Gestion d'une interface graphique avec Qt

 $> cd ˜/Projet
 $> svn mkdir https://svn.lal.in2p3.fr/projects/Etudiants/<ens>/TpQt -m "Creation du dossier TpQt"
 $> svn checkout https://svn.lal.in2p3.fr/projects/Etudiants/<ens>/TpQt TpQt
      

 $> cd ˜/Projet
 $> svn export https://svn.lal.in2p3.fr/projects/Enseignement/LAL-Info/tags/head/Interfaces Interfaces
      

 $> cd ˜/Projet
 $> cmt create TpQt v1
 $> cd TpQt/v1/cmt
      

package TpQt
 
# Utilisation de l'outil Doxygen
use Platform v1r* Interfaces
 
# Utilisation de l'environnement Qt
use Qt       v2r* Interfaces
 
# Package d'utilitaires de reconstruction
use dld      v2r* Interfaces
 
include_dirs $(TPQTROOT)/include
 
# Création du fichier moc permettant de générer le code pour les événements
document moc moc_myWindow   FROM=../include/myWindow.h TO=../src/moc_myWindow.cpp
 
# Définition d'une librarie contenant notre classe
library TpLib   \
   ../src/myWindow.cpp \
   ../src/moc_myWindow.cpp
 
# Arguments de compilation et de link de la classe myWindow
macro lib_TpLib_cflags   " ${Qt_cflags}"
macro lib_TpLib_cppflags " ${lib_TpLib_cflags}"
macro TpLib_shlibflags   " ${Qt_linkopts} ${dld_linkopts}"
macro TpLib_linkopts     " -L${TPQTROOT}/$(Platform_bin) -lTpLib" \
    WIN32                  " ${TPQTROOT}\$(Platform_bin)\TpLib.lib"
 
macro_append QtTestlinkopts " ${TpLib_linkopts}"
 
# Construction de l'application QtTest.exe
application QtTest QtTest.cpp 
 
# Empaquetage de l'application au format Mac
document darwin_app TpQt   FROM=QtTest TO=../app/QtTest
 
# Mise-à-jour de la variable d'environnement DYLD_LIBRARY_PATH
path_append DYLD_LIBRARY_PATH "" Darwin "${TPQTROOT}/$(Platform_bin)"
# création de la documentation
document doxygen doc -group=documentation TO=../doc 
      

 #ifndef MYWINDOW_H
 #define MYWINDOW_H
 
 #include <QtGui/QMainWindow>
 #include <QtGui/QPushButton>
 
 /**
  * @file   myWindow.h
  * @author LAL ens <ens@lal.in2p3.fr>
  * @date   Mars 2007
  * 
  * @brief  first class HelloWorld in Qt
  * 
  * 
  */
 class myWindow : public QMainWindow
 {
   // macro Q_OBJECT indispensable pour spécifier à Qt l'utilisation du mécanisme interne de 
   // communication entre les classes.
   Q_OBJECT
   public:
 
   /** @brief Constructeur de la classe principale
    * @param parent : Widget parent de la classe. Dans notre cas, ce sera
    * la fenêtre principale, donc le parent sera "NULL"
    * @param fl : Flags de création de la fenêtre. Cela permet par exemple de
    * créer une fenêtre non redimentionnable, sans bouton quitter...etc...
    */
   myWindow( QMainWindow* parent = 0, Qt::WFlags fl = Qt::Window );
 
   /** @brief Destructeur de la classe
    */
   virtual ~myWindow();
   
  private:
   /** @brief Notre PushButton Hello
    */
   QPushButton* hello;
   
 };
 
 #endif // MYWINDOW_H
      

 /**
  * @file   myWindow.cpp
  * @author LAL ens <ens@lal.in2p3.fr>
  * @date   Mars 2007
  * 
  * @brief  first class HelloWorld in Qt
  * 
  * 
  */
 
 // Interface
 #include <myWindow.h>
 
 /** @brief Méthode de création de la classe myWindow 

  * Notre classe, pour être une fenêtre affichage, doit hériter de
  * la classe QMainWindow de Qt.
  * @param parent : Widget parent de la classe. Dans notre cas, ce sera
  * la fenêtre principale, donc le parent sera "NULL"
  * @param fl : Flags de création de la fenêtre. Cela permet par exemple de
  * créer une fenêtre non redimentionnable, sans bouton quitter...etc...
  */
  myWindow::myWindow( QMainWindow* parent, Qt::WFlags fl )
   : QMainWindow( parent, fl )
 {
   // Création de notre button poussoir
   hello = new QPushButton(...); Pour compléter cette ligne, référez vous à la documentation de Qt
   // La documentation des méthodes du QPushButton est disponible sur : QPushButton
 
   // Affichage de notre bouton en position centrale
   setCentralWidget( hello );
 }
 
 
 /**
  *  @brief Détruit l'objet myWindow et tous les objects contenus à l'intérieur.

  *  En particulier le bouton précédement créé.
  */
 myWindow::~myWindow()
 {
   delete hello;
 }
      

 /**
  * @file   QtTest.cpp
  * @author LAL ens <ens@lal.in2p3.fr>
  * @date   Mars 2007
  * 
  * @brief  first HelloWorld en Qt
  * 
  * 
  */
 #include <QtGui/QApplication>
 #include <QtGui/QPushButton>
 
 #include <myWindow.h>
 
 int main(int argc, char *argv[])
 {
  QApplication app(argc, argv);
  myWindow * mw = new myWindow();
  mw->show();
  return app.exec();
 }
      

 $> cmt config
 $> source setup.sh
      

 $> cmt make 
 $> cmt make doc
      

 $> open ../app/QtTest.app
      

 open /Applications/Utilities/Console.app
        

 $> rm -r ../Darwin ../doc ../app
 $> rm Darwin.make Makefile *.csh *.sh
 $> cd ../../
 $> svn add v1
 $> svn commit -m "Version de depart" v1
      

 $> cd ./v1/src
      

 // Connection du signal clic() du bouton vers la méthode close() de la QMainWindow
 connect( hello, SIGNAL(clicked()), this, SLOT(close()) );
      

 $> cmt make
 $> cmt make doc
 $> open ../app/QtTest.app
 $> cd ..
 $> svn commit -m "Action sur bouton" .
      

 #include <QMenu>
 #include <QMenuBar>
            

 /** @brief Méthode de création de la classe myWindow 

  * Notre classe, pour être une fenêtre affichage, doit hériter de
  * la classe QMainWindow de Qt. Cette MainWindow possède un menu simple
  * et une fenêtre contenant un simple bouton.
  * @param parent : Widget parent de la classe. Dans notre cas, ce sera
  * la fenêtre principale, donc le parent sera "NULL"
  * @param fl : Flags de création de la fenêtre. Cela permet par exemple de
  * créer une fenêtre non redimentionnable, sans bouton quitter...etc...
  */
  myWindow::myWindow( QMainWindow* parent, Qt::WFlags fl )
   : QMainWindow( parent, fl )
 {
   // Définition du bouton poussoir
   hello = new QPushButton( "Hello world!" );
   connect( hello, SIGNAL(clicked()), this, SLOT(close()) );
 
   // Affichage du bouton en position centrale
   setCentralWidget(hello);
 
   // Création du menuBar 
   QMenuBar*  menubar = new QMenuBar(this);
 
   // Création d'un menu déroulant "Fichier"
   QMenu * menuFichier = new QMenu( "Fichier" );
 
   // et ajout du menu fichier à la barre de menu principale
   menubar->addMenu(menuFichier);
 
   // Maintenant, on ajoute nos items
   // Ajout d'un item "Ouvrir"
   menuFichier->addAction( "Ouvrir" );
 
   // Ajout d'un séparateur
   menuFichier->addSeparator();
 
   // Ajout d'un item "Quitter" que l'on connecte au slot "close" de la mainWindows
   menuFichier->addAction( "Fermer l'application",this,SLOT(close()) );
 
   // Puis on affecte cette barre de menu à la fenêtre principale
   setMenuBar( menubar );
 }
      

  // Ajout d'un nouvel item "Changer" que l'on connecte à la fonction changer()
  menuFichier->addAction( "Changer",this, SLOT(changer()) );
      

 public slots :
 void changer();
      

 /** @brief Cette méthode change le texte du bouton hello.

  * La documentation des méthodes du QPushButton est disponible sur :
  * QPushButton

  * Le QPushButton est un type spécial de bouton. En effet, les boutons peuvent être
  * des PushButton, des CheckButton, des RadioButton...etc...Il hérite donc des
  * propriétés d'un type de bouton abstrait appellé QAbstractButton.
  * La documentation des méthodes du QAbstractButton est disponible sur :
  * QAbstractButton

  */
 void myWindow::changer()
 {
   hello->setText(...); // Compléter cette ligne en fonction de la documentation
 }