Discussion :

[kennylafougere]

Bonjour,

Voila je tente de faire mon 1er programme sous Qt et j'ai voulu utiliser le système MVC de Qt avec un QStandardItemModel et QListView. Le modèle et la vue sont dans 2 classes différentes (j'ai déclaré le QStandardItemModel en public pour faciliter l'accès).

je n'ai pas d'erreur de compilation mais quand je debug, j'ai un segfault sur la méthode setModel(). Pour préciser, j'utilise des pointeurs.

Y-a-t-il quelque chose en plus a déclarer dans la classe de la vue, un ordre a respecter dans sa construction (liaison vue/modèle a faire avant d'ajouter la vue dans une fenêtre)?

[ymoreau]

La doc sur le sujet est un peu longue, mais je pense qu'il n'est pas inutile de s'en imprégner car ce n'est pas une partie très facile je trouve. Pour commencer tu as un exemple minimal de model/view :
Model/View Programming

Pour ton problème il faudrait un minimum de code pour t'aider, tu dis utiliser une QListView, dans ce cas tu devrais plutôt utiliser QAbstractListModel. Car QAbstractItemModel est la classe la plus générique des modèles capable de gérer une arborescence plus complexe qu'une liste. QAbstractListModel est plus simple à utiliser.

Est-ce que tu es sûr que le segfault vient de setModel ? Il est plus probable que c'est lorsque la vue va appeler les fonctions du modèle (principalement data, et rowCount) que tu auras des problèmes, car c'est à ce niveau que tu dois toi même gérer l'accès aux données.

[kennylafougere]

Pour ce qui est de l'utilisation de QStandardItemModel avec QListView, je sais que sa ne parait pas logique mais c'est ce qui me semble le mieux concorder puisque je ne souhaite afficher que le 1er élément dans l'arborescence de chaque enregistrement.

Un peu de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//vue.h
...
private:
    QListView *vue1, *vue2;
...
 
//vue.cpp
vue::vue()
{
...
    vue1 = new QListView;
    vue2 = new QListView;
 
    vue1->setModel(PtrClassModel->PtrModel);
    vue2->setModel(PtrClassModel->PtrModel);
}
 
//ClassModel.h
...
public :
    QStandardItemModel *model;
...

Je n'ai pas mis le code du remplissage du modèle mais j'utilise le même pointeur sur un QStandardItem pour chaque enregistrement.
Est-ce problématique?

Sinon je ne suis pas sûr que le problème vienne de setModel() mais toujours est-il que quand je lance le débugger il bloque sur cette ligne.

[gbdivers]

Car QAbstractItemModel est la classe la plus générique des modèles capable de gérer une arborescence plus complexe qu'une liste.

En fait, la classe la plus "générique" est QAbstractItemModel. QStandardItemModel est un modèle "clé en main" permettant d'utiliser directement n'importe quelle structure de données derrière.

Normalement, tu as une structure de données et tu crées un modèle permettant d'y accéder (dérivant de QAbstractXXXModel : un QAbstractListModel si ta structure de données est une liste, QAbstractTableModel si ta structure est une table, QAbstractItemModel dans la cas général, etc.), en ré-implémentant les fonctions d'accès aux données : data, setData, etc.

QStandardItemModel permet d'utiliser directement un modèle sans avoir à redéfinir les fonctions data, setData, etc. et sans avoir besoin de créer une structure de données derrière. La conséquence de cette généricté est le coût en terme de performance.

Tu peux donc utiliser QStandardItemModel sans problème. Et avec n'importe quelle vue.

Je n'ai pas mis le code du remplissage du modèle mais j'utilise le même pointeur sur un QStandardItem pour chaque enregistrement.
Est-ce problématique?

Regarde les exemples de code dans QStandardItemModel : il faut créer un nouvel QStandardItem pour chaque nouvel élément inséré dans le modèle.

Sans information détaillée, je pense que le problème vient de là.

[kennylafougere]

Il y a effectivement un problème avec le modèle.
Je déclare maintenant un nouveau pointeur QStandardItem pour chaque enregistrement et maintenant sa me donne plus de précision puisque je bloque dans QAbstractItemView.cpp sur cette ligne dans setModel() :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
// These asserts do basic sanity checking of the model
    Q_ASSERT_X(d->model->index(0,0) == d->model->index(0,0),
               "QAbstractItemView::setModel",
               "A model should return the exact same index "
               "(including its internal id/pointer) when asked for it twice in a row.");

Si j'ai bien compris, sa vérifie la validité du modèle.

histoire de donner plus d'info, mon modèle gère un parc informatique (rempli grâce à un fichier .csv) et chaque enregistrement correspond a une association nom d'hôte / adresse mac (d'où le QListView puisque je n'affiche que le nom) dont voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//Parc.h
#ifndef PARC_H
#define PARC_H
#include <string>
#include <fstream>
#include <iostream>
#include <sstream>
#include "gui.h"
#include <QStandardItemModel>
#include <QStandardItem>
 
class Parc
{
 
    public :
        Parc();
        void setInterface(Gui &maGui);
        QStandardItemModel *ParcInfo;
 
    private :
        Gui *PtrGui;
};
#endif // PARC_H

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
//Parc.cpp
#include "parc.h"
 
Parc::Parc()
{
 
    ParcInfo = new QStandardItemModel();
 
    // le constructeur de ifstream permet d'ouvrir un fichier en lecture
    std::ifstream fichierListeParc("listeParc.csv");
    if ( fichierListeParc )
    {
        std::string ligne;
        std::stringstream iss;
        std::string mot;
        std::string nom;
        std::string mac;
        bool passed = false;
 
        while (std::getline( fichierListeParc, ligne))
        {            
            QStandardItem *itemNom = new QStandardItem();
            QStandardItem *itemMac = new QStandardItem();
            iss.str(ligne);
            while(std::getline(iss, mot, ','))
            {
                if(!passed)
                    nom = mot.c_str();
                else
                    mac = mot;
                passed = true;
            }
            itemNom->setText(QString::fromStdString(nom));
            itemMac->setText(QString::fromStdString(mac));
            ParcInfo->appendRow(itemNom);
            itemNom->appendRow(itemMac);
            iss.clear();
            passed = false;
        }
        fichierListeParc.close();
    }
    else
    {
        PtrGui->AffMsg1("erreur a l'ouverture du fichier");
    }
}
 
void Parc::setInterface(Gui &maGui)
{
    PtrGui = &maGui;
}

edit : les items récupèrent les bonnes valeurs mais n'ont pas l'air de s'ajouter au modèle quand j'appel ParcInfo->appendRow().

[gbdivers]

Bonjour

Un peu de lecture

J'ai testé ton code, il fonctionne correctement...

Tu crées bien d'abord ton modèle puis la vue ? (puisque tu donnes le modèle à la vue dans le constructeur de la vue)

Plusieurs remarques :

- Pas besoin d'utiliser un pointeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QStandardItemModel *ParcInfo;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QStandardItemModel ParcInfo;

- Qt fournit des outils de manipulation de fichier plus "mieux" que les streams standard. A utiliser (en complément avec QTextStream et QString) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::ifstream fichierListeParc("listeParc.csv");

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

QFile file("listeParc.csv");

- Si ton modèle ne contient qu'une liste de chaine de caractères, tu peux utiliser directement QStringListModel, qui est un modèle utilisant une liste comme structure de données.

Et dans ce cas, tu n'as pas besoin de lire l'adresse MAC.

- Si au contraire, tu souhaites quand même conserver l'adresse MAC dans le modèle (pour un usage éventuel ultérieur, ce qui évitera de lire 2 fois le fichier si tu en as besoin), je pense qu'il vaut mieux stocker les données sous forme de table dans le modèle plutôt que sous forme d'arbre.

Actuellement, avec la ligne suivante, tu stockes l'adresse MAC comme enfant du nom, d'où une structure en arbre (tu peux le vérifier en utiliser un QTreeView à la place d'un QListView, ça fonctionne sans problème).

Pour stocker les données sous forme de table, tu dois ajouter les éléments avec setItem(row, col, item). Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
ParcInfo.setItem(row, 0, new QStandardItem(QString::fromStdString(nom)));
ParcInfo.setItem(row, 1, new QStandardItem(QString::fromStdString(mac)));
++row;

Pour l'affichage, ça ne change rien : utiliser une QListView affichera la première colonne de la table.

- Tu donnes un pointeur vers ta classe GUI = couplage fort entre tes classes = maintenance plus complexe, que tu pourrais éviter en utilisant les signaux/slots.

- Tu utilises le pointeur vers ta classe GUI pour afficher une erreur de lecture du fichier dans le constructeur, alors que tu fournis ce pointeur à ta classe modèle dans une autre fonction. En cas d'erreur de lecture du fichier, tu essaies donc d'utiliser un pointeur invalide = erreur !

Le code final pourrait ressembler à :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
#ifndef MA_VUE_H
#define MA_VUE_H
 
#include <QtGui/QListView>
#include <QStandardItemModel>
#include <QtCore/QFile>
#include <QtCore/QTextStream>
#include <QtCore/QStringList>
 
class MaVue : public QListView
{
    Q_OBJECT
 
public:
    MaVue(QWidget *parent = 0) : QListView(parent)
    {
        QFile file(":/ListeParc.csv");
 
        if (file.open(QIODevice::ReadOnly | QIODevice::Text))
        {
            QTextStream in(&file);
            QString line = in.readLine();
 
            int row = 0;
 
            while (!line.isNull())
            {
                QStringList list = line.split(',');
                for (int col=0; col<list.size(); ++col)
                    model.setItem(row, col, new QStandardItem(list[col]));
                ++row;
 
                line = in.readLine();
            }
            // file.close(); inutile, appelé par destructeur de QFile
 
            setModel(&model);
        }
    }
 
private:
    QStandardItemModel model;
};
 
#endif // MA_VUE_H