Partager
Affiche les résultats de 1 à 6 sur 6

Sujet : C++ GUI Avec Qt , Bienvenue en enfer

  1. #1
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Lightbulb C++ GUI Avec Qt , Bienvenue en enfer

    C++ GUI Avec Qt


    Introduction :
    Qt (prononcé officiellement en anglais cute mais erronément couramment prononcé Q.T) est un framework orienté objet et développé en C++ par Qt Development Frameworks, filiale de Nokia. Il offre des composants d'interface graphique (widgets), d'accès aux données, de connexions réseaux, de gestion des fils d'exécution, d'analyse XML, etc.
    Qt est par certains aspects un framework lorsqu'on l'utilise pour concevoir des interfaces graphiques ou que l'on architecture son application en utilisant les mécanismes des signaux et slots par exemple.
    Qt permet la portabilité des applications qui n'utilisent que ses composants par simple recompilation du code source.
    Les environnements supportés sont les Unix (dont Linux) qui utilisent le système graphique X Window System, Windows, Mac OS X et également Tizen. Le fait d'être une bibliothèque logicielle multiplate-forme attire un grand nombre de personnes qui ont donc l'occasion de diffuser leurs programmes sur les principaux OS existants.
    Qt est notamment connu pour être la bibliothèque sur laquelle repose l'environnement graphique KDE, l'un des environnements de bureau les plus utilisés dans le monde Linux.

    Question : ( Déjà ?)
    Que veut dire tous ce charabia ?

    Réponse :
    Cute est un framework qui va vous permettre de crée des application C++ avec des listes déroulante , sliders , menus ......etc , c'est enfet si on peux le dire l’équivalent t du jQuery dans le domaine du web, bref ce framework vous permettra de créer des applications écrite en C++ avec un GUI .

    Remarque :
    Le cour viens tous juste de commencer que je suis entrain de vous assommez avec le jargon a la con.
    Ce qui m’amène a un point très important qui est le langage C , alors je ne vous demande pas d'avoir un niveau avancé en C/C++ mais de maîtrisé les bases du langage en question , je ne vois pas l’intérêt de faire un cours sur les bases du C car tous le monde ou presque maîtrise ce langage ( en tous les cas c'est mon premier langage de programmation assimilé en 7 jours ) .

    Prérequis :
    Il nous faut tous d'abord , téléchargé le SDK en question ; et pour ce faire il faut avoir une connexion internet ( ce qui est le cas puisque vous êtes entrain de lire ce cours , Magique vous me diriez ) et d'un browser ( n'importe lequel mais mon préféré c'est Chrome pour ses outils de développement en natif bien plus intéressante que FireFox par exemple ) .
    Donc on se rends sur site pour pouvoir telecharger le SDK , plusieurs version s'offre a vous selon votre plateforme ( pour ma part j'ai téléchargé les trois versions ) .
    Il existe en plus des versions , des déclinaison Online et Offline , donc votre choix ce fera en dépends de votre connexion au net (toujours connecté ou pas) , pour ma part mon choix s'est porté sur les versions Offline (pour être plus a l'aise , vu la qualité de notre ISP).

    L'installation :
    Une fois le téléchargement terminé , lancez le SDK comme une simple application sous Windows , gardez toute les valeurs par défaut et ne changez rien du tous , donc juste Next suffira.
    Une fois l'installation terminé , vous trouverez au sein de votre menu Démmarer , un dossier nommé Qt SDK et en le déroulant vous trouverez ce que l'installation a créé .
    Pour simplifier les choses dites vous que l'on va pas utilisé tous ce bon monde , car voyez dans ce dossier une icone portant le sérieux nom de Qt Creator (mwé j'ai pas d'avis sur le nom en question), on cliquant dessus l'interface de Qt ce qui confirmera que l'installation s'est déroulé parfaitement .

    Remarque :
    On vous demandera d'installer un pilote provenant d'un éditeur inconnue , donc ce cas ci appuyez sur je fais confiance a ce pilote ( pas le choix enfet )

    Bref au lancement vous devez avoir cette interface s'affiché :

    Dernière édition par TeamWorK; 11/07/2012 à 18h12
    Not Available

  2. # ADS
    Inscrit
    Toujours
    Lieu
    Monde des annonces
    Messages
    Plusieurs






     
  3. #2
    Inscrit
    septembre 2010
    Lieu
    Tizi-ouzou
    Messages
    202
    Remerciements
    88
    Remercié(e) 63 fois dans 48 messages
    Pouvoir de réputation
    8

    Re : C++ GUI Avec Qt , Bienvenue en enfer

    où est l'enfer dans tout ça ???
    L'espoir c'est une bonne chose, c'est peut être l'une des plus bonnes choses, et les bonnes choses sont éternels.

  4. #3
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Lightbulb Re : C++ GUI Avec Qt , Bienvenue en enfer

    Familiarisation avec le UI de Qt


    Configurer notre projet :
    Dans la précédente snap vous pouvez voir un bouton : Crée un projet... , en cliquant dessus une fenêtre s'affiche avec plusieurs choix :


    Après le choix du type d'application , on continue toujours vers la prochain fenêtre :


    Pour les autres fenêtres , vous devez laisser les valeurs par défaut et ne rien changer , donc un clique sur Suivant suffira .

    Question :
    Et maintenant ou est l'enfer ? non parce que je suis venu que pour ça hein .

    Réponse :
    Patience jeune padawane patience , ressentir la force en toi du dois .

    Interface Graphique :
    Il faut dire que c'est vrai , l'interface graphique est le plus important ce qui est le but de ce cour et pour ce faire voyez avec moi :


    Question :
    Oui mais la on fais que cliquez sans rien comprendre , alors que ce qu'on est entrain de faire ?

    Réponse :
    Dans cette première partie , on ne détaillera pas ces étapes car ils le seront au moment voulu .

    Maintenant une interface s'affiche devant vous , avec des outils a gauche comme un compilateur standard tel que VS ou bien Eclipse , parmi les outils on trouvera des buttons , combo box , text edit ....etc
    Il suffit alors d'un simple DragAndDrop sur la forme pour pouvoir utiliser l'outil en question :


    Notre premier petit programme :


    L'idée du petit programme :
    On va tous simplement créé un programme qui affiche dans un Label (c'est le nom de l'objet) , un message précis .

    Les outils utilisés :
    1 - Push Button dans la catégorie Buttons
    2 - Label dans la catégorie Display Widget
    On les drag/drop sur notre forme et on clique droit sur le bouton , ensuite sur Aller au slot et on laisse l’évènement clicked() par défaut et on clique sur OK .

    Le code :
    En cliquant sur OK un code se génère pour l’évènement du clique et c'est la que l'on doit saisir notre code comme ce ci :

    Code:
    void MainWindow::on_pushButton_clicked()
    {
        ui->label->setText("TeamWorK UnLimited"); // Voici la ligne ajouté qui ciblera le Label pour lui 
                                                                             ajouter le texte entre double quotte 
    }
    ce qui donnera au final le code en entier de la page :

    Code:
    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
    }
    
    MainWindow::~MainWindow()
    {
        delete ui;
    }
    
    void MainWindow::on_pushButton_clicked()
    {
        ui->label->setText("TeamWorK UnLimited");
    }
    Compiler :
    Pour le compiler rien de plus simple que de cliquer sur la flèche verte juste en bas a gauche , on attend alors la compilation et une fois finis vous n'avez qu'a cliquez sur le bouton pour voir le texte apparaître au sein du Label .

    PS :
    Vous pouvez cliquez deux fois sur le bouton pour en changer son texte .

    Voila , ce qui nous amène a la fin de ce petit cours qui bien facile comparé a celui que l'on va créé une fois quelque base autour du Qt assimilés .

    A Venir : Détaillé les différents éléments de l'UI de Qt
    Dernière édition par TeamWorK; 11/07/2012 à 23h18
    Not Available

  5. #4
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : C++ GUI Avec Qt , Bienvenue en enfer

    Remarque :
    Voila personnellement expliqué l'UI des compilateurs n'est pas mon fort donc on va passé l’explication de l'UI de Qt mais comme c'est un mois saint donc voici de l'aide pour ceux qui veulent poursuivre : Aide

    Hello Qt :
    Commençons par un programme Qt très simple. Nous l’étudierons d’abord ligne par ligne (autrement dis 7aba b7aba), puis nous verrons comment le compiler et l’exécuter.

    Code:
    1 #include <QApplication>
    2 #include <QLabel>
    
    3 int main(int argc, char *argv[])
    4   {
    5        QApplication app(argc, argv);
    6         QLabel *label = new QLabel("Hello Qt!");
    7         label->show();
    8         return app.exec();
    9  }
    Analyse :
    Les lignes 1 et 2 contiennent les définitions des classes QApplication et QLabel. Pour chaque classe Qt, il y a un fichier d’en-tête qui porte le même nom (en respectant la casse) que
    la classe qui renferme la définition de classe.

    La ligne 5 crée un objet QApplication pour gérer les ressources au niveau de l’application.
    Le constructeur QApplication exige argc et argv parce que Qt prend personnellement en charge quelques arguments de ligne de commande.

    La ligne 6 crée un widget QLabel qui affiche "Hello Qt !". Dans la terminologie Qt et Unix, un widget est un élément visuel dans une interface utilisateur. Ce terme provient de "gadget pour fenêtres" (et cela n'a rien avoir avec l'inspecteur gadget .......mwé c'est pas terrible ) et correspond à "contrôle" et "conteneur" dans la terminologie Windows. Les boutons,
    les menus et les barres de défilement sont des exemples de widgets. Les widgets peuvent
    contenir d’autres widgets .

    Exemple :
    Une fenêtre d’application est habituellement un widget qui comporte un QMenuBar, quelques QToolBar, un QStatusBar et d’autres widgets. La plupart des applications utilisent un QMainWindow ou un QDialog comme fenêtre d’application, mais Qt est si flexible (sans arrière pensés) que n’importe quel widget peut être une fenêtre. Dans cet exemple, le widget QLabel correspond à la fenêtre d’application.

    La ligne 7 permet d’afficher l’étiquette. Lors de leur création, les widgets sont toujours masqués,
    de manière à pouvoir les personnaliser avant de les afficher et donc d’éviter le phénomène du
    scintillement.

    La ligne 8 transmet le contrôle de l’application à Qt. A ce stade, le programme entre dans la boucle d’événement. C’est une sorte de mode d’attente où le programme attend que l’utilisateur agisse, en cliquant sur la souris ou en appuyant sur une touche par exemple. Les actions de l’utilisateur déclenchent des événements (aussi appelés "messages") auquel le programme peut répondre, généralement en exécutant une ou plusieurs fonctions.

    Exemple :
    Quand l’utilisateur clique sur un widget, les événements "bouton souris enfoncé" et "bouton souris relâché" sont déclenchés. A cet égard, les applications GUI diffèrent énormément des programmes par lots traditionnels, qui traitent habituellement l’entrée, produisent des résultats et s’achèvent sans intervention de quiconque.

    Pour des questions de simplicité, nous je n'appelle pas delete sur l’objet QLabel à la fin de la fonction main(). Cette petite fuite de mémoire est insignifiante dans un programme de cette taille, puisque la mémoire est récupérée de toute façon par le système d’exploitation dès qu’il se termine.

    Vous pouvez désormais tester le programme sur votre ordinateur. Vous devrez d’abord installer Qt 4.7 (ou une version ultérieure de Qt 4).
    A partir de maintenant, je suppose que vous avez correctement installé une copie de Qt 4 et que le répertoire bin de Qt se trouve dans votre variable d’environnement PATH. (Sous Windows, c’est effectué automatiquement par le programme d’installation de Qt.) Vous aurez également besoin du code source du programme dans un fichier appelé hello.cpp situé dans un répertoire nommé hello. Vous pouvez saisir le code de ce programme vous-même.

    Depuis une invite de commande, placez-vous dans le répertoire hello, puis saisissez :

    Code:
    qmake -project
    pour créer un fichier de projet indépendant de la plate-forme (hello.pro), puis tapez :

    Code:
    qmake hello.pro
    pour créer un fichier Makefile du fichier de projet spécifique à la plate-forme.
    Tapez make pour générer le programme. Exécutez-le en saisissant hello sous Windows, ./hello sous Unix et open hello.app sous Mac OS X (za3ma les mac). Pour terminer le programme, cliquez sur le bouton de fermeture dans la barre de titre de la fenêtre.
    Si vous utilisez Windows et que vous avez installé Qt Open Source Edition et le compilateur MinGW, vous aurez accès à un raccourci vers la fenêtre d’invite DOS où toutes les variables d’environnement sont correctement installées pour Qt. Si vous lancez cette fenêtre, vous pouvez y compiler des applications Qt grâce à qmake et make décrits précédemment.

    Les exécutables produits sont placés dans les dossiers debug ou release de l’application.

    Exemple :

    Code:
    C:\qt-book\hello\release\hello.exe.
    Si vous vous servez de Microsoft Visual C++, vous devrez exécuter nmake au lieu de make.
    Vous pouvez aussi créer un fichier de projet Visual Studio depuis hello.pro en tapant :

    Code:
    qmake -tp vc hello.pro
    Puis concevoir le programme dans Visual Studio. Si vous travaillez avec Xcode sous Mac OS X, vous avez la possibilité de générer un projet Xcode à l’aide de la commande :

    Code:
    qmake -spec macx-xcode
    Avant de continuer avec l’exemple suivant, amusons-nous un peu : remplacez la ligne :

    Code:
    QLabel *label = new QLabel("Hello Qt!");
    par :

    Code:
    QLabel *label = new QLabel("<h2><i>Hello</i> "
    "<font color=red>Qt!</font></h2>");
    et générez à nouveau l’application.Il est facile d’égayer l’interface utilisateur d’une application Qt en utilisant une mise en forme simple de style HTML

    Etablir des connexions :
    Le deuxième exemple vous montre comment répondre aux actions de l’utilisateur. L’application propose un bouton sur lequel l’utilisateur peut cliquer pour quitter. Le code source ressemble beaucoup à Hello, sauf que nous utilisons un QPushButton en lieu et place de QLabel comme widget principal et que nous connectons l’action d’un utilisateur (cliquer sur un
    bouton) à du code.

    Voici le contenu du fichier :

    Code:
    1 #include <QApplication>
    2 #include <QPushButton>
    
    3 int main(int argc, char *argv[])
    4    {
    
    5         QApplication app(argc, argv);
    6         QPushButton *button = new QPushButton("Quit");
    7         QObject::connect(button, SIGNAL(clicked()),
    8               &app, SLOT(quit()));
    9         button->show();
    10             return app.exec();
    11    }
    Analyse :
    Les widgets de Qt émettent des signaux pour indiquer qu’une action utilisateur ou un changement d’état a eu lieu.

    Exemple :
    QPushButton émet un signal clicked() quand l’utilisateur clique sur le bouton. Un signal peut être connecté à une fonction (appelé un slot dans ce cas), de sorte qu’au moment où le signal est émis, le slot soit exécuté automatiquement. Dans notre exemple, nous relions le signal clicked() du bouton au slot quit() de l’objet QApplication.
    Les macros SIGNAL() et SLOT() font partie de la syntaxe .

    Nous allons désormais générer l’application. Nous supposons que vous avez créé un répertoire appelé quit contenant quit.cpp. Exécutez qmake dans le répertoire quit pour générer le fichier de projet, puis exécutez-le à nouveau pour générer un fichier Makefile, comme suit:

    Code:
    qmake -project
    qmake quit.pro
    A présent, générez l’application et exécutez-la. Si vous cliquez sur Quit ou que vous appuyez sur la barre d’espace (ce qui enfonce le bouton), l’application se termine.

    Conclusion :
    Dans le prochain cours nous continuerons avec quelques points sur les widgets .

    A Venir : Créer des boîtes de dialogue
    Dernière édition par TeamWorK; 23/07/2012 à 02h42
    Not Available

  6. #5
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : C++ GUI Avec Qt , Bienvenue en enfer

    Création des boites de dialogue


    Nous allons créer notre première boîte de dialogue en écrivant complètement le code pour vous en expliquer le fonctionnement. Puis nous verrons comment concevoir des boîtes de dialogue grâce au Qt Creator, un outil de conception de Qt. Avec le Qt Creator, vous codez beaucoup plus rapidement et il est plus facile de tester les différentes conceptions et de les modifier par la suite et aussi parce que c'est celui que j'utilise (bein quoi ?!!)

    Dérivation de QDialog :
    Notre premier exemple est une boîte de dialogue Find écrite totalement en langage C++ . Nous l’implémenterons comme une classe à part entière. Ainsi, elle deviendra un composant indépendant et autonome, comportant ses propres signaux et slots.

    Le code source est réparti entre deux fichiers : finddialog.h et finddialog.cpp. Nous commencerons par finddialog.h :

    Code:
    1 #ifndef FINDDIALOG_H
    2 #define FINDDIALOG_H
    
    3 #include <QDialog>
    
    4 class QCheckBox;
    5 class QLabel;
    6 class QLineEdit;
    7 class QPushButton;
    Analyse :
    Les lignes 1 et 2 : protègent le fichier d’en-tête contre les inclusions multiples.
    La ligne 3 : contient la définition de QDialog, la classe de base pour les boîtes de dialogue dans
    Qt. QDialog hérite de QWidget.
    Les lignes 4 à 7 : sont des déclarations préalables des classes Qt que nous utiliserons pour implémenter la boîte de dialogue. Une déclaration préalable informe le compilateur C++ qu’une classe existe, sans donner tous les détails d’une définition de classe (généralement située dans un fichier d’en-tête). Nous en parlerons davantage dans un instant.(patient tu dois être jeune sith)

    Nous définissons ensuite FindDialog comme une sous-classe de QDialog :

    Code:
    8 class FindDialog : public QDialog
    9 {
    10      Q_OBJECT
    11 public:
    12      FindDialog(QWidget *parent = 0);
    La macro Q_OBJECT au début de la définition de classe est nécessaire pour toutes les classes qui définissent des signaux ou des slots.
    Le constructeur de FindDialog est typique des classes Qt de widgets. Le paramètre parent spécifie le widget parent. Par défaut, c’est un pointeur nul (a damn one), ce qui signifie que la boîte de dialogue n’a pas de parent.(ahhh je compatie mais en vérité .....OSEF)

    Code:
    13 signals:
    14      void findNext(const QString &str, Qt::CaseSensitivity cs);
    15      void findPrevious(const QString &str, Qt::CaseSensitivity cs);
    La section des signaux déclare deux signaux que la boîte de dialogue émet quand l’utilisateur clique sur le bouton Find. Si l’option Search backward est activée, la boîte de dialogue émet findPrevious() ; sinon elle émet findNext().

    Le mot-clé signals est en fait une macro. Le préprocesseur C++ la convertit en langage C++ standard avant que le compilateur ne la voie. Qt::CaseSensitivity est un type énumération qui peut prendre les valeurs Qt::CaseSensitive et Qt::CaseInsensitive.

    Code:
    16 private slots:
    17       void findClicked();
    18       void enableFindButton(const QString &text);
    
    19 private:
    20      QLabel *label;
    21      QLineEdit *lineEdit;
    22      QCheckBox *caseCheckBox;
    23      QCheckBox *backwardCheckBox;
    24      QPushButton *findButton;
    25      QPushButton *closeButton;
    26 };
     
    27   #endif
    Dans la section privée de la classe, nous déclarons deux slots. Pour implémenter les slots, vous devez avoir accès à la plupart des widgets enfants de la boîte de dialogue, nous conservons donc également des pointeurs vers eux. Le mot-clé slots, comme signals, est une macro qui se développe pour produire du code que le compilateur C++ peut digérer.

    S’agissant des variables privées, nous avons utilisé les déclarations préalables de leurs classes.
    C’était possible puisque ce sont toutes des pointeurs et que nous n’y accédons pas dans le fichier d’en-tête, le compilateur n’a donc pas besoin des définitions de classe complètes. Nous aurions pu inclure les fichiers d’en-tête importants (<QCheckBox>, <QLabel>, etc.), mais la compilation se révèle plus rapide si vous utilisez les déclarations préalables dès que possible. (ze3ma Merci pour le conseil )

    Nous allons désormais nous pencher sur finddialog.cpp qui contient l’implémentation de la classe FindDialog.

    Code:
    1 #include <QtGui>
    2 #include "finddialog.h"
    Analyse :
    Nous incluons d’abord <QtGui>, un fichier d’en-tête qui contient la définition des classes GUI de Qt. Qt est constitué de plusieurs modules, chacun d’eux se trouvant dans sa propre bibliothèque.
    Les modules les plus importants sont QtCore, QtGui, QtNetwork, QtOpenGL, QtSql, QtSvg et QtXml. Le fichier d’en-tête <QtGui> renferme la définition de toutes les classes qui font partie des mo dules QtCore et QtGui. En incluant cet en-tête, vous évitez la tâche fastidieuse d’inclure chaque classe séparément.

    Dans filedialog.h, au lieu d’inclure <QDialog> et d’utiliser des déclarations préalables pour QCheckBox, QLabel, QLineEdit et QPushButton, nous aurions simplement pu spécifier <QtGui>. Toutefois, il est généralement malvenu d’inclure un fichier d’en-tête si grand depuis un autre fichier d’en-tête, notamment dans des applications plus importantes.

    Code:
    3 FindDialog::FindDialog(QWidget *parent)
    4     : QDialog(parent)
    5 {
    6     label = new QLabel(tr("Find &what:"));
    7     lineEdit = new QLineEdit;
    8     label->setBuddy(lineEdit);
    
    9     caseCheckBox = new QCheckBox(tr("Match &case"));
    10   backwardCheckBox = new QCheckBox(tr("Search &backward"));
    
    11    findButton = new QPushButton(tr("&Find"));
    12    findButton->setDefault(true);
    13    findButton->setEnabled(false);
    
    14    closeButton = new QPushButton(tr("Close"));
    Analyse :
    A la ligne 4 : nous transmettons le paramètre parent au constructeur de la classe de base. Puis nous créons les widgets enfants. Les appels de la fonction tr() autour des littéraux chaîne les marquent dans l’optique d’une traduction en d’autres langues. La fonction est déclarée dans QObject et chaque sous-classe qui contient la macro Q_OBJECT. Il est recommandé de prendre l’habitude d’encadrer les chaînes visibles par l’utilisateur avec tr(), même si vous n’avez pas l’intention de faire traduire vos applications en d’autres langues dans l’immédiat.

    Dans les littéraux chaîne, nous utilisons le caractère & pour indiquer des raccourcis clavier. Par exemple, la ligne 11 crée un bouton Find que l’utilisateur peut activer en appuyant sur Alt+F sur les plates-formes qui prennent en charge les raccourcis clavier. Le caractère & peut également être employé pour contrôler le focus, c’est-à-dire l’élément actif : à la ligne 6, nous créons une étiquette avec un raccourci clavier (Alt+W), et à la ligne 8, nous définissons l’éditeur de lignes comme widget compagnon de l’étiquette. Ce compagnon (buddy) est un widget qui reçoit le focus quand vous appuyez sur le raccourci clavier de l’étiquette. Donc, quand l’utilisateur appuie sur Alt+W (le raccourci de l’étiquette), l’éditeur de lignes reçoit le contrôle.

    A la ligne 12, nous faisons du bouton Find le bouton par défaut de la boîte de dialogue en appelant setDefault(true). Le bouton par défaut est le bouton qui est pressé quand l’utilisateur appuie sur Entrée. A la ligne 13, nous désactivons le bouton Find. Quand un widget est désactivé, il apparaît généralement grisé et ne répondra pas en cas d’interaction de l’utilisateur.


    Code:
    15 connect(lineEdit, SIGNAL(textChanged(const QString &)),
    16       this, SLOT(enableFindButton(const QString &)));
    17 connect(findButton, SIGNAL(clicked()),
    18       this, SLOT(findClicked()));
    19 connect(closeButton, SIGNAL(clicked()),
    20       this, SLOT(close()));
    Analyse :
    Le slot privé enableFindButton(const QString &) est appelé dès que le texte change dans l’éditeur de lignes. Le slot privé findClicked() est invoqué lorsque l’utilisateur clique sur le bouton Find. La boîte de dialogue se ferme si l’utilisateur clique sur Close. Le slot close() est hérité de QWidget et son comportement par défaut consiste à masquer le widget (sans le supprimer). Nous allons étudier le code des slots enableFindButton() et find- Clicked() ultérieurement.
    Etant donné que QObject est l’un des ancêtres de FindDialog, nous pouvons omettre le
    préfixe QObject:: avant les appels de connect().


    Voila , une pause s'impose (pas mal le jeu de mot hein) , la prochaine fois nous continuerons un peu avec les boites de dialogue .

    A Venir : Description détaillée des signaux et slots
    Dernière édition par TeamWorK; 25/07/2012 à 06h21
    Not Available

  7. #6
    Inscrit
    juin 2012
    Lieu
    Not Available
    Messages
    537
    Remerciements
    15
    Remercié(e) 188 fois dans 140 messages
    Pouvoir de réputation
    8

    Arrow Re : C++ GUI Avec Qt , Bienvenue en enfer

    Remarque :
    Avant de commencer , j'attire votre attention sur un commentaire au tous début qui voulais voir l'enfer en question , et bien il faut savoir que le propriétaire du commentaire n'as plus poser de question de ce genre depuis un bon bout de temps .......... hmmm les padawanes je te jure mais comparé au siths la question ne se pose même pas .

    Description détaillée des signaux et slots :
    Le mécanisme des signaux et des slots est une notion fondamentale en programmation Qt. Il permet au programmeur de l’application de relier des objets sans que ces objets ne sachent quoi que ce soit les uns sur les autres. Nous avons déjà connecté certains signaux et slots ensemble, déclaré nos propres signaux et slots, implémenté nos slots et émis nos signaux. Étudions désormais ce mécanisme plus en détail. (t9ar3idje quoi)

    Bref ,les slots sont presque identiques aux fonctions membres ordinaires de C++. Ils peuvent être virtuels, surchargés, publics, protégés ou privés, être invoqués directement comme toute autre
    fonction membre C++, et leurs paramètres peuvent être de n’importe quel type. La différence est qu’un slot peut aussi être connecté à un signal, auquel cas il est automatiquement appelé à chaque fois que le signal est émis.

    Voici la syntaxe de l’instruction connect()*:

    Code:
    connect(sender, SIGNAL(signal), receiver, SLOT(slot));
    où sender et receiver sont des pointeurs vers QObject et où signal et slot sont des signatures de fonction sans les noms de paramètre. Les macros SIGNAL() et SLOT() convertissent leur argument en chaîne.

    Dans les exemples étudiés jusque là, nous avons toujours connecté les signaux aux divers slots.
    Il existe d’autres possibilités à envisager.

    1 - Un signal peut être connecté à plusieurs slots :

    Code:
    connect(slider, SIGNAL(valueChanged(int)),
            spinBox, SLOT(setValue(int)));
    connect(slider, SIGNAL(valueChanged(int)),
            this, SLOT(updateStatusBarIndicator(int)));
    Quand le signal est émis, les slots sont appelés les uns après les autres, dans un ordre non spécifié

    2 - Plusieurs signaux peuvent être connectés au même slot :

    Code:
    connect(lcd, SIGNAL(overflow()),
            this, SLOT(handleMathError()));
    connect(calculator, SIGNAL(divisionByZero()),
            this, SLOT(handleMathError()));
    Quand l’un des signaux est émis, le slot est appelé.

    3 - Un signal peut être connecté à un autre signal :

    Code:
    connect(lineEdit, SIGNAL(textChanged(const QString &)),
            this, SIGNAL(updateRecord(const QString &)));
    Quand le premier signal est émis, le second est également émis. En dehors de cette caractéristique,
    les connexions signal-signal sont en tout point identiques aux connexions signal-slot.

    4 - Les connexions peuvent être supprimées :

    Code:
    disconnect(lcd, SIGNAL(overflow()),
               this, SLOT(handleMathError()));
    Vous n’en aurez que très rarement besoin, parce que Qt supprime automatiquement toutes les connexions concernant un objet quand celui-ci est supprimé. (ahh Qt nass mle7 ...ness mle7 city)

    Pour bien connecter un signal à un slot (ou à un autre signal), ils doivent avoir les mêmes types de paramètre dans le même ordre :

    Code:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),
            this, SLOT(processReply(int, const QString &)));
    Exceptionnellement, si un signal comporte plus de paramètres que le slot auquel il est connecté, les paramètres supplémentaires sont simplement ignorés :

    Code:
    connect(ftp, SIGNAL(rawCommandReply(int, const QString &)),
            this, SLOT(checkErrorCode(int)));
    Si les types de paramètre sont incompatibles, ou si le signal ou le slot n’existe pas, Qt émettra un avertissement au moment de l’exécution si l’application est générée en mode débogage. De même, Qt enverra un avertissement si les noms de paramètre se trouvent dans les signatures du signal ou du slot.

    Jusqu’à présent, nous n’avons utilisé que des signaux et des slots avec des widgets. Cependant, le
    mécanisme en soi est implémenté dans QObject et ne se limite pas à la programmation d’interfaces graphiques utilisateurs. Il peut être employé par n’importe quelle sous-classe de QObject*:

    Code:
    class Employee*: public QObject
    {
       Q_OBJECT
    public:
       Employee() { mySalary = 0; }
    
       int salary() const { return mySalary; }
    
    public slots:
       void setSalary(int newSalary);
    
    signals:
       void salaryChanged(int newSalary);
    
    private:
       int mySalary;
    };
    
    void Employee::setSalary(int newSalary)
    {
       if (newSalary*!= mySalary) {
          mySalary = newSalary;
          emit salaryChanged(mySalary);
       }
    }
    Vous remarquerez la manière dont le slot setSalary() est implémenté. Nous n’émettons le signal salaryChanged() que si newSalary*!= mySalary. Vous êtes donc sûr que les connexions cycliques ne débouchent pas sur des boucles infinies.

    Système de méta-objets de Qt = > Google is your damn friend .

    Conception rapide d’une boîte de dialogue :
    Qt est conçu pour être agréable et intuitif à écrire, et il n’est pas inhabituel que des programmeurs développent des applications Qt complètes en saisissant la totalité du code source C++.
    De nombreux programmeurs préfèrent cependant utiliser une approche visuelle pour concevoir les formulaires. Ils la trouvent en effet plus naturelle et plus rapide, et ils veulent être en mesure de tester et de modifier leurs conceptions plus rapidement et facilement qu’avec des formulaires codés manuellement.

    Le Qt Designer développe les options à disposition des programmeurs en proposant une fonctionnalité visuelle de conception. Le Qt Designer peut être employé pour développer tous les formulaires d’une application ou juste quelques-uns. Les formulaires créés à l’aide du Qt Designer étant uniquement constitués de code C++, le Qt Designer peut être utilisé avec une chaîne d’outils traditionnelle et n’impose aucune exigence particulière au compilateur.

    Nous utiliserons le Qt Designer afin de créer la boîte de dialogue Go-to-Cell (et non pas Go-to-hell). Quelle que soit la méthode de conception choisie, la création d’une boîte de dialogue implique toujours les mêmes étapes clés :

    - créer et initialiser les widgets enfants ;
    - placer les widgets enfants dans des dispositions ;
    - définir l’ordre de tabulation ;
    - établir les connexions signal-slot ;
    - implémenter les slots personnalisés de la boîte de dialogue.

    Pour lancer le Qt Designer, cliquez sur Qt by Trolltech v4.x.y > Designer dans le menu Démarrer sous Windows, saisissez designer dans la ligne de commande sous Unix ou double cliquez sur Designer dans le Finder de Mac OS X. Quand le Qt Designer démarre, une liste de modèles s’affiche. Cliquez sur le modèle "Widget", puis sur OK. (Le modèle "Dialog with Buttons Bottom" peut être tentant, mais pour cet exemple nous créerons les boutons OK et Cancel manuellement pour vous expliquer le processus.) Vous devriez à présent vous trouver dans une fenêtre appelée "Untitled".

    Par défaut, l’interface utilisateur du Qt Designer consiste en plusieurs fenêtres de haut niveau.
    Si vous préférez une interface de style MDI, avec une fenêtre de haut niveau et plusieurs sous fenêtres, cliquez sur Edit > User Interface Mode > Docked Window

    La première étape consiste à créer les widgets enfants et à les placer sur le formulaire. Créez une étiquette, un éditeur de lignes, un élément d’espacement horizontal et deux boutons de commande. Pour chaque élément, faites glisser son nom ou son icône depuis la boîte des widgets du Qt Designer vers son emplacement sur le formulaire. L’élément d’espacement, qui est invisible dans le formulaire final, est affiché dans le Qt Designer sous forme d’un ressort bleu.

    Faites glisser le bas du formulaire vers le haut pour le rétrécir. Ne perdez pas trop de temps à positionner les éléments sur le formulaire ; les gestionnaires de disposition de Qt les disposeront précisément par la suite. (ahh toujours aussi sympa ce Qt)

    Configurez les propriétés de chaque widget à l’aide de l’éditeur de propriétés du Qt Designer :
    1. Cliquez sur l’étiquette de texte. Assurez-vous que la propriété objectName est label et définissez la propriété text en &Cell Location:.
    2. Cliquez sur l’éditeur de lignes. Vérifiez que la propriété objectName est lineEdit.
    3. Cliquez sur le premier bouton. Configurez la propriété objectName en okButton, la propriété enabled en false, la propriété text en OK et la propriété default en true.
    4. Cliquez sur le second bouton. Définissez la propriété objectName en cancelButton et la propriété text en Cancel.
    5. Cliquez sur l’arrière-plan du formulaire pour sélectionner ce dernier. Définissez objectName en GoToCellDialog et windowTitle en Go to Cell.

    Tous les widgets sont correctement présentés, sauf l’étiquette de texte, qui affiche &Cell Location.
    Cliquez sur Edit > Edit Buddies pour passer dans un mode spécial qui vous permet de configurer les compagnons. Cliquez ensuite sur l’étiquette et faites glisser la flèche rouge vers l’éditeur de lignes. L’étiquette devrait présenter le texte "Cell Location" et l’éditeur de lignes devrait être son widget compagnon. Cliquez sur Edit > Edit widgets pour quitter le mode des compagnons.

    A Venir : La suite du cours
    Dernière édition par TeamWorK; 02/08/2012 à 02h48
    Not Available

Sujets similaires

  1. Je me souhaite la Bienvenue !!!
    Par wassim dans le forum Présentations
    Réponses: 6
    Dernier message: 17/10/2012, 13h00
  2. L'enfer de nos cybercafés !
    Par Essedik dans le forum Discussions Libres
    Réponses: 8
    Dernier message: 02/09/2012, 22h45
  3. Charlie Hebdo, «brûlé par les flammes de l’enfer»
    Par Essedik dans le forum Discussions Libres
    Réponses: 7
    Dernier message: 11/12/2011, 20h28
  4. Bienvenue à Google +
    Par Milax dans le forum Vannes
    Réponses: 1
    Dernier message: 30/06/2011, 19h22
  5. Hôpitaux Algériens, Bienvenue en Enfer video choc
    Par Maverick dans le forum Vidéos
    Réponses: 3
    Dernier message: 28/04/2011, 23h29

Règles des messages

  • Vous ne pouvez pas créer de sujets
  • Vous ne pouvez pas répondre aux sujets
  • Vous ne pouvez pas importer de fichiers joints
  • Vous ne pouvez pas modifier vos messages
  •  
  • Les BB codes sont Activés
  • Les Smileys sont Activés
  • Le BB code [IMG] est Activé
  • Le code [VIDEO] est Activé
  • Le code HTML est Désactivé



Liens annexes