Modèle-vue-délégué

Version imprimable

07/11/2019, 18h03
Tnerual42

Modèle-vue-délégué

Bonjour à tous,

Je suis entrain de développer enfin d'essayer, une application de gestion de devis et de factures.
J'ai bien avancé, mais là je bloque sur l'architecture Model / view delegate....

Je m'explique, lorsque je lance mon application la vue est chargée uniquement avec les entêtes: libellé, prix ht etc... (c'est ce que je souhaite), ensuite je recherche les articles à ajouter à mon devis depuis une boite de dialogue qui enrichis mon model en fonction de mes demandes (cela fonctionne), par contre la vue ne ce met pas à jour et je bloque, je n'arrive pas à trouvé une fonction me permettant de le faire !!!
Si quelqu'un à une idée je suis preneur.

Par avance merci.
10/11/2019, 20h30
koala01
Salut,

Avec un peu de code, nous aurions, sans aucun doute, beaucoup plus facile à t'aider ;)

Tu n'est pas obligé de nous fournir le code de tout le projet, mais le code de la fonction qui met ton modèle à jour serait surement intéressant, car il nous donnerait une bonne idée de ce qu'il te manque ;) :D

Ceci étant dit, je présumes que tu ajoutes des éléments avec les fonction insertRow(s) / insertColumn(s) de ton modele.

L'idee, c'est que, avant de faire appel à cette fonction, tu appelle la fonction beginInsertXXX (remplace le XXX par Rows / Columns selon ta situation particulière) et que, une fois que tu as ajouté l'ensemble des éléments qui t'intéressent, tu fasse appel à la fonction endInsertXXX équivalente.

Ces deux fonctions vont obliger le modèle à émettre des signaux (auxquels ta vue est normalement déjà connectée) indiquant le début et la fin de la mise à jour de ton modèle :
- le signal de début de la mise à jour du modèle va sans doute empêcher la modification des valeurs des éléments visibles (et modifibles, s'il y en a, bien sur)
- le signal de fin de la mise à jour va réactiver la modification des valeurs des éléments visibles (et modifiables, s'il y en a, bien sur) et forcer la vue à se mettre à jour ;)

Bonsoir Kohala01,

Tout d'abord merci pour ton attention.

Effectivement, j'aurais pu mettre un exemple, mais je souhaitais que la discussion soit engagée afin de mettre les morceaux de code demandé pour éviter de polluer l’énoncé du PB. Voici la fonction qui met mon model à jour:

Code:

1
2
3
4
5
6
7
8
9
 
void CreateDevis::ajouterMateriel(QString strNomArticle)
{
   std::cout <<"AjouterMateriel : " << strNomArticle.toStdString() << std::endl;
   model->requette(strNomArticle);//Fonction qui recupere les infos de l'article dans une BDD (prix, ref etc...)
   std::cout <<"Nombre de ligne du model: " << model->rowCount() << std::endl;
   //Le model est bien mis à jour, mais pas la vue,
   //et là je ne sais pas pourquoi....
}

Et voici la fonction membre requette() de mon model, chargée de récupérer les informations de la BDD:

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
 
void ModelDevis::requette(QString str )
{
    lineItem *item = new lineItem;
 
    //Récupération des données souhaitées:
    //Utilisation de bindValue et boundValue de Qt:
    query.prepare("SELECT nom_article, ref_four,"
                  "prix_achat_ht, prix_vente_ht"
                  " FROM materiel.electrique WHERE nom_article = :nom ");
    query.bindValue(":nom", str.toUpper());//Permet de ce positionner à la bonne ligne:
    query.exec();
 
 
    while(query.next())
    {
        item->setRef(query.value(1).toString());
        item->setLabel(query.value(0).toString());
        //lineitem->setQuantite(query.value(x).toString());
        item->setPrixAchat(query.value(2).toString());
        item->setPrixVente(query.value(3).toString());
 
        lineitem.append(item);
     }
}

Enfin voici la methode virtuelle data() redéfinis pour mon model personnalisé:

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
 
QVariant ModelDevis::data(const QModelIndex &index, int role) const
{
    int row = index.row();
    int col = index.column();
if(role == Qt::DisplayRole)
  {
    if (col == 0)
        return lineitem[row]->getLabel();
    if (col == 1)
        return lineitem[row]->getRef();
    if (col == 2)
        return lineitem[row]->getPrixAchat();
    if (col == 3)
        return lineitem[row]->getPrixVente();
    if (col == 4)
        return lineitem[row]->getLabel();
 
  for(auto x = 0; x<rowCount();x++){
        for(auto y = 0; y<columnCount();y++){
            return Qt::AlignRight + Qt::AlignVCenter;
        }
    }
 }
    //emit dataChanged(index, index);
      return QVariant();
}

Mon model se met bien à jour, mais pas la vue, par contre il est vrai que je n'utilise pas les fonctions insertRow(s) / insertColumn(s) ni même
beginInsertXXX, j'avoue avoir un peu de mal à comprendre les subtilités des Model/view deleguate....
Quand pensez vous ?

Du coup je viens de relire la documentation Qt (je galère un peu avec l'anglais :roll:), mais grâce a vos informations je me suis concentré
sur les fonctions insertRow(int row, const QModelIndex &parent = QModelIndex()) et beginInsertRows(const QModelIndex &parent, int first, int last).
Ensuite j'ai implémenté la fonction insertRowinsertRow(int row, const QModelIndex &parent = QModelIndex()), puis je l'ai surchargée afin
d’appeler la méthode requette(QString) directement et tout fonctionne comme je le souhaite.

Merci beaucoup pour votre aide.

Voici la fonction concernée:
Code:

1 2 3 4 5 6 7 8 bool ModelDevis::insertRow(int row, const QModelIndex &index, QString data) { this->beginInsertRows(index,this->rowCount(),this->rowCount()); requette(data); this->endInsertRows(); nbrLigne += 1; return true; }

12/11/2019, 03h46
koala01

Citation:

Envoyé par Tnerual42

Merci beaucoup pour votre aide.

Ce fut un plaisir ;)

Mais je suis très mal à l'aise par rapport à ton code, car, selon moi, ta requête SQL n'a rien à faire dans l'histoire. Je m'explique.

Quand tu décide d'ajouter une ligne à ton devis (typiquement, lorsque tu en vient à appeler la fonction ajouterMateriel ), tu ne va -- normalement -- pas laisser l'utilisateur de ton application essayer d'ajouter un matériel "tiré du néant" à ton devis:

L'un dans l'autre, tu vas lui présenter (sans doute dans un formulaire séparé) une liste des matériaux présents dans la base de données, parmi laquelle il pourra en choisir un qui sera ajouté au devis.

Ta requête SQL devrait donc, dans l'idéal, prendre place... au niveau de ce formulaire séparé, et tu devrais donc récupérer de ce formulaire l'ensemble des informations (une QStringList me semble pas mal pour l'occasion) correspondant au matériau sélectionné, et qui serait transmise à ta fonction ajouterMatériel.

Je vais réfléchir pour te donner une idée précise de ce que je ferais si j'étais toi, mais, une chose est sure : quand on en arrive au point de provoquer l'ajout d'un élément à ton devis, il n'est clairement plus temps de faire une requete SQL pour savoir ce qu'il faut y ajouter ;)
12/11/2019, 19h51
Tnerual42

Citation:

Envoyé par koala01

Mais je suis très mal à l'aise par rapport à ton code, car, selon moi, ta requête SQL n'a rien à faire dans l'histoire. Je m'explique.

Il est vrai que je me suis posé la question concernant l’intégration des requêtes SQL au sein de mon code au début de mon projet. Car effectivement j'ai plusieurs fenêtres graphiques qui communiquent avec la base de données pour afficher des informations, afin de m'aider à choisir. Pour ce cas voici la logique que j'ai choisi: Depuis la fenêtre principale, j'ai un menu devis-facture dans laquelle j’accède à l'action de créer un nouveau devis ce qui génère:

- Appel de la class créatDevis() qui contient l'interface graphique dont la vue tableView() des articles et de la main d’œuvre du devis.
- Depuis cette interface j’accède via un bouton connecté au slot rechercheMateriel() à une nouvelle boite de dialogue.
- Ce dlg me permet d'affiner mon choix, elle affiche notamment un QComboBox me proposant du matériel (uniquement leur nom) en fonction de cases à cocher (afin de limiter ces propositions).
- Lorsque je valide mon choix en cliquant sur un bouton ajouter j'appelle un nouveau slot dont la connexion se fait depuis la fonction rechercheMateriel(), ainsi je récupère le Qstring (nom de l'article) qui me permet de faire une requête SQL ciblée pour récupérer les informations nécessaires au devis (prix ht, ref etc...) c'est à ce moment la qu’intervient la mise à jour de mon model et ensuite de la vue.

Il est vrai que je pourrai utiliser la requette SQL en amont et plutôt que de communiquer un Qstring communiquer directement une QlistItem, si selon vous c'est une meilleure pratique je le ferai car le but principal de ce développement est d’apprendre les bonnes pratiques des le départ.
Qu'en pensez vous? si besoin je peux vous communiquer des extraits de code.

Ce qu'il faut comprendre, c'est que toutes les données que tu vas afficher (je vais parler de "données métier") sont typiquement toujours les mêmes, peu importe la manière dont elles sont affichées : elles représentent toutes, dans le cas qui nous intéresse, du matériel électrique, qui pourraient très bien toujours être représentées sous la forme d'une structure regroupant toutes les informations qui nous intéressent et qui serait proche de

Code:

1
2
3
4
5
6
7
8
/* je me suis basé sur la requête SQL que tu présentais plus tôt */
struct Materiel{
    QString nom;
    Categorie categorie; // c'est du cable, un interrupteur, un socket de lampe, une prise, ...
    int refFournisseur;
    int prixAchat; // tu peux, bien sur, adapter le type
    int prixVente; // de prixAchat et de prixVente
};

Au travers des différents modèle, il n'y a qu'une seule chose qui change: les informations -- extraites de cette strutures -- qui seront transmises à la vue afin d'être affichées.

De plus, on peut s'attendre à ce que la liste des différents matériels disponibles ne change que très rarement dans la base de données : ce n'est en effet "pas tous les jours" que tu décidera de proposer un matériel supplémentaire ;) . Une chose est sure : tu ne vas surement pas décider d'ajouter un nouveau matériel à la vente alors que tu es occupé à calculer un devis :P

L'idéal serait donc de "charger" cette liste (en utilisant une QList<Materiel> selon mon exemple) "une bonne fois pour toute", et de faire en sorte que tous tes modèles (et, de manière générale, tous les éléments qui auront besoin d'accéder à une information à une autre concernant un des matériel éléctrique) puissent y accéder.

Le meilleur endroit pour accéder à cette liste semble donc être ta classe dérivée de QMainWindow, qui prendrait dés lors une forme proche de

Code:

1
2
3
4
5
6
7
8
9
10
class MainWindow: public QMainWindow{
    Q_OBJECT;
public:
    Application();
    /* je passe tout le reste */
privatte:
    /* je ne présente que ce qui m'intéresse */
    void loadFromDataBase(); // parce que la liste devra être chargée à un moment ou à un autre
    QList<Materiel>  m_materiels;
}

avec une implémentation proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
MainWindow::MainWindow(): QMainWindow(){
   // on crée l'ensemble des boutons, menus et autres joyeusetés
   // on termine en chargeant la liste des matériel disponibles
   loadFromDataBase();
}
void MainWindow::loadFromDataBase(){
    /* C'est ici que la requête SQL est exécutée, elle permet de remplir
     * la liste des éléments disponibles (m_materiels)
     */
    QSqlQuery query;
    query.prepare("Select * from materiel.electrique"); // on veut toutes les informations relatives à tous les enregistrements
    query.exec();
    while(query.next()){  //tant qu'il y a un enregistrement à gérer
        Materiel temp; // on crée une nouvelle instance de notre structure
        temp.nom = query.value(0).toString(); // le nom
        temp.categorie = query.value(1).toInt(); // la catégorie
        temp.refFournisseur = query.value(2).toInt(); // le fournisseur
        temp.prixAchat = query.value(3).toInt(); // le prix d'achat
        temp.prixVente = query.value(4).toInt(); // le prix de vente
        m_materiels << temp; // on ajoute le matériel à la liste
    }
}

Une fois que cette liste sera chargée, il te suffira de la transmettre, sous forme d'une référence (constante, le plus souvent, c'est à dire sous la forme de [c]QList<Materiel> const & tousLeMateriel) "de proche en proche" à tous les modèles qui devront l'utiliser.

Par exemple, si tu veux remplir un combobox, tu pourrais envisager la création d'un modèle proche de

Code:

1
2
3
4
5
6
7
8
9
class ModeleNomSeul : public QAbstractModel{
   /* je n'indique que ce qui m'intéresse */
public:
    ModeleNomSeul(QList<Materiel> const & mat);
    QVariant data(QIndexModel model, int role);
private:
    QList<Materiel> const & m_materiels; // une référence, parce que je ne veux pas que cette liste soit copiée
                                         // une référence constante parce que je ne veux pas que ce modèle la modifie
};

dont l'implémentation ressemblerait à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
ModeleNomSeul::ModeleNomSeul(QList<Materiel> const & mat):m_materiels{mat}{
}
 
QVariant ModeleNomSeul::data(QIndexModel model, int role){
   int row = index.row();
   int column = index.column();
   auto const & mat = m_materiels.at(row);
   if(role == Qt::DisplayRole){
      switch (column){
          case 0:
              return mat.nom; 
          case 1:
              return row;  // permet de récupérer l'indice de l'élément dans la liste des matériels disponibles
   }
   return QVariant;
}

Tu veux afficher toutes les informations, par exemple, pour dresser la liste de ton stock:question: On peut faire pareil, en adaptant simplement la fonction data d'un modèle que nous appellerions volontier ModeleComplet:

Code:

1
2
3
4
5
6
7
8
9
class ModeleComplet: public QAbstractTableModel {
   /* je n'indique que ce qui m'intéresse */
public:
    ModeleComplet(QList<Materiel> const & mat);
    QVariant data(QIndexModel model, int role);
private:
    QList<Materiel> const & m_materiels; // une référence, parce que je ne veux pas que cette liste soit copiée
                                         // une référence constante parce que je ne veux pas que ce modèle la modifie
};

dont l'implémentation ressemblerait à quelque chose comme

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
ModeleComplet::ModeleComplet(QList<Materiel> const & mat):m_materiels{mat}{
}
 
QVariant ModeleComplet::data(QIndexModel index, int role){
   int row = index.row();
   int column = index.column();
   auto const & mat = m_materiels.at(row);
   if(role == Qt::DisplayRole){
      switch(row){
          case 1:
             return mat.nom;
          case 2:
             return mat.categorie;
          case 3:
             return mat.refFournisseur;
          case 4:
             return mat.prixAchat;
          case 5:
             return mat.prixVente;
      }
   }
   return QVariant;
}

Pour le modèle utilisé pour le devis, ce sera encore pareil, mais il va falloir chipoter un peu, car:

c'est un modèle "dynamique" : on va y ajouter des éléments "au fur et à mesure"
on voudra sans doute indiquer le nombre de chaque élément du devis qui sera fourni
on n'a pas envie que le client connaisse nos fournisseurs
on auras sans doute besoin d'afficher la catégorie sous une forme compréhensible (ex "interrupteur" et non sous une vague référence (1 ou 15)
on n'a pas envie que le client sache à quel point on se "sucre sur son dos"

On va donc partir du même principe, mais comme notre structure Materiel ne présente aucune information de quantité, nous allons créer -- en interne pour le modèle -- une structure qui permet de faire la liaison entre un des éléments de la liste de matériel et la quantité que l'on prévoit de fournir. Le modèle prendra donc une forme proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class ModeleDevis: public QAbstractTableModel {
   /* faire le lien entre les éléments sélectionnés et la quantité fournie est simple:
    * il suffit de maintenir l'index de l'élément sélectionné et la quantité fournie sous
    * une forme proche de
    */
   struct Fourniture{
       int index;   // l'indice du matériel fourni dans la liste m_materiels
       int quantité;// la quantite fournie
   }
public:
    ModeleDevis(QList<Materiel> const & mat);
    /* parce que l'on veut pouvoir ajouter des lignes au devis */
    void ajouterFourniture(int index, int quantite);
    QVariant data(QIndexModel model, int role);
    /* parce que l'on veut pouvoir modifier la quantité fournie de quelque chose à tout moment */
    bool setData(onst QModelIndex &index, const QVariant &value, int role = Qt::EditRole);
private:
    QList<Materiel> const & m_materiels; // une référence, parce que je ne veux pas que cette liste soit copiée
                                         // une référence constante parce que je ne veux pas que ce modèle la modifie
    QList<Fourniture> m_fournitures; 
};

dont l'implémentation ressemblerait à quelque chose comme

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
ModeleDevis::ModeleDevis(QList<Materiel> const & mat):m_materiels{mat}{
}
 
QVariant ModeleComplet::data(QIndexModel index, int role){
   int row = index.row();
   int column = index.column();
   auto const & four = m_fournitures.at(row);
   int matIndex = four.mat;
 
   switch(role){
      case Qt::DisplayRole:
          auto const & mat = m_materiels.at(matIndex);
          switch(row){
             case 1:
                return mat.nom;
             case 2:
                /* faudra chipoter ici pour avoir une chaine de caractères */
                return mat.categorie;
             case 3:
                return mat.prixVente;
             case 4 :  // la quantite
                return four.quantite;
              case 5: // le total au vu de la quantite
                return four.quantite * mat.prixVente; 
         }
   return QVariant;
}
 
void ModelDevis::ajouterFourniture(int index, int quantite){
    /* je te laisse faire le plus gros, mais il faudra terminer par
     * quelque chose comme
     */
   Fourniture four;
   four.index = index;
   four.quantite= quantité;
   m_fournitures << temp; 
}
 
bool ModelDevis::setData(onst QModelIndex &index, const QVariant &value, int role = Qt::EditRole){
   int row = index.row();
   int column=index.column();
   auto & four = m_fournitures.at(row);
   if(role == Qt::EditRole){
       /* parce que l'on n'accepte la modification que de la quantite */
      if(colum == 4){
          four.quantite = value.toInt();
          return true;
      }
   }
   return false;
}

Avoue que cela te facilitera énormément la tâche, non :question:

13/11/2019, 21h31
Tnerual42

Citation:

Envoyé par koala01

Avoue que cela te facilitera énormément la tâche, non :question:

Vos explications sont claires précises et agrémenté d’exemple vraiment bravo.
Il est clair que cela me facilitera grandement la tâche et rendra le code ainsi que son organisation plus clair, plus logique.
Je vais reprendre mon application afin de mettre en pratique vos conseils qui mon permis de mieux comprendre comment organiser
mes différentes class.

Et encore merci d'avoir pris le temps de me conseiller.:D