Double clic non désiré

Bonjour,

Je m'adresse à vous, car je suis un peu en panne là.

J'utilise deux formes dans mon programme.
Ma forme de base, entre autres comporte un slot relié à un bouton, qui me sert à ouvrir puis refermer une fenêtre.
Ma forme dérivée, qui sert à étendre les fonctionnalités de la première.

Tout fonctionne parfaitement sauf un truc :
Lorsque je clique sur le bouton dans la forme dérivée, le slot du bouton est parcouru deux fois. Cela me gène dans la mesure où il s'agît d'un bouton on/off.
Pour être plus précis, j'ai implémenté les deux dans des programmes identiques dont main appelle simplement un objet respectivement de chaque classe. Celui qui utilise QMBase fonctionne normalement, clui qui utilise QMNation passe deux fois dans le slot quand on clique le bouton bnListe.

Description des classes :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class QMBase : public QWidget { Q_OBJECT ... private slots: // Visualiser/masquer la liste pour pouvoir rechercher des éléments. void on_bnListe_clicked(); ... }; class QMNation : public QMBase { Q_OBJECT ... };
Quelqu'un peut-il me dire pourquoi ce comportement, et comment y remédier svp?

Merci de vos réponses :)
A bientôt
M.P.

PS. J'utilise QT creator SDK et BMBase a été créée avec Designer, alors que la forme de QMNation a été codée à la main (je ne sais pas sous-classer avec Designer).

Bonjour,
Je ne vois pas d'où peut venir ce problème mis à part peut-être un problème de souris ?

J'ai une souris qui actuellement, suivant où mon doigt est placé sur le bouton, va double-cliquer (usure partielle de la touche, sur le bouton du circuit, qui provoque un double clic)... ça ne double-clique pas systématiquement, mais vraiment en fonction de comment ma main est positionnée sur la souris. Essaye de regarder déjà si ton problème viendrait pas d'un problème dans ce style (en essayant avec une autre souris).

Si c'est vraiment interne au développement. Je ne sais pas vers quoi me diriger, as tu essayé de faire un nettoyage de ton projet? Sinon il faudra ~~peut-être~~certainement plus de code pour t'aider.

Plus de ton code pour t'aider est en effet nécessaire.

Bonjour,

Tout d'abord, merci de l'intérêt que vous portez à ma question.

Voici donc le code complet des différentes fenêtres en jeu :

Ma classe de base. Rappelons que c'est elle qui est chargée de gérer l'affichage de la fenêtre appelée :
header :

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
#ifndef QMBASE_H
#define QMBASE_H
 
#include <QWidget>
 
QT_BEGIN_NAMESPACE
class QDataWidgetMapper;
class QItemSelectionModel;
class QSqlRelationalTableModel;
class QSqlTableModel;
class QStandardItemModel;
class QStringListModel;
class QSqlRecord;
class QLabel;
QT_END_NAMESPACE
 
class QMListe;
 
namespace Ui {
    class QMBase;
}
 
class QMBase : public QWidget
{
    Q_OBJECT
 
public:
    explicit QMBase(QString tableName, QSqlTableModel *modele=0, bool toSet=true, QWidget *parent = 0);
    ~QMBase();
 
    // Assigner le modèle associé à la table à la vue.
    // Par défaut, un QSqlTableModel est utilisé.
    // On suppose que la table comporte au moins un champs id (PK autoinc)
    // et Nom (index unique).
    // Les modèles proposés doivent descendre de QSqlTableModel.
    // Mettre toSet à 0 si le modèle a déjà été initialisé.
    // Dans ce cas, il ne sera pas tenu compte du paramètre tableName,
    // et le modèle ne sera pas initialisé (pour permettre de fournir un modèle tout prêt).
    void setModel(QString tableName, QSqlTableModel *modele=0, bool toSet=true);
 
protected:
    // Fonction virtuelle à surcharger pour compléter les connexions du mapper.
    // Ne pas oublier d'appeler le parent, sinon pas de lien avec le nom.
    virtual void populateMapper(QDataWidgetMapper *mapper);
 
    // Evènement de fermeture. La fermeture de la forme doit aboutir à la fermeturé
    // conjointe de la liste, si elle a été ouverte.
    void closeEvent(QCloseEvent *event);
 
    // Permettre aux enfants d'accéder à la forme (pour la compléter)
    Ui::QMBase *getUi() const;
 
    // Et au mapper
    QDataWidgetMapper *getMapper() const;
private slots:
 
    // Visualiser/masquer la liste pour pouvoir rechercher des éléments.
    void on_bnListe_clicked();
 
    // Ce slot est sensé être appelé lorsque la liste du modèle change.
    // Dans la pratique j'ai constaté qu'il n'en est rien. Il est donc utilisé
    // comme une simple fonction, appelée pour mettre la longueur de la liste
    // à jour.
    void on_layoutChanged();
 
    // Lorsque l'utilisateur désire insérer un nouvel élément dans la base.
    // Insère un élément vierge dans la base.
    void on_bnNouveau_clicked();
 
    // Lorsque l'utilisateur désire supprimer l'élément actuellement sélectionné
    // De la base. Pas de confirmation à l'heure actuelle.
    void on_bnSupprimer_clicked();
 
    // Synchroniser la base avec les éléments de la forme.
    // Si l'utilisateur change d'enregistrement sans avoir effectué cette opération,
    // ses modifications sont perdues.
    void on_bnEnregistrer_clicked();
 
    // Annuler toutes lezs modifications non enregistrées.
    // Je pensais que celéa pouvait agir sur plusieurs enregistrements,
    // mais il n'en est rien.
    void on_bnAnnuler_clicked();
 
private:
    Ui::QMBase *ui;
 
    // Modèle utilisé pour visualiser les données.
    QSqlTableModel *model;
 
    // Mapper utiliser pour effectuer la liaison entre le modèle et les widgets.
    QDataWidgetMapper *mapper;
 
    // Liste à visualiser quand on veut naviguer.
    QMListe *liste;
 
    // Se charge de la création du mapper. Appelle la fonction populateMapper
    // pour permettre aux enfants de compléter le mappage des liens.
    void createMapper();
 
    // Se charge d'initialiser les connexions signal/slot
    // Cette fonction n'est pas virtuelle, car les signaux doivent être créés
    // après les objets qu'ils connectent.
    void setupConnexions();
};
 
#endif // QMBASE_H

Source :

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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
#include "qmbase.h"
#include "ui_qmbase.h"
#include "qmliste.h"
#include <QtSql>
#include <QDataWidgetMapper>
#include <QMessageBox>
#include <QCloseEvent>
 
QMBase::QMBase(QString tableName, QSqlTableModel *modele, bool toSet, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::QMBase),
    model(0),
    liste(new QMListe())
{
    ui->setupUi(this);
    setModel(tableName, modele, toSet);
    createMapper();
    setupConnexions();
    liste->hide();
    on_layoutChanged();
}
 
QMBase::~QMBase()
{
    delete liste;
    delete ui;
    delete model;
}
 
void QMBase::setModel(QString tableName, QSqlTableModel *modele, bool toSet)
{
    if (!model || model != modele) {
        delete model;
        if (!modele)
            modele = new QSqlTableModel(this);
        model = modele;
        if (toSet) {
            model->setTable(tableName);
            model->setEditStrategy(QSqlTableModel::OnManualSubmit);
            model->select();
        }
        liste->setModel(model);
    }
}
 
void QMBase::setupConnexions()
{
    connect(ui->vsNavi, SIGNAL(valueChanged(int)), mapper, SLOT(setCurrentIndex(int)));
    connect(mapper, SIGNAL(currentIndexChanged(int)), ui->vsNavi, SLOT(setValue(int)));
    connect(model, SIGNAL(layoutChanged()), this, SLOT(on_layoutChanged()));
    connect(liste, SIGNAL(rowSelected(int)), mapper, SLOT(setCurrentIndex(int)));
}
 
void QMBase::on_layoutChanged()
{
    int nombre = model->rowCount();
    ui->vsNavi->setMaximum(nombre);
    if (ui->vsNavi->value()>=nombre)
        ui->vsNavi->setValue(nombre);
    if (ui->vsNavi->value() < 0)
        ui->vsNavi->setValue(0);
    ui->lbNbre->setText(QString::number(nombre));
}
 
void QMBase::createMapper()
{
    mapper = new QDataWidgetMapper;
    mapper->setModel(model);
    this->populateMapper(mapper);
    mapper->toFirst();
}
 
void QMBase::populateMapper(QDataWidgetMapper *map)
{
    map->addMapping(ui->eId, model->fieldIndex("id"));
    map->addMapping(ui->eNom, model->fieldIndex("Nom"));
}
 
void QMBase::on_bnListe_clicked()
{
    if (liste->isVisible()) {
        ui->bnListe->setText("liste >>>");
        liste->hide();
    }
    else {
        ui->bnListe->setText("liste <<<");
        liste->move(x()+frameGeometry().width(), y());
        liste->show();
    }
}
 
void QMBase::on_bnNouveau_clicked()
{
    // Si des modifications sont en cours, il faut les enregistrer.
    model->submitAll();
    // Du fait qu'il s'agît d'un autoinc, le champs id n'est pas touché.
    // C'est la BDD qui en définit la valeur.
    // Essayons ...
    int row = model->rowCount();
    if (model->insertRow(row))
        if (model->setData(model->index(row,  model->fieldIndex("Nom")), "Nouvelle")) {
            // Dans le cas où des champs seraient définis comme obligatoires (notnull)
            // il sera nécessaire de prévoir une fonction de rappel pour ajouter ces champs
            // avec une valeur donnée (soit définie à travers les relations)
            // setInsertData(model);
            model->submitAll();
            mapper->toLast();
            on_layoutChanged();
        }
}
 
void QMBase::on_bnSupprimer_clicked()
{
    int row = mapper->currentIndex();
    model->removeRow(row);
    model->submitAll();
    on_layoutChanged();
}
 
void QMBase::on_bnEnregistrer_clicked()
{
    model->database().transaction();
    if (model->submitAll()) {
        if (!model->database().commit())
            QMessageBox(QMessageBox::Critical, "Erreur d'enregistrement",
                        "Les modifications n'ont pu être prises en compte par\n"
                        "la base de données. \nErreur : " + model->lastError().text());
    } else {
        QMessageBox(QMessageBox::Critical, "Erreur d'enregistrement",
                    "Les modifications n'ont pu être enregistrées dans\n"
                    "la base de données. \nErreur : " + model->lastError().text());
    }
}
 
void QMBase::on_bnAnnuler_clicked()
{
    model->revertAll();
}
 
void QMBase::closeEvent(QCloseEvent *event)
{
    if (liste->close())
        event->accept();
    else
        event->ignore();
}
 
Ui::QMBase * QMBase::getUi() const
{
    return ui;
}
 
QDataWidgetMapper * QMBase::getMapper() const
{
    return mapper;
}

L'appel de la liste se fait dans l'évènement

Code:

void QMBase::closeEvent(QCloseEvent *event)

Code de la fenêtre de liste :
entête :

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
#ifndef QMLISTE_H
#define QMLISTE_H
 
#include <QWidget>
 
QT_BEGIN_NAMESPACE
class QDataWidgetMapper;
class QAbstractItemModel;
class QItemSelectionModel;
class QSqlRelationalTableModel;
class QSqlTableModel;
class QStandardItemModel;
class QStringListModel;
class QModelIndex;
class QSqlRecord;
class QLabel;
QT_END_NAMESPACE
 
 
namespace Ui {
    class QMListe;
}
 
class QMListe : public QWidget
{
    Q_OBJECT
 
public:
    explicit QMListe(QWidget *parent = 0);
    ~QMListe();
 
    void setModel(QAbstractItemModel *model);
 
signals:
    // Ce signal est émis quand on clique sur une cellule de la table,
    // permettant de gérer le cha,gement de ligne.
    // En pratique ce signal sera directement relié au vsNavi de la forme
    // utilisatrice.
    void rowSelected(int);
 
private slots:
    void on_tableView_clicked(const QModelIndex &index);
 
    void on_lineEdit_textChanged(const QString &arg1);
 
private:
    Ui::QMListe *ui;
};
 
#endif // QMLISTE_H

source :

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
#include "qmliste.h"
#include "ui_qmliste.h"
#include <QtSql>
#include <QModelIndex>
 
 
QMListe::QMListe(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::QMListe)
{
    ui->setupUi(this);
}
 
QMListe::~QMListe()
{
    delete ui;
}
 
void QMListe::setModel(QAbstractItemModel *model)
{
    ui->tableView->setModel(model);
    ui->tableView->setColumnWidth(0,15);
    ui->tableView->setColumnWidth(1,150);
    ui->tableView->setColumnWidth(0,50);
    ui->tableView->setColumnWidth(0,1);
}
 
void QMListe::on_tableView_clicked(const QModelIndex &index)
{
    emit rowSelected(index.row());
}
 
void QMListe::on_lineEdit_textChanged(const QString &arg1)
{
 
}

Si j'exécute le main suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <QtGui/QApplication>
#include "qmbase.h"
#include "../connection.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    createConnection();
 
    QMBase w("nation");
    w.show();
 
    return a.exec();
}

tout fonctionne parfaitement : L'application se lance, et si je clique le bouton 'liste>>>', apparaît une jolie vue tableau avec ma liste de nations dedans. Si je clique une nouvelle fois le même bouton, la fenêtre liste disparaît, et je suis content...

Vous comprendrez que QMBase sert de classe de base à une série de fenêtres qui utilisent un comportement commun, en particulier pour accéder à ma bdd et à la liste (fenêtres de saisie). Les comportements spécifiques propres aux différentes tables attaquées sont décrits dans les classes dérivées.

Voici la première de toutes et la plus simple (la seule pour l'instant d'ailleurs) :
entete :

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
#ifndef QMNATION_H
#define QMNATION_H
 
#include "qmbase.h"
QT_BEGIN_NAMESPACE
class QLineEdit;
class QSpacerItem;
class QHBoxLayout;
class QGraphicsView;
QT_END_NAMESPACE
 
class QMNation : public QMBase
{
    Q_OBJECT
public:
    explicit QMNation(QWidget *parent = 0);
 
signals:
 
public slots:
 
protected:
    virtual void populateMapper();
 
private:
    QLabel *lAbrev, *lDrap;
    QLineEdit *eAbrev;
    QGraphicsView *glDrap;
    QSpacerItem *hsp1, *hsp2;
    QHBoxLayout *hl1, *hl2;
 
    void setupUI(QWidget *w);
    void retranslateUI(QWidget *w);
};
 
#endif // QMNATION_H

source :

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
93
94
95
96
97
98
99
100
101
#include "qmnation.h"
#include "ui_qmbase.h"
#include <QLabel>
#include <QHBoxLayout>
#include <QGraphicsView>
#include <QDataWidgetMapper>
#include <QSqlTableModel>
 
QMNation::QMNation(QWidget *parent) :
    QMBase("nation",0,true,parent)
{
    setupUI(this);
    populateMapper();
}
 
void QMNation::retranslateUI(QWidget *w)
{
    lAbrev->setText(QApplication::translate("QMNation","Abr\303\251viation :", 0, QApplication::UnicodeUTF8));
    lDrap->setText(QApplication::translate("QMNation","Drapeau :", 0, QApplication::UnicodeUTF8));
}
 
void QMNation::setupUI(QWidget *w)
{
    // Retirer le spacer vertical pour le remettre correctement plus tard
    getUi()->glContenu->removeItem(getUi()->verticalSpacer_2);
 
    // Label pour l'abréviation
    lAbrev = new QLabel(w);
    lAbrev->setObjectName(QString::fromUtf8("lAbrev"));
    lAbrev->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
 
    hl1 = new QHBoxLayout(w);
    hl1->setObjectName(QString::fromUtf8("hl1"));
    hl1->setContentsMargins(0, 0, 0, 0);
 
    // Edit pour l'abréviation
    eAbrev = new QLineEdit(w);
    eAbrev->setObjectName(QString::fromUtf8("eAbrev"));
    QSizePolicy sizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    sizePolicy.setHorizontalStretch(0);
    sizePolicy.setVerticalStretch(0);
    sizePolicy.setHeightForWidth(eAbrev->sizePolicy().hasHeightForWidth());
    eAbrev->setSizePolicy(sizePolicy);
    eAbrev->setMaximumSize(QSize(50, 16777215));
 
    hl1->addWidget(eAbrev);
 
    // Espaceur pour la bonne place
    hsp1 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
 
    // Insérer les contrôles dans le layout.
    getUi()->glContenu->addWidget(lAbrev, 1, 0, 1, 1);
    getUi()->glContenu->addItem(hl1, 1, 1, 1, 1);
 
    hl1->addWidget(eAbrev);
    hl1->addItem(hsp1);
 
    // Drapeau - de la même façon
    lDrap = new QLabel(w);
    lDrap->setObjectName(QString::fromUtf8("lDrap"));
    lDrap->setAlignment(Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter);
 
    hl2 = new QHBoxLayout(w);
    hl2->setObjectName(QString::fromUtf8("hl2"));
    hl2->setContentsMargins(0, 0, 0, 0);
 
    glDrap = new QGraphicsView(w);
    glDrap->setObjectName(QString::fromUtf8("glDrap"));
    QSizePolicy sizePolicy2(QSizePolicy::Fixed, QSizePolicy::Fixed);
    sizePolicy2.setHorizontalStretch(0);
    sizePolicy2.setVerticalStretch(0);
    sizePolicy2.setHeightForWidth(glDrap->sizePolicy().hasHeightForWidth());
    glDrap->setSizePolicy(sizePolicy2);
    glDrap->setMaximumSize(QSize(120, 80));
 
    hl2->addWidget(glDrap);
 
    // Espaceur pour la bonne place
    hsp2 = new QSpacerItem(40, 20, QSizePolicy::Expanding, QSizePolicy::Minimum);
 
 
    // Insérer les contrôles dans le layout.
    getUi()->glContenu->addWidget(lDrap, 2, 0, 1, 1);
    getUi()->glContenu->addItem(hl2, 2, 1, 1, 1);
 
    hl2->addWidget(glDrap);
    hl2->addItem(hsp2);
 
 
    // On déplace le compresseur de lignes
    getUi()->glContenu->addItem(getUi()->verticalSpacer_2, 3, 0, 1, 1);
 
    QMetaObject::connectSlotsByName(w);
    retranslateUI(w);
}
 
void QMNation::populateMapper()
{
    getMapper()->addMapping(eAbrev, dynamic_cast<QSqlTableModel *>(getMapper()->model())->fieldIndex("Abréviation"));
    getMapper()->toFirst();
}

Si maintenant, je modifie mon main de ja façon suivante :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <QtGui/QApplication>
#include "qmnation.h"
#include "../connection.h"
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
 
    createConnection();
 
    QMNation w;
    w.show();
 
    return a.exec();
}

et que je lance l'application, tout se passe correctement, jusqu'au moment où je clique le bouton 'Liste >>>'. Le cadre de la fenêtre liste apparaît brièvement au bon endroit, puis disparaît à nouveau, et un passage par le débogueur me montre que 'on_bnEnregistrer_clicked()' est bien exécuté deux fois. J'ai vérifié également que c'est pareil dans les fonctions appelantes déboguables (celles générées par le moc et uic). Notez que ce comportement ne trouble pas le reste du fonctionnement de l'application, qui reste irréprochable.

Mouarf le roman :aie: Bravo a ceux qui auront suivi jusqu'ici :)
En tous cas, vous avez là autant d'infos que moi. J'espère que cela pourra vous servir ;)
Pour finir je tiens simplement à préciser (ça doit se voir) que je suis encore débutant en QT... Mais que je suis déjà familiarisé avec les logiciels du type designer que j'apprécie beaucoup pour l'économie de codage qu'ils procurent.

Encore merci
A bientôt
M.P.

Re bonjour :)

Cherchez plus, j'ai trouvé la réponse :
Dans la fonction setupUI de QMNation, vers la fin, j'avais ajouté une instruction qui figure également dans le setupUI de QMBase:

Code:

QMetaObject::connectSlotsByName(w);

Si je supprime cette instruction, je perds la connexion BDD vers les champs définis dans la classe, et je corrige le problème avec la liste.
J'en conclus que cette instruction ne doit figurer qu'une fois dans l'init de la hiérarchie de la classe.
Ca me ramène à une question à laquelle j'avais pensé répondre par ce programme (avant que l'histoire du bouton ne se présente) :
Comment sous-classer des formes (widgets) créées avec Designer ?
En effet, les comportements décrits dans QMBase sont communs à une douzaine d'autres widgets que j'ai à créer, et je n'ai donc pas trop envie de devoir refaire 12 fois la même construction... Surtout qu'il s'agît là d'une hiérarchie et que certains widgets seront encore sous-classés par la suite...

J'ai encore la possibilité de récupérer le code généré par le moc (setupUI etc) au niveau de QMBase, mais là, je sacrifie un gros morceau de maintenabilité...

C'est aussi là qu'on voit que je ne connais pas encore très bien cet environnement...

A bientôt,
M.P.

Bon, finalement j'ai trouvé une solution de contournement :
La fameuse fonction de connexion automatique des slots, qui ne contrôle pas si la connexion existe déjà (je pense qu'il s'agît là d'une petite erreur), je la désactive dans la fenêtre de la classe de base.
Il faudra cependant que je mette un mécanisme au point me permettant de l'activer une fois, en m'assurant que c'est fait après tous les setupUI.

Par ailleurs, je vais ouvrir un sujet sur comment permettre l'héritage avec Designer, car là je ne vois pas trop comment continuer en wisiwyg.

Merci pour votre aide
A bientôt
M.P.