QListView pour afficher un fichier en temps réel

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour,
Je rencontre un petit problème :
J'ai un fichier qui se remplit continuellement et j'aimerais l'ouvrir/l'afficher/le lire dans un QListview ou autre (si ça existe).

Je fais donc ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 QString fileName = "fichier.txt"; QFile fichier(fileName); fichier.open(QIODevice::ReadOnly); QByteArray data; while(!fichier.atEnd()) { data = fichier.readLine(); QString ligne(data); //traitement de la ligne }
Cependant j'ai deux problèmes :

1/ Je n'arrive pas à afficher ma "ligne" dans mon QListview. J'ai essayer listview.setText, listview.text,listview.SetPlainText, listview.setHtml et pleins d'autres méthodes mais je ne trouve pas la bonne.

2/ J'arrive à l'afficher en faisant cout << ligne.toStdString() << endl; mais il ne m'affiche qu'une fois le fichier c'est-à-dire pas les lignes créées depuis l'exécution.

Merci beaucoup de votre aide !

QListView est un widget qui utilise l'architecture Model-Vue-Constructeur (voir http://qt-project.org/doc/qt-4.8/mod...ogramming.html).

Il faut d'abord définir un modèle et l'appliquer au QListView, les classes de view-model sont définis ici : http://qt-project.org/doc/qt-4.8/model-view.html.

Pour ce que tu veux faire, tu utiliseras sûrement un QStringListModel qui se construit simplement à partir d'un QStringList.

Ainsi ton code donnera quelque chose comme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 QString fileName = "fichier.txt"; QFile fichier(fileName); fichier.open(QIODevice::ReadOnly); QByteArray data; QStringList linesList; while(!fichier.atEnd()) { linesList << QString(fichier.readLine()); } QStringListModel* model = new QStringListModel(linesList); this->_ListView->setModel(model); // le QListView ici

05/06/2012, 09h14
ceinpap

Bonjour,

Merci beaucoup, mon fichier se met bien dans mon QListView par contre cela met presque 10 secondes à s'afficher. Comment réduire de ce temps significativement?

J'ai un deuxième problèmes, les lignes créées après l'exécution de ce code ne s'affiche pas et j'ai besoin que les nouvelles lignes apprraissent.

Mais déjà un grand merci ! :ccool:
05/06/2012, 10h33
mitkl

Je sais pas si 10s c'est lent, je ne connais pas la taille du fichier mais j'imagine qu'il ne fait pas plusieurs centaines de Mo.

Pour les nouvelles lignes, c'est normal qu'elles ne s'affichent pas, actuellement tu vois le fichier tel qu'il était au lancement du programme. La meilleure chose à faire est de vérifier s'il y a eu des changements sur le fichier chaque seconde environ pour simuler un affichage temps-réel sans pour autant accroitre la surcharge du processus. Et s'il y a des changements, il faut tout simplement rafraichir le QListView. Evidemment, il faut faire le tout dans un QThread pour éviter de bloquer ton programme. :)
05/06/2012, 11h06
ceinpap

Mon fichier fait à peine 1mo mais il augmente tout le temps puisque c'est un fichier de log qui se remplit tout le temps.
Mais déjà la il met 10 secondes pendant lequel mon application est bloqué et je ne peut rien faire tant que le chargement du fichier n'est pas terminé.

Quand vous dîtes QThread, un QProcess doit pouvoir faire l'affaire nan ?

Mettre à jour le QListView je sais faire mais comment vérifier si il y a des changements ?

Non un QThread car un QProcess ferait référence à un appel vers un programme externe.

En effet c'est pas terrible quand le chargement bloque l'interface, c'est pourquoi il faudrait placer tout le code qui charge le fichier et affiche le QListView dans un thread différent, ce même thread qui se rafraichit toutes les secondes pour simuler une visualisation du log en temps réel. Mais avant de faire ça, il faut vraiment déterminer pourquoi ça met autant de temps à charger car une fois le code dans le thread qui se rafraichit, multiplier un code qui met déjà 10s à se charger c'est pas super.

Est-ce qu'on peut voir le code final du chargement du fichier et de l'affichage du multiview ? Quelque chose doit prendre trop de temps. Vu le code que j'ai déjà donné je pense que le problème vient d'ici :
Code:

1 2 3 4 5 while(!fichier.atEnd()) { linesList << QString(fichier.readLine()); }
On peut tester un autre code mais je garantis pas le résultat et je n'ai rien actuellement sous la main pour le tester. Au lieu de lire le fichier ligne par ligne pour convertir chaque QByteArray en QString et l'ajouter à un QStringList, on pourrait lire le fichier en entier, le convertir en QString et faire un split('\n') pour récupérer chaque ligne, split renvoyait directement un QStringList qu'on ajouterait ensuite au model.
Code:

1 2 3 4 5 6 7 8 9 QString fileName = "fichier.txt"; QFile fichier(fileName); fichier.open(QIODevice::ReadOnly); QByteArray data; QStringList linesList = QString(fichier.readAll()).split('\n'); QStringListModel* model = new QStringListModel(linesList); this->_ListView->setModel(model); // le QListView ici

Mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void MainWindow::test(){
    cout << "testing" << endl;
    QString tempPath = "/home/tmp3.txt";
    QFile tempToRead(tempPath);
    tempToRead.open(QIODevice::ReadOnly);
    QByteArray tempData;
    QStringList strList;
 
//##### AVEC QPLAIN TEXT #####//
    QString ligne2;
    while(!tempToRead.atEnd()){
 
        tempData = tempToRead.readLine();
        QString ligne(tempData);
        cout << "temp :" + ligne.toStdString() << endl;
        ligne2 += ligne;
 
    }
    ui->plainTextEdit->setPlainText(ligne2);
    cout << "done" << endl;
}

Et la fonction test() est appelée lors du clic d'un bouton.

Je vais tester avec un QThread et je vais aussi essayer votre deuxième code. Je vous tiens au courant. Merci beaucoup

05/06/2012, 14h03
mitkl

Ok, si ton code est lent c'est en partie à cause du cout dans ton while.
05/06/2012, 14h12
ceinpap

Vous avez complètement raison ! c'était juste pour tester et j'ai pas pensé à l'enlever, merci beaucoup :ccool:

Pour l'affichage au fil des nouvelles lignes ? Quel classe puis-je utiliser dans QT? QSocketNotifier (je n'arrive pas à l'utiliser) ?
05/06/2012, 15h53
mitkl

Je ne vois pas comment tu comptais faire avec QSocketNotifier mais fais au plus simple, tu peux par exemple utiliser QFileInfo pour récupérer la dernière date de modification via QDateTime QFileInfo::lastModified () const. Tu créés un membre de type QDateTime et chaque seconde tu compares, pour comparer, rien de plus simple, tu fais faire QDateTime2 > QDateTime1, ça fonctionne et dans ce cas, tu rafraichit l'affichage.
05/06/2012, 20h10
Troudhyl

QFileSystemWatcher est la classe qu'il te faut.
06/06/2012, 10h24
ceinpap

Merci à vous deux !

Troudhyl:J'ai réussi avec le QFileSystemWatcher par contre comment le mettre à jour sans recharger tout le fichier. En effet, j'aimerais seulement afficher les lignes nouvelles de mon fichier.

Parce qu’en fait j'ai des logs toute les secondes et du coup l'application plante au bout d'un moment car l'affichage est plus lent que les nouvelles lignes du logs.

Merci déjà pour toute l'aide apportée !

Cette classe est très intéressante, merci Troudhyl.

En lisant la doc, on peut faire quelque chose comme ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
 
// dans MyThread.h
class MyThread : public QThread
{
public:
     void setMainWindow(MainWindow*);
 
     // fonction réimplémenté
     void run();
 
protected:
     // on donne à notre thread un pointeur vers notre MainWindow pour pouvoir contrôler l'ui dans notre cas
     MainWindow* _mainWindow;
};
 
// dans MyThread.cc
 
void MyThread::setMainWindow(MainWindow* mainWindow)
{
     this->_mainWindow = mainWindow;
}
 
void MyThread::run()
{
    cout << "testing" << endl;
    QString tempPath = "/home/tmp3.txt";
    QFile tempToRead(tempPath);
    tempToRead.open(QIODevice::ReadOnly);
    QByteArray tempData;
    QStringList strList;
 
//##### AVEC QPLAIN TEXT #####//
    QString ligne2;
    while(!tempToRead.atEnd()){
 
        tempData = tempToRead.readLine();
        QString ligne(tempData);
        cout << "temp :" + ligne.toStdString() << endl;
        ligne2 += ligne;
 
    }
    this->_mainWindow->ui->plainTextEdit->setPlainText(ligne2);
    cout << "done" << endl;
 
//##### AVEC MODEL-VIEW ######//
/*
QString fileName = "/home/tmp3.txt";
QFile fichier(fileName);
fichier.open(QIODevice::ReadOnly);
QByteArray data;
 
QStringList linesList;
 
while(!fichier.atEnd())
{
    linesList << QString(fichier.readLine());
}
 
QStringListModel* model = new QStringListModel(linesList);
this->_ListView->setModel(model);
*/
}
 
// Dans MainWindow.h
 
public slots:
      fileChangedSlot(const QString & s);
 
protected:
      MyThread* _thread; // classe dérivant de QThread qui contient le code
      QFileSystemWatcher *_fileWatcher; // qui envoie les signaux au changement de fichier
 
// Dans MainWindow.cc, dans le constructeur
void MainWindow::fileChangedSlot(const QString & s)
{
 
...
 
_thread = new MyThread();
_thread->setMainWindow(this);
 
_fileWatcher = new QFileSystemWatcher(this);
_fileWatcher->addPath("/home/tmp3.txt");
 
connect(_fileWatcher, SIGNAL(fileChanged(const QString &)), this, SLOT(fileChangedSlot(const QString &)));
}
 
void MainWindow::fileChangedSlot(const QString & s)
{
   thread->start(); // qui appellera la méthode run
}

Voila, en gros on créé on dérive de QThread dans le but d'effectuer l'ouverture et l'affichage du fichier sans bloquer l'interface principale. Quand on dérive de QThread, on doit réimplémenter la méthode run(), j'ai donc mis ton code actuel dedans à la différence près que pour avoir le contrôle de ta class MainWindow, j'ai envoyé un pointeur à la class MyThread nouvellement créé. J'ai aussi inclus la solution Model-View en commentaire pour le QListView que j'avais mis dans un message précédent.

Vient ensuite l'utilisation du QFileSystemWatcher, utilisation basique, on connecte le signal fileChanged() à notre slot pour appeller le thread à la modification du fichier.

Le code est pas super bien indenté car j'ai copié-collé du code un peu partout et ne pas oublier aussi de remplir le destructeur de MainWindow. ;)

Oula ça devient compliqué pour moi ! :lol:

J'ai des problèmes de compilation, principalement dans MyThread.h.
Code:

1 2 3 4 5 */mythread.h:6: error: invalid use of incomplete type ‘struct QThread’ */usr/include/qt4/QtCore/qobject.h:69: error: forward declaration of ‘struct QThread’ */mythread.h:8: error: ‘MainWindow’ has not been declared */mythread.h:15: error: ISO C++ forbids declaration of ‘MainWindow’ with no type */mythread.h:15: error: expected ‘;’ before ‘*’ token
Je ne m'en sort pas, je suis un peu perdu :/

06/06/2012, 11h40
mitkl

Il manque les includes dans chaque fichier.
06/06/2012, 13h38
ceinpap

J'ai déjà include mainwindow.h dans tous les fichiers et mythread.h aussi :cry:
06/06/2012, 13h59
mitkl

colle tes fichiers, tu as sûrement des includes manquantes ou des inclusions mutuelles
06/06/2012, 15h35
ceinpap

J'ai toujours au moins cette erreur :

Code:

mainwindow.h:20: error: ISO C++ forbids declaration of ‘MyThread’ with no type

Sur cette ligne:

Code:

MyThread* _thread; // classe dérivant de QThread qui contient le code
06/06/2012, 15h59
mitkl

Es-tu vraiment sûr d'avoir mis #include "MyThread.h" dans les entêtes de ton fichier MainWindow.h ?

Selon l'organisation de tes includes, tu as peut-être besoin d'une déclaration anticipée, dans ce cas fait après tes includes :

Code:

class MyThread;
06/06/2012, 17h08
ceinpap
Oui j'en suis sur,
Le Class MyThread; a réglé le problème mais maintenant :

Code:

mythread.h:6: error: invalid use of incomplete type ‘struct QThread’

Code:

/usr/include/qt4/QtCore/qobject.h:69: error: forward declaration of ‘struct QThread’

Ligne 226: thread->start();
Code:

1 2 3 mainwindow.cpp:226: error: invalid use of member (did you forget the ‘&’ ?) mainwindow.cpp:226: error: base operand of ‘->’ is not a pointer

Voir 40 message(s) de cette discussion en une page