[QGroupBox] Aligner la case à cocher avec son titre

**Ant_02** · 15/10/2019, 14h25

Bonjour,

Je bosse sur une appli Qt et ça fait un moment que je cherche comment aligner verticalement la case a cocher d'un QGroup Box avec sont titre?

A gauche, la checkBox, ensuite le label et ensuite le contenu (Un widget) et le tout sur la même ligne?

J'ai forcement essayé un setAlignement, mais sa ne fait que centré/gauche/droit e sur le label!

J'ai pas mal cherché mais la j'ai du mal.......

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
 
QVBoxLayout *layoutAux = new QVBoxLayout;//.....Création du layout vertical aux
        layoutAux->setAlignment(Qt::AlignTop);//.......Alignement haut
 
        for (int x = 0; x < 14; x++)
        {
            QPushButton *BpAux = new QPushButton(nameLoop[x]);
            BpAux->setFont(QFont("",t_police_preset,QFont::DemiBold));
            BpAux->setCheckable(true);
 
            QDoubleSpinBox *ValueRepeat = new QDoubleSpinBox;
            ValueRepeat->setFont(QFont("",t_police_preset,QFont::Normal));
            ValueRepeat->setSuffix(" sec");//...........Ajoute le suffixe seconde
            ValueRepeat->setDecimals(1);//............Bloque la decimale a 1
            ValueRepeat->setSingleStep(0.1);//.........Incremente le pas de 0.1
            ValueRepeat->setValue(value_shift_min);//............initialise le temps
            ValueRepeat->setRange(value_shift_min,value_shift_max);//............initialise le temps min et max
 
            QHBoxLayout *layoutSpin = new QHBoxLayout;//.....Création du layout horizontal repeat
            layoutSpin->addWidget(ValueRepeat);
 
 
            QGroupBox *GroupAuxRepeat = new QGroupBox("Repeat");//.....Création du Group Data Loop
            GroupAuxRepeat->setCheckable(true);
            GroupAuxRepeat->setChecked(false);
            GroupAuxRepeat->setLayout(layoutSpin);
            GroupAuxRepeat->setEnabled(false);
 
            QHBoxLayout *layoutRepeat = new QHBoxLayout;//.....Création du layout horizontal repeat
            layoutRepeat->setAlignment(Qt::AlignLeft);//.......Alignement a gauche
            layoutRepeat->addWidget(BpAux);//...............Ajoute le bouton
            layoutRepeat->addWidget(GroupAuxRepeat);//...............Ajoute le check shift
 
            layoutAux->addLayout(layoutRepeat);
 
            connect(BpAux, SIGNAL(toggled(bool)), GroupAuxRepeat, SLOT(setEnabled(bool)));//.....Connexion du clic du bouton
        }

Oui je pourrais faire un layout avec tout ça, mais je créer une quizaine de groupBox dans un boucle For avec un méthode connect, et si je crée un slot, tout mes bouton envoie leur signal vers le même slot....

Merci d'avance!

**koala01** · 16/10/2019, 05h03

Salut,

Une des solutions( la plus longue à mettre en place) est de créer ton propre widget, hériterait directement de QGroupBox et qui contiendrait:

le bouton,
le spinbox
un HLayout pour organiser correctement tout cela
un slot privé auquel connecter le signal du bouton

de manière à pouvoir en créer plusieurs instances de ce widget qui seraient tout à fait "indépendantes" les unes des autres.
Cela prendrait une forme proche de
MyWidget.hpp (nom à adapter

)

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
#ifndef MYWIDGET_HPP
#define MYWIDGET_HPP
#include <QGroupBox>
class QPushButton;
class QDoubleSinbox
class MyWidget : public QGroupBox{
    Q_OBJECT;
public:
    MyWidget(QString const & title, QWidget * parent = 0);
    double value() const; // pour pouvoir  récupérer la valeur du spinbox
    bool checked() const; // pour savoir si le bouton est checke ou non
private:
    void buttonClicked(bool checked);
    QPushButton * button;
    QDoubleSpinBox *spinbox;
};
#endif //MYWIDGET_HPP

et l'implémentation ressemblerait à quelque chose comme
MyWidget.cpp

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
#include <MyWidget.hpp>
#include <QPushButton>
#include <QSPinBox>
#include <QHBoxLayout>
#include <QGroupBox>
MyWidget::MyWidget(int boxValue, QWidget * parent):QGroupBox{title,parent}{
    QString buttonString{QString{"le texte qu'il faut"}};
    button = new QPushButton(buttonString);
    button->setCheckable(true);
 
    spinbox = new QSpinBox;
    spinbox ->setSuffix(" sec");
    spinbox ->setDecimals(1);//............Bloque la decimale a 1
    spinbox ->setSingleStep(0.1);
    spinbox ->setValue(value_shift_min);
    spinbox ->setRange(value_shift_min,value_shift_max);
 
   QHBoxLayout * layout = new QHBoxLayout;
   layout->addWidget(spinbox);
   layout->addWidget(button);
   setLayout(layout);
   connect(button, &QPushButton::toggled, this, &MyWidget::buttonClicked);
}
/* les deux accesseurs publics: */
double MyWidget::value() const{
   return spinbox->value();
}
bool MyWidge::checked() const{
    return button->isChecked();
}
void MyWidget::buttonClicked(bool checked){
    /* tout ce que tu voudras faire lorsqu'on modifie l'état du bouton */
}

De cette manière, tu pourras créer une liste de (pointeurs sur) MyWidget, de manière à pouvoir y accéder depuis l'endroit où ils sont affichés, sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* dans la définition de la classe (le fichier d'en-tête *.h / *.hpp)*/
 
// je te passe tout le reste
    QList(MyWidget *) allSpinboxes;
/* dans implémentation du constructeur (le fichier *.cpp)*/
 
// je te passe tout le reste
    QVBoxLayout * layout = new QVBoxLayout;
    for(int i = 0; i< 14; ++i){
        MyWidget * temp = new MyWidget(nameLoop[x]);
        allSpinBoxes.append(temp);
        layout->addWidget(temp);
    }
    setLayout(layout);

Une autre solution, plus rapide par rapport à ton code existant, est d'utiliser les expessions lambda pour effectuer le mapping.

Pour se faire, tu devrais sans doute modifier le prototype de ton slot pour lui donner une forme proche de

Code :

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

void buttonChecked(int button, bool checked)

, et modifier ton code pour lui donner une forme proche de

Code :

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

1
2
3
4
/* tout reste pareil à ce que tu as fait, à part la ligne connect
 * qui ressemble désormais à quelque chose comme
 */
    connect(BpAux, &QPushButton::toggled, [=](bool checked){this->buttonChecked(i, checked);});

(nota : il serait sans doute plus qu'intéressant de placer ad minima les différents spinbox dans une liste qui serait membre de ta classe, de manière à pouvoir en récupérer la valeur quand tu en as besoin

)

**Ant_02** · 16/10/2019, 09h30

Salut, Merci pour cette réponse rapide et très complète!
J'ai résolu mon problème avec les deux méthodes en fait....

J'ai créé un layout avec un QPushButton, un QCheckBox et un QSpinBox.

Ensuite j'ai créé un mappage avec:

Code :

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

1
2
QSignalMapper *signalMapper = new QSignalMapper(this);
QObject::connect(signalMapper, SIGNAL(mapped(int)), this, SLOT(displayButton(int)));

je peux donc piloter une fonction avec mes slots et lui passer des arguments, numéros du bouton etc.

Merci beaucoup!

**koala01** · 16/10/2019, 12h20

Attention, QSignalMapper est obsolète, et les développeurs de Qt te mettent bien en garde du fait qu'il déconseillent fortement de l'utiliser dans du nouveau code !!!

Parce qu'il y a de fortes chances pour que cette classe soit supprimée dans la version 6

Or, la version 6 est en préparation, et devrait arriver à la fin de l'année prochaine, si tout va bien, ce qui t'obligera à modifier ton code (ou à rester bloquer, au mieux, avec une ancienne version de Qt).

Les deux possibilités que je t'ai présentées vont fonctionner dés maintenant (la première pourrait même fonctionner avec des versions bien plus anciennes de Qt), et continueront de fonctionner dans l'avenir

**Ant_02** · 16/10/2019, 15h37

Ah, merci du conseil!

Je vais regarder de plus prêt ta seconde solution qui en fait a l'air très simple, en tout cas pour mon niveau sur Qt....
J'ai trouvé QSignalMapper sur un autre Forum, j'ai teseter ça marche donc je n'est pas forcement chercher plus loin...

Je ne compte pas changer de version de Qt car changer tout le temps de version apporte souvent plus de problème qu'autre chose, en tout cas c'est mon constat sur d'autre Soft, donc quand ca marche je préfère rester sur des valeurs sur.
Après je suis d'accord qu'il vaut mieux faire en sorte d'éviter des problème future si je suis amené a passer a Qt 6.

Je test ton code rapidement et repost pour te dire.

Encore merci!

Cordialement, Antoine

**koala01** · 16/10/2019, 20h44

En fait, Qt évolue énormément de version en version, en fournissant de plus en plus de fonctionnalités.

De plus, les développeurs ont une philosophie stricte en ce qui concerne la compatibilité ascendante : si un code fonctionne avec la version A.b.c de Qt, le même code devra fonctionner sans rien avoir à changer avec la version mineure A.c où c >= b.

Par exemple, le code qui compilait avec l'avant dernière version LTS (Long Term Support: 5.9.x à l'époque) doit fonctionner sans aucune modification avec la dernière version de Qt en date (la version 5.13.2 à l'heure actuelle). A priori, la compatibilité binaire est assurée, si bien que tu n'a -- normalement -- même pas à recompiler ton programme pour qu'il utilise la dernière version de Qt : tu remplace les "anciennes" dll par les nouvelles, et le tour est joué

La classe QSignalMapper existait déjà dans Qt 4.8, pour faciliter la vie des développeurs en mettant en place toute une mécanique qu'il était compliqué de mettre en place en C++98.

Depuis, C++11 (et les versions suivantes de la norme) a fait son apparition, avec, entre autres, les expressions lambda. C'est l'apparition de cette nouvelle norme qui a incité les développeurs de Qt de passer de la version majeure 4 à la version majeure 5 (et d'en profiter pour réorganiser les différents modules proposés par Qt).

Le truc, c'est que, à l'époque ou Qt 5.0 est sorti, la norme C++11 était encore finalement très jeune, et l'un des compilateur majeur (celui proposé par microsoft, pour ne pas le citer) ne supportait encore cette norme qu'au compte goutte.

La classe QSignalMapper est donc restée dans la version 5.0 de Qt, non seulement pour favoriser la transition (comprends : pour qu'un projet dont le développement a commencé avec une version 4.x de Qt puisse continuer à fonctionner avec la version 5.0 en ne nécessitant que très peu de modifications) mais aussi parce qu'elle restait nécessaire au vu des capacités des différents compilateurs

Depuis cette époque (je te parle de l'an de grace 2012 ou peu s'en faut), les choses ont énormément évolué. Nous avons, entre autres, pu observer un changement radical de mentalité chez microsoft : depuis 2015 à peu près (un peu après en réalité), son compilateur supporte pour ainsi dire intégralement la dernière norme en date au moment de sa sortie, avec la possibilité d'activer à titre expériemental le support de la norme "en cours de préparation"; comblant ainsi son retard par rapport à d'autres grands noms de compilateurs (tels que Gcc ou clang).

Les nouvelles normes (C++14, C++17 et bientot C++20), ont, pour ainsi dire, rendu la classe QSignalMapper totalement inutile, en permettant d'obtenir un résultat équivalent en à peine quelques lignes de code. Cela fait donc trois ou quatre ans (peut-être un peu plus) que les développeurs de Qt déconseillent l'utilisation de cette classe parce qu'il ne sert à rien de se taper volontairement la tête contre le mur, juste pour le plaisir de se dire que "ca fait tellement de bien quand cela s'arrête"

.

Et, pourtant, cette classe existe encore dans la dernière version en date de Qt (la version 5.13.1). Pourquoi

Ben, justement pour permettre la compatibilité ascendante : si tu avais lancé un projet avec Qt 5.2 -- par exemple -- qui utilise QSignalMapper, tu devrais pouvoir décider de passer à la version 5.13 de Qt sans rien avoir à changer.

Cela n'empêche que l'on te prévient quand même déjà depuis quatre ans qu'il est préférable de ne pas utiliser cette classe; et qu'elle finira tot ou tard (sans doute à la sortie de Qt 6.0) par disparaitre. A ce moment là, tu n'auras plus vraiment le choix:

ou bien tu devra modifier "en catastrophe" tout ton code pour supprimer les références à la classe QSignalMapper et pouvoir utiliser la prochaine version majeure de Qt
ou bien tu te condamnera à être bloqué à l'utilisation d'une "ancienne" version de Qt, ce qui t'interdira l'utilisation des nouvelles possibilités offertes par les versions plus récentes.

A titre d'exemple :

Peut-être as tu déjà entendu parler de QCharts, QVirtualKeyboard ou de QDataVisualization

Ces modules existent déjà depuis "pas mal de temps"... dans la version commerciale de Qt. Ce n'est que "relativement récemment" que ces modules sont passés sous version LGPL (non commerciale / libre). Mais, tu dois respecter les numéros de versions pour ce faire:

Avec Qt 5.5, par exemple, tu serais obligé de payer la licence commerciale de Qt pour pouvoir les utiliser, alors qu'avec Qt 5.12 ou 5.13, tu peux les utiliser tout à fait librement.

Je ne me tiens pas forcément à jour en ce qui concerne les modules en cours de développement de Qt, mais tu peux t'attendre à ce qu'il en aille de même pour les nouveaux modules qui paraitront au fil du temps : il seront développés et utilisable d'abord pour la version commerciale de Qt, et ne passeront en version libre qu'avec "quelques années" de retard

**Ant_02** · 17/10/2019, 22h59

Super, merci pour toute ces précision!

J'ai néanmoins un souci avec ton 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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
QVBoxLayout *layoutLoop = new QVBoxLayout;//.....Création du layout vertical loop
        layoutLoop->setAlignment(Qt::AlignLeft);//.......Alignement a gauche
 
        for (int x = 0; x < nFunctionLoop; x++)
        {
            BpLoop[x] = new QPushButton(nameLoop[x]);
            BpLoop[x]->setFont(QFont("",t_police_preset,QFont::DemiBold));
            BpLoop[x]->setCheckable(true);
            BpLoop[x]->setMinimumWidth(120);
            BpLoop[x]->setToolTip("On/Off Loop");
            BpLoop[x]->setCursor(Qt::PointingHandCursor);
 
            QHBoxLayout *layoutShift = new QHBoxLayout;//.....Création du layout horizontal
 
            CheckShift[x] = new QCheckBox("Spill over");
            CheckShift[x]->setFont(QFont("",t_police_preset,QFont::Normal));
            CheckShift[x]->setEnabled(false);
 
            ValueShift[x] = new QDoubleSpinBox;
            ValueShift[x]->setFont(QFont("",t_police_preset,QFont::Normal));
            ValueShift[x]->setSuffix(" sec");//...........Ajoute le suffixe seconde
            ValueShift[x]->setDecimals(1);//............Bloque la decimale a 1
            ValueShift[x]->setSingleStep(0.1);//.........Incremente le pas de 0.1
            ValueShift[x]->setValue(value_shift_min);//............initialise le temps
            ValueShift[x]->setRange(value_shift_min,value_shift_max);//............initialise le temps min et max
            ValueShift[x]->setEnabled(false);
 
            if(x>=10)
                {
                    accesCheckSpillOver(x,true);
 
                    QObject::connect(BpLoop[x],
                                     &QPushButton::toggled,
                                     [=](bool checked)
                    {this->accesCheckSpillOver(x, checked);}//Ligne avertissement
                    );//.......................................................Ligne erreur
 
                }
 
            layoutShift->setAlignment(Qt::AlignLeft);//.......Alignement a gauche
            layoutShift->addWidget(BpLoop[x]);//...............Ajoute le bouton
            layoutShift->addWidget(CheckShift[x]);//...............Ajoute le check shift
            layoutShift->addWidget(ValueShift[x]);//...............Ajoute la value shift
 
            layoutLoop->addLayout(layoutShift);
 
        }

Voici les erreur:

avertissement : lambda expressions only available with -std=c++11 or -std=gnu++11 [enabled by default]
erreur : no matching function for call to 'TW_S_Rck::connect(QPushButton*&, void (QAbstractButton::*)(bool), TW_S_Rck::productWindow()::__lambda0)'
erreur : template argument for 'template<class Func1, class Func2> static typename QtPrivate::QEnableIf<(QtPrivate::FunctionPointer<Func2>::ArgumentCount == (-1)), QMetaObject::Connection>::Type QObject::connect(const typename QtPrivate::FunctionPointer<Func>::Object*, Func1, Func2)' uses local type 'TW_S_Rck::productWindow()::__lambda0'

Merci d'avance.

**koala01** · 18/10/2019, 03h12

Montre moi un peu ton fichier *.pro???

Et, tant que l'on y est, pourrais tu me dire ce que te donne l'instruction

Code :

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

gcc -v

**Ant_02** · 18/10/2019, 09h32

Voila le .pro:

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
 
QT       += core gui
 
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 
//RC_ICONS = Logo.ico
 
SOURCES += \
    main.cpp \
    tw_s_rck.cpp \
    Midi.cpp \
    Loop.cpp \
    Level.cpp \
    AuxExt.cpp \
    NameBankPreset.cpp \
    Expression.cpp
 
HEADERS += \
    tw_s_rck.h

l'instruction je doit la placé ou?

**koala01** · 19/10/2019, 03h12

Je voudrais que tu lance l'instruction gcc -v dans un terminal. Cela devrait occasionner une sortie proche de

Using built-in specs.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=D:/dev/mingw-8.1.0/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-posix-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=posix --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-posix-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-posix-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-posix-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-posix-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-posix-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib '
Thread model: posix
gcc version 8.1.0 (x86_64-posix-seh-rev0, Built by MinGW-W64 project)

mais dont la seule chose qui m'intéresse réellement est la toute dernière ligne (celle qui commence par gcc version x.y.z).

Ce que tu pourrais déjà faire, c'est ajouter la ligne

Code :

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

CONFIG +=c++14

à ton fichier pro, histoire de forcer le compilateur à respecter cette norme (même s'il est possible que ce ne soit pas indispensable, en fonction de la version de Gcc que tu emploie, et qui est la raison exacte de la première instruction

)

**Ant_02** · 20/10/2019, 14h58

gcc -v, dans un terminal, c'est à dire??
Ou je doit taper ce code?

Dans le excuter Windows? ca plante
Dans l'invite de commande aussi.

[QGroupBox] Aligner la case à cocher avec son titre

Qt

Discussions similaires

Partager

Partager