PyQt/Quelques explications
Ce premier exemple permet d'introduire quelques concepts de base.
Importation des librairies.
En premier lieu, il faut indiquer à Python d'importer les librairies PyQt et sys. Ceci est fait avec
les lignes suivantes :
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import sys
La méthode codice_1.
Nous définissons ensuite une méthode main qui s'occupera de gérer l'ensemble du programme.
Cette méthode crée en premier lieu une instance de codice_2. Cette instance représente
l'ensemble de notre application, par conséquent elle est essentielle et doit rester unique pour
assurer un fonctionnement correct.
Toute application PyQt est constituée d'un objet de type codice_2. Par conséquent, une
application débute toujours par la création d'un objet de la classe codice_2 :
app=QApplication(args)
Veuillez noter toutefois que si vous développez une classe dans laquelle la référence vers codice_2 n'est pas disponible (typiquement lors de la création de votre propre widget), Qt met
à disposition la variable codice_6 fournissant une référence vers l'application Qt. Vous pouvez donc
sans autre utiliser cette variable dans votre code.
Création d'un bouton.
Un bouton est un objet de la classe codice_7 créé comme tout autre objet par l'appel de son
constructeur :
button=QPushButton("Hello World !", None)
Les widgets ne sont pas visibles lors de leur création, c'est pourquoi la méthode codice_8 de la classe
codice_9 est appliquée à l'objet codice_10 afin de le rendre visible. Néanmoins, si vous déclarez un
widget comme enfant d'un autre, un appel à show sur le parent affichera automatiquement tous
ses enfants.
button.show()
Gestion des évènements.
L'exemple utilise deux événements : l'application quitte lorsque l'utilisateur clique sur le bouton
précédemment défini ou lorsqu'il ferme la fenêtre.
La méthode statique codice_11 de la classe codice_12 établit une communication unidirectionnelle
entre deux objets. À chaque objet de la classe codice_12 ou de ses classes dérivées, peuvent être
associés des signaux permettant d'envoyer des messages et des slots permettant de recevoir des
messages. De manière plus rigoureuse, un slot correspond à tout élément pouvant être appelé tandis qu'un signal est le message qui est passé entre objets.
Le fonctionnement est le suivant : les objets héritant de codice_12 émettent des signaux quand ils
reçoivent des événements. Ces signaux peuvent être connectés à des slots, qui sont donc appelés
automatiquement quand l'objet reçoit un événement donné. L'objet émetteur du signal ne se
soucie pas de l'existence d'un objet susceptible de recevoir son signal. Cela assure une bonne
encapsulation ainsi qu'un mécanisme modulaire.
Un même signal peut être connecté à plusieurs slots, tout comme plusieurs signaux peuvent viser
le même slot.
Dans le cas de notre exemple, deux signaux sont connectés au même slot :
app.connect(app,SIGNAL("lastWindowClosed()"),app,SLOT("quit()"))
app.connect(button, SIGNAL("clicked()"),app,SLOT("quit()"))
Les signaux « codice_15 » de l'objet app et « codice_16 » de l'objet codice_10 sont tous
deux connectés au slot « codice_18 » par l'appel à la méthode connect.
Lorsque les widgets sont définis, la méthode codice_19 de la classe codice_2 met en place
la boucle d'événements. C'est grâce à cette boucle (infinie) que l'application va fonctionner et
que les divers événements auront le comportement voulu.
app.exec_()

PyQt/Approche orientée objet
Dans cette version du très classique Hello World, une approche plus orientée objet est implémentée. La classe codice_1 encapsule les détails de l'utilisation d'une fenêtre de base. La classe codice_2 construit un bouton nommé Hello World !. Le fonctionnement est totalement identique à l'exemple précédent.
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import sys
class HelloButton(QPushButton) :
 def __init__ (self, args) :
 QPushButton.__init__ (self,None)
 self.setText("Hello World !")
class HelloApplication(QApplication) :
 def __init__ (self, args) :
 QApplication.__init__ (self,args)
 # Creation et affichage d'un objet HelloButton
 self.button=HelloButton(self)
 self.button.show()
 # Traitement des divers evenements
 self.connect(self,SIGNAL("lastWindowClosed()"),self,SLOT("quit()"))
 self.connect(self.button,SIGNAL("clicked()"),self,SLOT("quit()"))
 #boucle principale de traitement des evenements
 self.exec_()
if __name__ == "__main__" :
 app=HelloApplication(sys.argv)

PyQt/Signaux et slots
Les signaux et les slots sont utilisés pour la communication entre les objets. Le mécanisme de
signaux/slots est l’une des caractéristiques principales de Qt et PyQt qui les différencie des autres
outils de développement.
Dans Qt comme dans PyQt, un signal est émis par un widget lorsqu’un événement se produit.
Ces événements sont généralement le fait d’un utilisateur qui cliquerait par exemple sur un bouton
ou qui remplirait un champ. Les slots sont des fonctions appelées en réponse à un signal
particulier.
Ainsi en résumé, un objet héritant de codice_1 peut émettre des signaux quand il reçoit des événements comme un clic sur un bouton. Les signaux peuvent être connectés à des slots. Un
slot est une fonction membre (« méthode ») appelée automatiquement.
Pour plus d’informations, la page de référence fournit de plus amples détails : http://doc.trolltech.com/3.3/signalsandslots.html.

Photographie/Fabricants/Sverdlovsk
Sverdlovsk est un important fabricant russe, ex soviétique, de matériel optique et photographique, installé dans la ville du même nom.

PyQt/Positionnement des éléments graphiques

Qt et PyQt mettent à disposition plusieurs méthodes permettant de disposer les widgets et de
spécifier leurs tailles. Voici un petit aperçu de ces méthodes.
La meilleure façon de disposer les éléments graphiques consiste à les placer dans un widget de
type QHBox, QVBox et QGrid. Un widget déclaré enfant de l'une de ces classes sera automatiquement
disposé dans son widget parent. Ainsi le placement est entièrement géré par le parent.
Chacun des widgets énoncé plus haut possède sa spécificité dans le placement de ses widgets
enfants.
codice_1 dispose ses enfants horizontalement de la gauche vers la droite.
codice_2 aligne les widgets enfants sur une colonne verticale depuis le haut vers le bas.
codice_3 permet de mettre les enfants sur une grille à deux dimensions dont on peut spécifier le nombre de colonnes, les widgets étant disposés sur la ligne suivante lorsque la ligne précédente est pleine. L'alignement sur cette grille assure que les widgets ne se chevauchent pas lors d'un redimensionnement.
Cependant, vous remarquerez que placer ces objets de la sorte est très laborieux et demande de
multiples essais afin de voir ce qui est modifié lorsque l'utilisateur change la taille de la fenêtre.
C'est pourquoi nous vous recommandons plutôt d'utiliser Qt Designer, qui est un outil de développement d'interfaces Qt fourni avec la librairie. Cet outil vous permet de placer facilement
vos objets, de régler leurs paramètres, d'introduire des objets invisibles élastiques afin de garder une mise en page cohérente, et tout cela de manière graphique. Consultez la section "Utilisation de Qt Designer" pour plus d'informations concernant cet outil.