Nokia Qt 4.5 et versions de Qt Creator 1.0 - Qt Extended sac pro
Les nouvelles sont vieux, mais est encore chaud. Sur la journée de mardi dernier Mars 3, Nokia a annoncé la tant attendue version 4.5 de Qt, donna un ordre à Qt Extended et a également publié la première version de Qt Creator.
Installation et intégration Eclipse, CDT, Qt, Subversion, Perl, des outils Web Vim et uniquement avec la souris
Il ya bien longtemps dans un poste pas trop loin d'ici, nous montrons comment installer eclipse avec des plugins pour le développement et l'intégration de Qt avec Subversion. Mais le temps passe, le changement des versions et tout est différent, et cette fois nous allons montrer comment faire cela seulement avec clics et un Eee PC.
Eclipse + Qt + svn
Plus carnet personnel d'un tutoriel, j'ai ressenti le besoin de quitter un endroit facilement accessible, les étapes de configuration de l'éclipse pour mon propre usage, ou l'installation d'Eclipse et les plugins que j'utilise normalement (svn et qt) .
Les commandes qui affectent les répertoires en dehors de votre maison, besoin d'une autorisation de superutilisateur.
Si vous décidez d'installer l'éclipse à partir des paquets disponibles dans votre distribution, vous pouvez sauter directement à l'étape n ° 2.
# Etape 0: Installer Java
Pour le travail éclipse, vous avez besoin de Java Runtime Environment (JRE) installée * E * configuré.
Le JRE peut être téléchargé directement à partir du site de Sun http://java.sun.com/javase/downloads/index.jsp . Les instructions complètes pour l'installation et la configuration peut être trouvé à http://java.sun.com/javase/6/webnotes/install/index.html , pour le cas de Java 6.
Étape # 1: Donwload et installer Eclipse
L'éclipse peut être facilement téléchargés depuis la zone téléchargements sur son site officiel: http://www.eclipse.org/downloads . Après le téléchargement, il suffit de décompresser et de cesser d'utiliser. Dans mon cas, j'ai utilisé:
-xvzf eclipse-cpp-europa-winter-linux-gtk.tar.gz -C / usr / local user @ host $ tar-xvzf eclipse-cpp-europa-winter-linux-gtk.tar.gz-C / usr / local
Si tout s'est bien passé l'éclipse sera exécutable dans / usr / local / eclipse / eclipse, puis il suffit de créer un lien / raccourci / que ce soit dans votre environnement graphique préféré.
Étape # 2: Téléchargez et installez l'intégration plugin avec QT
Le plugin que j'utilise actuellement est fournie par Trolltech propre. Il vous permet de gérer vos fichiers de projet à partir d'un petit éditeur graphique, et même si vous préférez, ont un accès direct vers le fichier. Pro.
Ils peuvent être téléchargés à partir http://trolltech.com/developer/downloads/qt/eclipse-integration-download et instructions complètes d'installation qui peuvent être trouvés à http://trolltech.com/developer/downloads/qt / qteclipse-installmanual , est extrêmement compliquée:
-xvzf qt-eclipse-integration-linux.x86-gcc3.3-1.4.0.tar.gz -C / usr / local user @ host $ tar-xvzf qt-eclipse-integration-linux.x86-gcc3.3-1.4.0.tar.gz-C / usr / local
Si tout va bien, les fichiers du plugin sont copiés dans le répertoire / usr / local / eclipse / plugins.
Note: Pour ceux qui ont opté pour l'installation de l'éclipse à travers le package de distribution, attention! A l'intérieur du fichier compressé, le répertoire est eclipse / plugins / et dentaires lui les fichiers du plugin qui devrait être copiés dans le répertoire plugins de votre installation Eclipse, habituellement / usr / lib / eclipse / plugins.
Après l'installation, démarrez Eclipse avec la commande:
usr / local / eclipse / eclipse -clean user @ host $ / usr / local / eclipse / eclipse-clean
Maintenant, allez à Fenêtre> Préférences> et définir la version Qt et "chemins", en fonction de votre installation de Qt
Pour être plus pratique si vous invoquez l'éclipse directement à partir de la ligne de commande, ajoutez le répertoire de votre exécutable dans la variable d'environnement $ PATH dans l'une des scripts de démarrage (. Bash_profile)
= $PATH : / usr / local / eclipse export PATH = $ PATH: / usr / local / eclipse
Étape # 3: Subversion
Dans éclipse aller à Aide Mises à jour de logiciels> Rechercher et installer. Marke l'option Rechercher de nouvelles fonctions à installer et cliquez sur Suivant. Maintenant, ajoutez les sites distants:
Buckminster
http://download.eclipse.org/tools/buckminster/updates
Subclipse
http://subclipse.tigris.org/update_1.2.x
Cochez les cases respectives et cliquez sur Terminer. Après une brève consultation à l'Internet, il suffit de cocher le plugin et ses dépendances et d'exécuter pour se câliner.
À partir de l'intervalle QT, la partie III - qmake et Pro.
Dans ce troisième poste, nous allons parler des fichiers utilitaires QT projet qmake et *. Pro. Entendons-nous bien ce que c'est pour qmake et la façon de configurer différents types de projets.
Le qmake
Le qmake est un utilitaire qui est livré avec le framework QT. Sa fonction est d'analyser un fichier de projet (*. Pro) et générer un Makefile déjà avec les règles de la moc , uic et les options de QT embarqués. Sans elle, par exemple, aurait d'appeler explicitement le moc de créer des fichiers et moc_ * explicitement passer aux options du compilateur et du lieur d'inclure l'intervalle QT correcte à nos projets.
La documentation officielle sur les fichiers qmake et le projet peut être trouvé ici .
Fichiers de projet *. Pro
Pour créer un projet simple à partir de la ligne de commande, entrez le répertoire du projet et en tapant:
user @ host $ qmake-project
Cela fait, vous allez créer un fichier avec le même nom que le répertoire courant, suivi de l'extension. Pro. S'il ya déjà des fichiers dans ce répertoire reconnus par qmake, sous forme de fichiers de code source (. H. Cpp), les formes (. Ui), etc, ils sont automatiquement ajoutés au dossier de projet.
Créé le fichier. Pro, d'exécuter qmake sans argument, il va essayer d'analyser un fichier. Pro avec le même nom que le répertoire courant. Vous pouvez même spécifier un fichier de projet alternatif comme un argument pour qmake. Si tout s'est bien passé, a été créé un fichier Makefile, et avec une marque simple, nous pouvons construire le projet.
Les fichiers de projet sont des fichiers texte contenant des macros réguliers et les directives qui seront interprétés par qmake pour créer le Makefile. La liste complète des options peut être trouvée dans la documentation en ligne . Les plus courants sont:
MODÈLE: Indiquez le type de projet. Utilisez 'app' pour les exécutables proramas ou «lib» de créer des bibliothèques.
CONFIG: Ajouter plusieurs options pour le projet. Parmi eux, des informations de débogage 'debug' ajouter, «staticlib 'avec' lib 'le modèle, qui est créé abiblioteca statique (. Il en linux).
CIBLE: Le nom et l'emplacement de la cible, c'est à dire, l'application ou la bibliothèque.
MOC_DIR: répertoire où les fichiers seront diplômés moc_ *. Utile pour ne pas polluer le répertoire du code source.
OBJECTS_DIR: complémentaire à l'option précédente indique le répertoire où les fichiers qu'il va générer le code objet (* O.).
INCLUDEPATH: annuaires externes en-têtes HTTP doivent être utilisés dans le projet, comme en-têtes de bibliothèques externes.
DEPENDPATH: externes répertoires de code source qui seront utilisés par le projet.
En-têtes: Les fichiers d'en-tête du projet (* H.).
FORMES: fichiers d'interface générés avec le QTDesigner (* Ui.).
SOURCES: Les fichiers de mise en œuvre du code source du projet (* Cpp.).
LIBS: bibliothèques externes utilisées par le projet. -L indique le chemin vers la bibliothèque, e-l dit le nom de la bibliothèque.
QT: QT modules à ajouter / supprimer du projet. Si le passé "QT = '(égal QT vide), l'intervalle QT a pas de module utilisé dans le projet.
SUBDIRS: Utilisé en conjonction avec «des sous-répertoires« le modèle indique que le qmake sous-répertoires ons doit rechercher des fichiers d'autres projets.
Avec cette main, nous pouvons créer dans des conceptions simples CERTAINS.
Une application simple:
# La première ligne crée un personnage de ce commentaire # Le nom de ce fichier est «app.pro ' Notre modèle # template app = est une application appelée TARGET = bin / # myapp.bin myapp.bin au sein de la dir. / Bin MOC_DIR = tmp / moc Annuaire # pour GPM, en option OBJECTS_DIR = tmp / obj # répertoire pour le code objet, en option HEADERS + = MyClass.h # class MyClass tête SOURCES + = main.cpp # Utilisez-le pour organiser les fichiers en MyClass.cpp lignes # multiples.
Une bibliothèque simple:
# Le nom de ce fichier est «lib.pro ' Notre modèle # template = lib est une bibliothèque CONFIG + = # dll appel dynamique TARGET = lib / mylib # mylib au sein de la dir. / Lib MOC_DIR = tmp / moc Annuaire # pour GPM, en option OBJECTS_DIR = tmp / obj # répertoire pour le code objet, en option HEADERS + = MyClass.h # class MyClass tête SOURCES + = # MyClass.cpp mise en œuvre de classe MyClass
Une application qui utilise une bibliothèque externe:
# Le nom de ce fichier est «mixed.pro '# TEMPLATE = app Notre modèle est une application appelée TARGET = bin / # myapp.lkd myapp.lkd au sein de la dir. / Bin MOC_DIR = tmp / moc # Dossier pour les GPM, en option OBJECTS_DIR = tmp / obj # répertoire pour le code objet, INCLUDEPATH option + =. # Dir, où sont les en-têtes des SOURCES lib externes + = main.cpp # Mise en œuvre de l'application.
Répertoires imbriqués:
Pour utiliser les répertoires imbriqués, il nous faut un fichier de projet dans le répertoire courant, et un autre sous-répertoire.
Dans le répertoire courant, utilisez les options:
Template = subdirs SUBDIRS = [liste de sous-répertoires doivent être construites en séquence]
Si on leur donne seulement le nom du répertoire, il doit contenir un fichier de projet avec votre propre nom. Est-il possible dans entando, relèvera directement de la liste des sous-répertoires, un répertoire suivi d'un dossier de projet avec le nom de Quaker.
Le code source complet des exemples abordés dans ce tutoriel peut être trouvé ici .
En conclusion
Le qmake est un outil simple et très puissant qui facilite grandement la vie de celui qui doit gérer des arborescences de projet complexe, même si le projet n'utilise pas QT (il suffit d'ajouter à la fin de la «QT = '). Ajouter à cela le fait que les dossiers de projets ont une syntaxe très simple et peu intuitive. Si vous avez besoin des ajustements plus fins, de la documentation en ligne vous donnera une douzaine d'options pour le plaisir.
Avec ou sans QT QT qmake est toujours une bonne option pour la gestion de l'arbre de construction.
À partir de l'intervalle QT, Partie II - Signaux, fentes et Timers
Dans ce post, j'ai suivi avec le jeu pour faire des tutoriels pour débutants petits sur l'intervalle QT. Cette fois, je vais montrer comment créer vos propres signaux et slots et comment gérer une minuterie.
Le code source peut être trouvé à ce lien .
L'exemple de programme est un timer qui va utiliser la classe QTimer , l'une des principales classes de l'intervalle QT, et affiche l'heure en utilisant un style LCD écran de la calculatrice avec la classe QLCDNumber .
QT et Timers
Les minuteries de soutien les plus élémentaires dans l'intervalle QT est disponible à partir de la classe QObject qui fournit des méthodes startTimer :: QObject () et QObject :: KillTimer () . Procédé première renvoie un identificateur unique et la deuxième minuterie de la minuterie extrémités travers cet ID.
Pour que cela fonctionne, cependant, l'extrait de code qui utilise ce mécanisme doit être l'intérieur d'une "boucle d'évènement". A partir du moment de la minuterie est-il commencé de temps en temps (timeout) fait une demande dispate QTimerEvent , ce qui perturbe le flux normal du programme jusqu'à ce que l'événement est traité.
Le délai maximal n'est pas définie, et peut créer des minuteries avec temporisation d'années, cependant, le minimum de temps peut varier d'un système à. Dans Windows Vista, le timer minimum est de 10 ms tandis que dans Linux 2.6.x ce qui est configurable (par défaut est de 4 ms). Le QT vais essayer de livrer tous les événements, comme l'a demandé, mais si le système ne lui permet pas vont rejeter le «surplus».
Les minuteries peuvent aussi être utilisés dans des threads, mais vous devez satisfaire à l'exigence d'être l'intérieur d'une boucle d'événement. Discussions méritent un article distinct, comme toujours ...
Les classes QTimer minuteries implémente niveau supérieur, ce qui permet à certaines fonctions. Le premier est le QTimer :: SingleShot () , qui déclenche un événement fois.
Lisez la documentation vaste et répétitif, ennuyeux, mais croyez-moi, vous permettra d'économiser beaucoup de QDorDeCabeca ...
Plus sur Signaux et Slots
Signaux et les slots sont utilisés pour la communication entre objets, l'un des éléments fondamentaux de l'intervalle QT. Dans ce système, plutôt que d'implémenter des rappels pour gérer les événements, nous utilisons le concept de connecter les signaux aux slots, ce qui rend la programmation plus intuitive.
Signaux et les slots sont des méthodes de classe qui sont manipulés par le compilateur de méta-objets (moc) avant le code source en cours de compilation. Ils ont des états spéciaux qui ne font pas partie de la norme C + +, donc fazum moc l'analyse du code source compilable et génère.
Lorsque vous exécutez le moc sur toute classe qui implémente les signaux et les slots, une certaine quantité de code source est généré. Utilisation du programme qmake , moc l'appel au programme est pris en charge par le Makefile, ce qui en fait transparente pour le programmeur.
Pour une classe peut implémenter signaux et des slots, il doit avoir accès à la Meta System-Object . Donc, il devrait hériter de la classe QObject et de ses sous-classes, et ont besoin de la macro Q_OBJECT dans votre déclaration de confidentialité région. Terminé les préparatifs, les signaux sont déclarés dans une section "signaux" dans les sections et les fentes "[public | | Les protégées privées] créneaux horaires".
Une fente après, déclaré, est alors définie comme toute autre méthode commune, peut être appelé explicitement comme un autre. Déjà, les signes sont un peu plus délicat, et ne sont jamais défini et déclaré par le programmeur. La raison? Ce message à la fin de la tentative de construire:
tmp / moc_mydisplay.o: In function `MyDisplay :: signalPlay () ': ~ / Chronomètre / tmp / moc_mydisplay.cpp: 89: définition multiple de `signalPlay MyDisplay :: () ' tmp / mydisplay.o: ~ / chronomètre / mydisplay.cpp: 169: tout d'abord défini ici collect2: ld returned 1 exit status faire: ** [chronomètre] Erreur 1
Dans le fichier est généré moc_mydisplay.cpp le code suivant:
/ / 0 SIGNAL signalPlay ( ) MyDisplay vide :: signalPlay () { activate ( this , & staticMetaObject , 0 , 0 ) ; QMetaObject :: activate (ce, & staticMetaObject, 0, 0); }
Oui, moc génère des signaux à la définition de soi-disant méta-méthodes de l'intervalle QT. Par conséquent, la définition du corps d'un signe est illégal en CT et va générer une erreur de compilation pour la méthode de réinitialisation. Laissez-moc prend soin de la mise en œuvre du signal pour vous.
Relier
Il n'est donc pas seulement d'utiliser des signaux définis et les fentes. Vous devez définir la façon dont ils interagissent. La façon de faire est de les relier grâce à la méthode connect () tout au long de cet héritier de QObject . Ce sera la mise en œuvre moc le signal de sorte qu'un appel à elle les résultats de l'appel (s) emplacement (s) connexion (s) avec les mêmes paramètres.
En fonction de connexion, un signal peut aussi retourner la même valeur que le dernier emplacement rappelé. Notez que ce n'est pas très sûr pour les signaux connectés à plusieurs fentes, par conséquent, rien ne garantit l'ordre d'appel.
Un signal de donnée peut être relié à un second signal directement. Un émettent () dans le premier signal est alors équivalente à émettre () dans le second signal, tandis que, après l'étape de création des GPM, les résultats d'appel dans la première à la deuxième appel, qui se traduit par l'appel est connecté à une autre méthode, et ainsi de suite .
Façons de se connecter
Il existe essentiellement trois façons de se connecter signaux et les slots et s'il n'est pas utilisé correctement peut être une source de bugs terriblement difficiles à découvrir. Ces formes de connexion sont passés comme des paramètres supplémentaires à la méthode connect (). Ils sont les suivants:
Direct Connect : Le slot est appelé immédiatement le signal a été émis dans le thread où le signal a été émis. Cela agit comme un appel direct à la fente.
File d'attente de connexion : Le signal est envoyé et l'appel à la fente va à une liste interne de l'intervalle QT, et le signal retourne immédiatement, quel que soit l'emplacement ont été appelés ou non. La boucle sera alors Evente traitement de cette liste et que plus tard la fente est appelé sur le thread où réside l'objet fente.
Connexion automatique : C'est le type utilisé par défaut lorsque vous ne spécifiez pas le type de connexion. Il est l'un des «Seeds of Evil" , il présente deux comportements différents: si le signal et la fente se trouve sur le même fil, fonctionne comme une connexion directe, mais sinon il fonctionne comme connexion en file d'attente.
Bloquer les connexions en file d'attente : Hey!? ne sont pas seulement trois? Eh bien, c'est un avantage de lire cet article: pour épargner la documentation INCOMPATIBLE! Cette connexion est similaire à la connexion en file d'attente, à l'exception que le fil de signal est bloqué jusqu'à ce que le signal à dûment exécutés. Notez que ne devraient être utilisés avec beaucoup d'attention, et signaux et des slots sur différents threads. Une mauvaise utilisation peut aussi causer des blocages. Vous savez quand vous voyez quelque chose comme ceci:
user @ host: ~ / chronomètre $ / chronomètre. Qt: impasse détecté lors de l'activation de la BlockingQueuedConnection: l'expéditeur est QPushButton (0x807e2d8), le récepteur est MyDisplay (0x8076ac0)
Pour résoudre les doutes sur ce que l'on entend par "thread où un objet réside" se réfèrent au fil QT arespeito.
Il faut toujours prendre le plus grand soin avec des signaux, des slots, les fils et les minuteries. Ce sont des caractéristiques clés de l'intervalle QT, mais sa mauvaise utilisation peut conduire à des bogues très difficiles à localiser. Voir toute la documentation à ce sujet.
Bas à la source
Notre exemple est composer de deux classes et MyDisplay StopWatch de fichiers et une commune principale. La principale et crée seulement un objet QApplication StopWatch. La classe prend en charge la pièce MyDisplay visuelle du programme, comprenant une boîte de dialogue avec des boutons et un style d'affichage à cristaux liquides. La classe chronomètre créer un widget pour afficher et mettre en œuvre la minuterie. Notez que cette architecture n'est pas le plus elegente, plus intéressant d'hériter de la classe MyDisplay StopWatch. Mais ce serait gâcher le jeu éliminant pratiquement la nécessité d'utiliser des signaux et slots.
L'utilisation des signaux et slots devient plus claire lorsque l'on veut des objets à communiquer avec l'extérieur. En général, les classes ne sais pas ce qui est dehors. En passant des pointeurs vers des objets externes en leur sein, ça fait mal à l'encapsulation et rend le code moins générique. Dans notre exemple, le plus intéressant d'utiliser des signaux et slots est myDisplay à l'objet (le StopWatch interne) des événements du rapport de / vers le chronomètre objet (Mydisplay externe), sans que cela soit perdu dans la généralité ou l'encapsulation.
Avec l'aide de Qt Designer (dans un autre article, je vais parler de cela), j'ai créé la boîte de dialogue, les boutons et l'écran LCD. Après simplifié le code pour l'adapter à nos besoins. Comment myDisplay hérite de QDialog, et ce hérite indirectement de QObject, d'utiliser des signaux et slots était suffisant pour ajouter la macro Q_OBJECT dans la section privée de la déclaration de classe. Après cela, entre autres, auxiliaire ajouté, les méthodes suivantes:
public slots: long ) ; slotDisplayValue vide (long); private slots: slotPlay vide (); nulle slotStop (); signaux: signalPlay vide (); nulle signalPause (); nulle signalStop (); nulle signalReset ();
Les signes de communiquer aux événements extérieurs liés aux clics de bouton. Déjà, les slots privés feront une procédure de pré-traitement, tandis que le public a droit à tiques minuterie de l'extérieur. Ainsi, la classe envoie des informations vers l'extérieur et reçoit des informations de l'extérieur, sans savoir ce qui est de l'autre côté. Le contrat d'interface bonne vieille.
public slots: slotPlay vide (); nulle slotPause (); nulle slotStop (); nulle slotReset (); private slots: nulle slotTick (); signaux: long ) ; signalTicks vide (long);
Analogique et inversement la classe StopWatch met en œuvre les fentes qui reçoivent la classe MyDisplay signaux, et déclare le signal qui envoie des informations au public son logement.
Il implémente également un QTimer qui se déclenche toutes les 10 millisecondes (de sorte que nos amis peuvent suivre lerdinhos Vista!), Incrémentation d'un compteur. Ce compteur est renvoyé à des formats d'affichage et des écrans.
La minuterie peut être arrêté, en pause et redémarré à tout moment en cliquant sur le bouton approprié.
Les Finalmentes
L'exemple n'est pas en soi beaucoup de code, mais il illustre l'utilisation la plus fondamentale de minuteries et de la construction des signaux personnalisés et des fentes. Une attention toute particulière doit cependant être accordée aux détails qui impliquent l'utilisation de ces ressources, ils peuvent devenir des pièges mortels.
Liens importants
Signaux et Slots
QTimer
Discussions dans le QT
La documentation en ligne de l'intervalle QT
À partir de l'intervalle QT, la partie I
Sur demande, j'ai décidé de faire un bref article montrant pour commencer s'aventurer avec le QT.
En Apanas 20 lignes, avec l'espace (oui, l'espace est votre ami, ne laissez jamais) et les en-têtes supplémentaires, nous pouvons faire une "Bonjour tout le monde" tableau, qui utilise déjà les principales caractéristiques du cadre.
Comme je n'ai aucun moyen de tester sur d'autres plateformes, je pars du principe que la plate-forme utilisée est un * nix, et que les bibliothèques de développement QT sont déjà installés, ainsi que la norme de construction des outils. Si l'intervalle QT n'est pas installé, il est temps de jeter un oeil à ce lien .
Le code source complet peut être téléchargé à partir de l'exemple ici , mais si vous préférez le faire à la main, créez un répertoire n'importe où dans qthello et à l'intérieur d'un fichier appelé main.cpp avec le contenu suivant:
01 # include <qapplication> 02 # include <qwidget> 03 # include <qpushButton> 04 main ( int argc , char ** argv ) 05 int main (int argc, char ** argv) 06 { app ( argc , argv ) ; 07 QApplication (argc, argv) app; window ; 08 fenêtre QWidget; button ( "Hello World!" , & window ) ; 09 bouton QPushButton ("Bonjour tout le monde!", Et la fenêtre); 10 ( 300 , 200 ) ; 11 Redimensionner la fenêtre (300, 200).; ( 100 , 85 , 100 , 30 ) ; 12. Bouton setGeometry (100, 85, 100, 30); 13 :: connect ( & button , SIGNAL ( clicked ( ) ) , 14 QObject :: connect (& bouton, SIGNAL (clicked ()), SLOT ( quit ( ) ) ) ; & App, SLOT (quit ())); 15 ( ) ; 16 Fenêtre Show ().; app. exec ( ) ; 17. Retour app Exec (); 19} 20
Maintenant, allez dans un terminal dans ce répertoire et le type qmake-project.
Si tout est correctement installé, un fichier appelé qthello.pro doit avoir été créé. S'il n'ya pas de répertoire qthello.pro, ensuite en revue l'étape précédente.
Avec tous les terminaux installés dans un qmake && type faire. Cela va compiler l'exemple et tout s'est bien passé, un fichier exécutable appelé qthello a été créé.
Exécutez-le avec. / Qthello et une fenêtre avec un bouton devrait apparaître.
Ok, nous allons maintenant la partie amusante: le code source.
Les trois premières lignes ne contiennent que des en-têtes se rapportant à des classes que nous allons utiliser l'intervalle QT.
Ligne 7 déclare une application QT et il passe des paramètres reçus par le programme shell. La classe QApplication gère le flux principal du programme et ses paramètres. Il contient la boucle principale, où tous les événements de l'interface et d'autres sources sont traitées et expédiées. Elle gère également le démarrage et l'arrêt du programme, entre autres.
Ligne 8 déclare un widget qui sera notre principal élément graphique.
Ligne 9 déclare un bouton avec le texte "Bonjour tout le monde!" Et il est un «fils» de notre widget principal. Cela fera apparaître le bouton dans le widget principal.
Les lignes 11:12 configurer les composants de la forme et le positionnement.
Ligne 14 montre l'une des principales caractéristiques du cadre, le système signal-slot.
Signaux et les slots sont utilisés pour réaliser la communication entre les objets. Grâce à ce système peut tirer sur un objet (émettent) un événement (signal) qui peuvent être saisies et traitées par un (ou plusieurs) objet (s). Signaux et les slots sont des méthodes spéciales de la classe. Fondamentalement, l'émission d'un signal est traduit en un appel à la fente à travers le moc (méta-objet du compilateur) , qui prétraite le code source avant la compilation. Pour chaque classe qui implémente signaux et des slots, il génère un fichier appelé moc_nomedaclasse.cpp, qui est ensuite compilé avec le reste du code. Tout cela est fait dans la transparence et le programmeur n'a généralement pas à vous soucier de ces détails. En termes pratiques, émettent un signal de signigica la fente qui lui est associée par l'intermédiaire d'un appel connect est en quelque sorte avec les mêmes paramètres passés au signal. Plus d'informations peuvent être vérifiées dans la documentation en ligne.
Dans notre exemple, les liens se connecter le signal clicked () bouton d'objet, avec la fente quit () la mise en œuvre objet. Cela signifie qu'en cliquant sur le bouton, un signal est déclenché et par la suite capturé par l'objet d'application, puis le processus se termine.
A la ligne 16, appeler la méthode show () du widget afin qu'il devienne visible.
Dans la ligne 17, nous avons finalement contrôler programme de l'intervalle QT. La méthode exec () se déclenche la boucle principale et tous ses mécanismes, et ne revenir lorsque l'application est terminée, dans notre cas, quand app.quit () est appelée par le système signal-slot.
Ce simple "Bonjour tout le monde" peut sembler idiot, mais il suffit de démontrer quelques caractéristiques principales de l'intervalle QT, comme la boucle principale, la création d'objets graphiques et l'utilisation des signaux et slots.
Dans le prochain post je vous montrerai à créer nos propres signaux et slots et l'utilisation de minuteries.
Références:
QApplication
QWidget
QPushButton
Signaux et Slots
Construction d'un gestionnaire d'interface simple pour multi-fenêtres avec QT
A plusieurs reprises, j'ai fini par avoir à donner des interfaces du système d'entretien avec de nombreux écrans, que ce soit en mode texte ou graphique. Souvent, le nombre d'écrans a augmenté avec le système, sans planification préalable, qui a toujours conduit à un enchevêtrement d'appels obscurs, # ifndefs, commutateurs et autres monstres.
La première fois que je suis tombé sur un problème du genre, a été quand je faisais la première version d'un jeu comme la fin des années Elifoot à un procès équitable dans CEFETES. A l'époque je suis tombé sur un ensemble de fonctions où ils appelés les uns des autres et ne revint quand le but est arrivé. Résultat: il empiler! (Ne vous inquiétez pas, dans cette nouvelle version a été corrigé!)
Dans le cas de l'interface avec de multiples fenêtres, et dans les systèmes où la planification se fait à la volée-, est commun d'avoir des fenêtres qui appellent d'autres fenêtres avant de fermer les fenêtres et ainsi de suite, laissant derrière lui une traînée de destruction et de terreur. Croyez-moi, vous ne voudrez pas jamais prendre en charge la maintenance d'un tel rapp.
La poussière à la poussière ...
Dans mon cas, Résovi le problème en créant un gestionnaire d'interface. Un objet centralisé qui contrôle la création et la destruction des objets d'interface. Chaque objet, pour terminer leurs tâches, les signaux pour le gérant et il prend soin de nettoyer le gâchis. Ainsi, chaque fois qu'un objet est né, meurt et s'acquitte de ses tâches sans passer le contrôle du programme de l'avant, on en revient toujours au gestionnaire.
Notez que je n'ai pas dit que le gestionnaire va détruire l'objet, mais il faudra faire le nettoyage. Chaque objet doit être construit dans le but d'avertir le gestionnaire à chaque fois qu'il a terminé, soit avec succès ou a échoué. Souvent l'objet lui-même est en mesure de «tuer» et que seul est très utile, en prenant une partie de la gestionnaire de travaux, mais pas de contrôler.
Avant de commencer
Je ne prétends pas que ce poste simple, couvre toutes les fonctionnalités de l'intervalle QT ou tous les aspects des interfaces de gestion. Je vais juste parler de comment j'ai résolu un problème pour lequel je l'ai fait. Ce message est également un hommage à un ami Janeiro Paulo-Rio de qui a eu à éplucher un ananas comme ça!
Hands-on
Je suis, dans la plupart des cas, un programmeur de bas en haut, mais un analyste de haut en bas. Cela peut sembler déroutant, mais il n'y a aucune raison de paniquer, ou presque ...
Les objets doivent échanger des messages. Pour ce faire, le système signal-slot QT sera d'une grande aide. Les objets seront envoyer des signaux (EMIT (signal)) et le gestionnaire de les écouter (fentes ()).
Étonnamment, le constructeur de la gestionnaire, à partir de maintenant appelé l'UIM n'a pas une seule ligne de code. Il initialise simplement le pointeur vers 0, il suffit de la paranoïa (ou non) ...
L'UIM met en œuvre des fentes pour la création d'objets et de nettoyer le gâchis. Lorsque vous créez un objet, l'UIM se connecte cet objet à son nettoyage fente respective. Lorsque l'objet ne meurt, il active la fente de nettoyage dans l'UIM. Les créneaux horaires seront liés à la création des menus graphique objet principal de cet exemple, une fenêtre.
Les autres objets sont de petites fenêtres, boîtes de dialogue, un pour configuration de l'application, et deux à parler de lui (environ), après tout, le marketing est important ...
Tous les objets graphiques, j'ai cliqué, et entraîné le Qt Designer, puis ajustée pour obtenir ma façon. Rien à l'alignement de pixels dans la main, après tout n'est pas une œuvre d'art n'est qu'une preuve de concept.
Les objets graphiques
L'écran de configuration est un dialogue commun avec un combo-box où une liste de paramètres à passer à la page widget. Les détails que j'ai ajoutés le code généré par Qt Designer avoir un destructeur, et une paire de signaux-fente pour envoyer les données sélectionnées retour à la gestionnaire. Je n'ai pas pris la peine de garder une trace de la configuration actuelle. Ce chat est pour un autre poste.
Le abouts étaient essentiellement le même code ainsi que les destructeurs.
La fenêtre principale possède un menu qui appelle les autres fenêtres et d'un widget de plein fou de cases qui sont clignotants. Le carré est la quantité d'information qui va changer la configuration de la fenêtre.
Le QT magique
Tous les objets graphiques utilisés sont également QWidgets parce que leurs classes héritent de la classe QWidget, et je utiliser le constructeur suivant dans chaque méthode héritée:
this-> setAttribute (Qt :: WA_DeleteOnClose, true); Selon la documentation en ligne , cela indique que Qt, elle doit supprimer le widget quand il est fermé. Sinon, il est juste caché.
"... Quand un widget accepte l'événement close, elle est cachée ..."
"... Si vous voulez que le widget à supprimer Quand il est fermé, il crée avec le Qt :: WA_DeleteOnClose drapeau. Ceci est très utile pour les indépendants de haut niveau des fenêtres dans une application multi-fenêtre ... "
Les routines qui font la fin des objets dans l'échec, comme cliquer sur Annuler ou sur Fermer, sont directement reliés à sa fin propre fentes (). Cela déclenche une série d'événements qui aboutissent à la destruction de l'objet.
Les routines qui sont l'objet se termine avec succès, en cliquant sur OK et envoyer les données, ont été dirigés pour revenir à l'UIM, de sorte qu'il peut les acheminer. Après avoir obtenu les données, la fente UIM appelle directement à proximité de l'objet ().
Quand un objet est détruit, il envoie son dernier souffle, par exemple, un signe qui est détruit (). Littéralement, il hurle "I WAS!".
De "l'extérieur" de l'objet, l'UIM est à l'écoute, la connexion de ce signal pour le nettoyage de routine et TADAM! prête.
Dans l'exemple que j'ai utilisé, la quantité de places sur l'écran vient MyConf d'un objet, et passe par l'UIM est acheminé vers le MyApplication. Ce à son tour la transmet au widget interne fou.
Pour obtenir encore plus intéressant, tandis qu'une petite fenêtre est ouverte, le widget cesse de clignoter, le retour lorsque la trappe est fermée. Cela peut paraître idiot, mais c'était juste pour montrer que l'UIM a le plein contrôle sobreo ce qui se passe dans chaque fenêtre, tandis qu'elle était en focus ou non.
Conclusion
Le framework QT est immense et offre une gamme d'énormes caractéristiques. On est capable de contrôler la façon dont les objets sont détruits. L'utilisation de ce long avec un peu de planification et avec le système de signalisation-slot peut construire une interface très complexe, sans en faire une tarasque temps à entretenir.
Source:
PS: L'exemple de code source complet est sous licence GPL et peut être téléchargé par l'intermédiaire lien . Un jour, j'ai mis des commentaires sur elle ...
BUGFIX
L'insecte malheureux caché en l'absence de propriétés d'initialisation dans les MySquares constructeur de la classe. L'animal, bien que petite était empoisonnée, parce que provoquant un "Segmentation Fault". Lorsque vous démarrez le programme, si je devais partout sur la, et fermé, il a tiré une séquence d'événements qui découlaient de l'hypothèse que l'écran a déjà été configuré correctement. Le code corrigé est dans le lien ci-dessus, et souvenez-vous:
"Toujours initialiser vos variables"
Traducteur
