Programmer des interfaces graphiques avec le framework open source wxPython

Cette ligne est indispensable sous Linux pour indiquer à l'OS où se situe l'interpréteur Python, et pour permettre un lancement du script par double-clic.

Cette ligne permet de faire prendre en compte par l'interpréteur les accentués et le sigle € .

Ces deux premières lignes figurent toujours en début de mes scripts Python.

Depuis la version 2.4 de wxPython, l'espace de nom du module a changé, et se nomme tout simplement wx (l'ancien espace de nom - wxPython.wx - n'a été maintenu que pour assurer la compatibilité ascendante). Il suffit donc d'importer wx pour accéder aux wxWidgets. On pourrait également les importer sous la forme « from wx import * » afin d'éviter de systématiquement devoir préfixer chaque objet utilisé, mais je préfère personnellement utiliser le préfixe wx qui me permet de repérer immédiatement dans le code les références à wxPython.

On construit une classe Bonjour dérivée du wxWidget wx.Frame (ligne 06) dont une instance sera la fenêtre qu'on veut afficher à l'écran.

Pour connaître les paramètres attendus par une wx.Frame, il suffit d'aller sur le site wxpython.org à l'adresse http://www.wxpython.org/onlinedocs.php (sous MS Windows, l'intégralité de cette documentation est installée avec wxPython sur votre disque local) et choisir alphabetical class reference puis wxFrame.

Vous arrivez alors sur la documentation wxFrame où vous voyez que ce widget dérive de :

• wxTopLevelWindow
• wxWindow
• wxEvtHandler
• wxObject

Vous voyez aussi que sont listés un certain nombre de styles de fenêtre, et de processus d'événements par défaut.

Retenez dans un premier temps, que les styles de fenêtre sont des styles supplémentaires par rapport à ceux de la classe parente wxWindow, et que les processus d'événements sont également supplémentaires par rapport à la classe parente wxEvtHandler.

La rubrique intitulée Members liste les méthodes implémentées dans la classe.

Celle qui nous intéresse est le constructeur de la classe dénommé wxFrame::wxFrame tel que défini en C++.

Si vous cliquez sur ce lien, vous arrivez à la documentation de cette méthode:

wxFrame()

Default constructor.

wxFrame(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "frame")

Il s'agit d'une méthode décrite à destination des programmeurs en C++. Il vous faut donc la transposer en méthode Python pour pouvoir l'utiliser.

Cela donne ce qui suit :

wx.Frame(parent, id, title, pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.DEFAULT_FRAME_STYLE, name = 'frame')

Signification des paramètres :

parent

Il s'agit de la fenêtre qui doit accueillir la wx.Frame (le conteneur). None pour une wx.Frame en TopLevel

id

Un entier qui représente le Handle de la fenêtre. Indiquer la valeur -1 pour une attribution automatique par l'interpréteur.

title

Une chaîne de caractère qui sera affichée dans la barre de titre de la fenêtre.

pos

La position de la fenêtre (coordonnées supérieures gauche). La constante wx.DefaultPosition est prise par défaut, et correspond au tuple (-1, -1), qui est interprété par Python en fonction de l'OS.

size

La taille de la fenêtre (largeur, hauteur). La constante wx.DefaultSize est prise par défaut, et correspond au tuple (-1, -1) qui laisse le choix à l'interpréteur d'une taille adaptée à l'OS.

style

Le style de la fenêtre, à choisir parmi les styles spécifiques à wx.Frame ou ceux de wx.Window dont wx.Frame dérive. Le style wx.DEFAULT_FRAME_STYLE pris par défaut correspond à l'assemblage des constantes de style wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX | wx.RESIZE_BORDER | wx.SYSTEM_MENU | wx.CAPTION | wx.CLOSE_BOX | wx.CLIP_CHILDREN. A noter que pour indiquer un assemblage de styles, il faut séparer chacune des constantes choisies par le trait vertical (Alt Gr + 6).

name

Le nom de la fenêtre. Je n'utilise pour ma part jamais ce paramètre qui peut être éventuellement utile sous MAC OS.

C'est donc aux lignes 07 et 08 que nous indiquerons les paramètres souhaités.

à la ligne 07, dans la méthode __init__() (habituelle des classes Python) de la classe Bonjour, nous indiquons les paramètres attendus pour instancier la classe. Ce peut être des paramètres attendus par la classe parente (wx.Frame), ou des paramètres nouveaux, propres à la classe dérivée.

En l'occurrence, nous n'attendons que le paramètre «titre», qui correspond au paramètre «title» de wx.Frame. Les autres paramètres obligatoires ou que nous voulons alimenter par défaut pour wx.Frame seront indiqués à la ligne 08 dans la méthode d'initialisation __init__() de la classe parente.

Hormis le mot clé «self» que nous retrouvons systématiquement en tête des arguments de méthodes de classes en Python, et qui établit explicitement un rapport entre la méthode et son propriétaire, nous avons défini par défaut que l'instance de wx.Frame créée par l'intermédiaire de la classe Bonjour ne devait pas avoir de parent (None), que son id devait être créé automatiquement (-1), que le texte à afficher dans sa barre de titre devait provenir du paramètre «titre» attendu pour sa classe fille, et que sa taille devait être d'une largeur de 200 pixels et d'une hauteur de 100 pixels. Les autres paramètres de cette Frame étant ceux définis par défaut.

Ensuite, il nous reste à y placer le texte que nous voulons y voir affiché (Bonjour le monde !).

Pour ce faire, à la ligne 09, nous créons, dans un premier temps, un conteneur destiné à recevoir le texte, sur la base d'un panneau wx.Panel, à placer dans notre fenêtre.

Là encore, pour connaître les paramètres attendus par un wx.Panel, il suffit d'aller sur le site wxpython.org à l'adresse http://www.wxpython.org/onlinedocs.php à la rubrique wxPanel.

On voit là que le wx.Panel dérive de :

• wxWindow
• wxEvtHandler
• wxObject

La rubrique Members donne accès au constructeur wxPanel::wxPanel qui se présente comme suit:

wxPanel()

Default constructor.

wxPanel(wxWindow* parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL, const wxString& name = "panel")

Transposé en Python, ça donne ceci :

wx.Panel(parent, id, pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.TAB_TRAVERSAL, name = 'panel')

Signification des paramètres :

parent

Il s'agit de la fenêtre qui doit accueillir le wx.Panel (le conteneur)

id

Un entier qui représente le Handle du Panel. Indiquer la valeur -1 pour une attribution automatique par l'interpréteur.

pos

La position du Panel (coordonnées supérieures gauche). La constante wx.DefaultPosition est prise par défaut, et correspond au tuple (-1, -1), qui est interprété par Python en fonction de l'OS.

size

La taille du Panel (largeur, hauteur). La constante wx.DefaultSize est prise par défaut, et correspond au tuple (-1, -1) qui laisse le choix à l'interpréteur d'une taille adaptée à l'OS. style

Le style du Panel, à choisir parmi les styles de la classe parente wx.Window (aucun style spécifique n'a été défini pour un wx.Panel). La constante de style wx.TAB_TRAVERSAL prise par défaut signifie que la touche TAB pourra être utilisée pour passer de contrôles en contrôles (pour les contrôles posés sur le Panel).

name

Le nom de la fenêtre. Je n'utilise pour ma part jamais ce paramètre qui peut être éventuellement utile sous MAC OS.

Nous voyons donc que nous créons un wx.Panel dont l'identificateur est conteneur, le conteneur (parent) est le wx.Frame (référencé par le mot clé self), l'id est -1 (attribution automatique), et la taille (size) est calculée par la méthode GetClientSize() de la wx.Frame (mot clé self).

Si on se réfère à la documentation à la rubrique wxFrame, on ne trouve aucune méthode de ce nom. C'est là l'avantage de la programmation orienté objet ; une classe hérite des méthodes de ses classes parentes. La plupart des méthodes de base des wxWidgets sont héritées de la classe wxWindow. On va donc consulter la documentation à la rubrique wxWindow, et on découvre alors la méthode wxWindow::GetClientSize.

wxSize GetClientSize() const

This gets the size of the window 'client area' in pixels. The client area is the area which may be drawn on by the programmer, excluding title bar, border, scrollbars, etc.

En français :

Cette méthode retourne la taille de la zone 'client' de la fenêtre, en pixels. La zone client est la zone sur laquelle le programmeur peut dessiner, à l'exclusion de la barre de titre, des bordures, des ascenseurs, etc.

Parameters

width (largeur) : Receives the client width in pixels.

height (hauteur) : Receives the client height in pixels.

wxPython note: In place of a single overloaded method name, wxPython implements the following methods:

GetClientSizeTuple() Returns a 2-tuple of (width, height)

GetClientSize() Returns a wxSize object

En détaillant sa documentation, on voit qu'il y a une particularité wxPython à cette méthode. Elle a été implémentée de deux façons différentes:

GetClientSizeTuple() qui retourne un tuple composé de deux données, la largeur et la hauteur.

Cette méthode peut être très intéressante lorsqu'on a besoin de récupérer indépendamment l'une de l'autre les deux données. On peut alors le faire de la façon suivante :

largeur, hauteur = fenetre.GetClientSizeTuple()

GetClientSize() qui retourne les dimensions sous forme d'un objet wx.Size (il s'agit d'un objet englobant de façon monolithique les dimensions) pouvant être passé directement en paramètre size d'une fenêtre.

C'est donc cette dernière méthode que nous utilisons à la ligne 09, de façon à ce que notre wx.Panel prenne toute la place de la zone client de la wx.Frame.

On passe ensuite au message proprement dit qu'on veut afficher dans notre fenêtre. A la ligne 10, on crée un contrôle wx.StaticText, qui correspond à une simple étiquette sur laquelle on positionne le texte voulu.

On peut aller voir sa documentation en ligne, toujours au même endroit, et on peut changer de type de recherche en choisissant une recherche par catégories, puis les contrôles, et parmi ceux-ci on clique sur wxStaticText.

On voit que cet objet dérive de :

• wxControl
• wxWindow
• wxEvtHandler
• wxObject

Son constructeur en C++ est le suivant:

wxStaticText()

Default constructor.

wxStaticText(wxWindow* parent, wxWindowID id, const wxString& label, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxString& name = "staticText")

transposé en Python ça donne:

wx.StaticText(parent, id, label, pos = wx.DefaultPosition, size = wx.DefaultSize, style = 0, name = 'staticText')

Signification des paramètres :

parent

Il s'agit de la fenêtre qui doit accueillir le wx.StaticText (le conteneur). Comme nous plaçons ce contrôle sur notre wx.Panel, ce paramètre est passé sa référence, soit 'conteneur'.

id

Un entier qui représente le Handle du contrôle. Indiquer la valeur -1 pour une attribution automatique par l'interpréteur.

label

La chaîne de caractères que nous voulons voir affichée ('Bonjour le monde !'). pos

La position du contrôle (coordonnées supérieures gauche). La constante wx.DefaultPosition est prise par défaut, et correspond au tuple (-1, -1), qui est interprété par Python en fonction de l'OS.

size

La taille du contrôle (largeur, hauteur). La constante wx.DefaultSize est prise par défaut, et correspond au tuple (-1, -1) qui laisse le choix à l'interpréteur d'une taille adaptée à l'OS.

style

Le style de la fenêtre, à choisir parmi les styles spécifiques à wx.StaticText ou ceux de wx.Window dont wx.StaticText dérive. Les styles spécifiques du contrôle sont des styles de présentation du texte dans le contrôle : wx.ALIGN_RIGHT aligne le texte sur le bord droit du contrôle, wx.ALIGN_LEFT aligne le texte sur le bord gauche du contrôle, et wx.ALIGN_CENTRE place le texte au centre du contrôle (c'est ce dernier style que nous utilisons)...

Il existe un style supplémentaire, wx.ST_NO_AUTORESIZE, qui empêche le contrôle de changer de taille quand le texte est modifié à l'aide de la méthode SetLabel().

name

Je ne reviens pas sur ce paramètre.

Une fois notre contrôle texte créé, il nous reste à le centrer dans notre fenêtre. On fait ça à la ligne 11 à l'aide de la méthode CentreOnParent(), dérivée de la classe wxWindow et qui permet de centrer une fenêtre ou un contrôle dans son conteneur. Cette méthode prend un paramètre initialisé par défaut avec la constante wx.BOTH qui signifie un centrage à la fois vertical et horizontal. les deux autres valeurs acceptées sont wx.VERTICAL et wx.HORIZONTAL, qui n'ont pas besoin de précisions complémentaires.

C'est là la particularité de wxPython, celle qui nous oblige à pratiquement toujours développer en pur objet.

Pour pouvoir lancer un interface graphique wxPython, on doit obligatoirement passer par un objet chargé de créer l'instance de la classe principale de l'interface (le Top Level). Cet objet doit lui-même être construit et dériver de la classe wx.App ; c'est ce qu'on fait à la ligne 13.

La classe wx.App est initialisée différemment des classes Python classiques. Ce n'est pas la méthode __init__() qui doit être implémentée, mais une méthode OnInit() sans paramètre (sauf le mot clé self qui lui permet de s'auto-référencer) ; c'est ce qui est fait à la ligne 14. La séquence d'initialisation de la méthode OnInit() est alors toujours la même :

• Création d'une instance de la fenêtre principale (ligne 15)
• Affichage de la fenêtre par la méthode Show() dérivée de la classe wx.Window (ligne 16)
• Désignation de la fenêtre en tant que principale par la méthode SetTopWindow() spécifique à la classe wx.App (ligne 17)
• Retour de la valeur True marquant la fin de l'initialisation (ligne 18).

C'est là que démarre réellement notre application.

A la ligne 20, on crée une instance de l'application, qui elle-même crée une instance de notre fenêtre principale (classe Bonjour).

A la ligne 21 on démarre la boucle de gestion des évènements, qui permet au programme d'inter-agir avec son environnement.

Résumé On a vu dans ce chapitre:

• Comment créer une fenêtre en wxPython
• Comment positionner un contrôle dans une fenêtre
• Comment consulter la documentation en ligne
• Comment créer une application basée sur wxPython

C'est loin d'être suffisant, mais c'est un bon début...

Il s'agissait tout simplement de rendre publiques les références de notre wx.Panel et de notre wx.StaticText de façon à ce qu'elles soient accessibles depuis une autre méthode que la méthode __init__().

On le fait en les transformant en membres de la classe bonjour en les préfixant du mot clé self.

Attention, à partir de là, il faut toujours les préfixer de self lorsqu'on veut les utiliser, sinon python considérera que conteneur est une référence différente de self.conteneur.

C'est cette ligne qui nous permet d'intercepter l'évènement attendu, et de référencer la méthode qui en effectuera le traitement.

wx.EVT_SIZE() n'est pas une méthode, mais une macro-commande liée à la classe wxSizeEvent, elle-même dérivée de la classe wxEvent. Cette macro renvoie un objet wxEvent de classe wxSizeEvent dès que l'évènement se produit.

Si vous accédez à la documentation en ligne par le classement par catégories, vous trouvez, à la catégorie Events, une liste des classes dérivée de wxEvent, dont notre classe wxSizeEvent.

En cliquant sur le lien, vous accédez au détail de notre classe :

Comme pour les autres descriptions de classes, on y voit de quelles classes elle dérive :

• wxEvent
• wxObject

Mais on a une rubrique supplémentaire appelée Event table macros.

On trouve dans cette rubrique l'ensemble des macros disponibles pour la classe d'évènement considérée. En l'occurrence, pour la classe wxSizeEvent, la seule macro disponible est EVT_SIZE(funct) qu'on peut transposer en wxPython en wx.EVT_SIZE(objet, méthode).

Les paramètres attendus sont les suivants :

• Objet : Les évènements sont propagés depuis le contrôle jusqu'à sa classe parente. C'est donc le mot clé self qui sera toujours indiqué, puisque la classe dans laquelle est déclarée la macro est forcément parente du contrôle concerné.
• méthode : C'est la méthode de la classe englobant la macro, chargée de traiter l'évènement qui lui est automatiquement renvoyé par la macro dès que celui-ci se produit (dans notre exemple, c'est la méthode OnSize(), préfixée self, puisque c'est obligatoirement une méthode de classe qui doit être appelée).

Vous pouvez naviguer dans la documentation en ligne, parmi les classes de gestion d'évènements, il en existe pour tout ce qui peut interagir avec votre application, et elles possèdent toutes des macros vous permettant de les intercepter.

La plupart des macros qui interceptent les évènements liés à des actions de l'utilisateur (clic sur des boutons, sur des menus, appui sur des touches, etc. sont fournies par la classe wxCommandEvent. Les autres autres classes fournissent des macros relatives à des évènements plus spécifiques aux contrôles qu'ils concernent.

Le nombre de paramètres attendus par les macros dépend de la propagation de l'évènement, et de la spécificité de l'évènement attendu. Dans le cas de notre macro wx.SIZE_EVENT(), le seul paramètre attendu, hormis le mot clé self, est le nom de la méthode de classe chargée de le traiter. Il est inutile de lui passer l'Id du contrôle qui génère l'évènement puisque c'est la feuille elle-même qui est en cause. Par contre, un événement originaire d'un bouton ou du clic sur un menu, sera récupéré sous la forme wx.EVT_XXX(self, id, méthode), ou id est l'id du contrôle ayant généré l'évènement.

C'est la méthode de gestion de l'évènement renvoyé par la macro. Cette méthode doit avoir le même nom que la méthode passée en paramètre de la dite macro.

A la ligne 14, on définit la méthode avec attente d'un paramètre 'evt' (le mot clé self, n'est là que pour indiquer qu'il s'agit d'une méthode de la classe Bonjour).

Ce paramètre, fourni par la macro, est tout simplement l'objet de classe wxSizeEvent généré par notre dimensionnement de fenêtre.

Que faire de cet objet ?

Si on retourne à la documentation en ligne à la rubrique wxSizeEvent, on constate que cette classe possède, outre une macro-commande, des méthodes membres.

• Un constructeur dont vous n'avez pas à vous préoccuper(sauf si vous créez votre propre classe dérivée de wxSizeEvent, mais ça c'est une autre histoire), puisque l'objet est construit automatiquement.
• une méthode GetSize() qui renvoie la taille de la fenêtre après dimensionnement.

Dans notre exemple, nous voulons simplement adapter la taille de notre wx.Panel (self.conteneur) à notre fenêtre, et à maintenir notre wx.StaticText (self.etiquette) au centre.

Nos méthodes GetClientSize() et CentreOnParent() utilisées aux lignes 15 et 16 sont adaptées à ces tâches, c'est pourquoi nous n'avons pas utilisé la méthode fournie par l'évènement, mais il y a un tas d'informations qu'on peut récupérer pour traiter un événement.

Outre les méthodes propres au type d'évènement attendu, il suffit d'aller voir la documentation en ligne de la classe wxEvent dont dérivent toutes les classes d'évènements pour s'en convaincre.

Ces méthodes sont particulièrement simples à utiliser.

Voyons notre exemple auquel nous ajoutons une ligne (en rouge) dans la méthode OnSize() (à noter que j'ai augmenté les dimensions de la fenêtre à la ligne 08 de façon à ne pas tronquer le titre):

01 #!/usr/bin/python
02 # -*- coding: iso-8859-15 -*-
03
04 import wx
05
06 class Bonjour(wx.Frame):
07     def __init__(self, titre):
08         wx.Frame.__init__(self, None, 1, title = titre)
09         frameSizer = wx.BoxSizer(wx.VERTICAL)
10         panelSizer = wx.BoxSizer(wx.HORIZONTAL)
11         conteneur = wx.Panel(self, 1)
12         etiquette = wx.StaticText(conteneur, 1, "Bonjour tout le monde !", style = wx.ALIGN_CENTRE)
13         panelSizer.Add(etiquette, 1, wx.ALIGN_CENTRE)
14         conteneur.SetSizer(panelSizer)
15         frameSizer.Add(conteneur, 1, wx.EXPAND)
16         self.SetSizer(frameSizer)
17         frameSizer.SetSizeHints(self)
18         self.SetSize((200, 100))
19
20 class MonApp(wx.App):
21     def OnInit(self):
22         fen = Bonjour("Exemple 4")
23         fen.Show(True)
24         self.SetTopWindow(fen)
25         return True
26
27 app = MonApp()
28 app.MainLoop()

Voici ce que cela donne à l'exécution :

Effectivement, on ne décèle aucune différence avec la fenêtre affichée à l'exemple 1.

Maintenant, voyons ce qui se passe quand la fenêtre est dimensionnée :

Bien qu'on n'ait pas intercepté l'évènement wx.SizeEvent pour dimensionner les contrôles, le texte se centre automatiquement.

Examinons les lignes de code qui en sont responsables ...

V-A-1-a. Ligne 09▲

V-A-1-b. Ligne 10▲

V-A-1-c. Ligne 13▲

V-A-1-d. Ligne 14▲

V-A-1-e. Ligne 15▲

V-A-1-f. Ligne 16▲

V-A-1-g. Ligne 17▲

01 #!/usr/bin/python
02 # -*- coding: iso-8859-1 -*-
03
04 import wx
05
06 class Bonjour(wx.Frame):
07     def __init__(self, titre):
08         wx.Frame.__init__(self, None, 1, title = titre)
09         frameSizer = wx.BoxSizer(wx.VERTICAL)
10         panelSizer = wx.BoxSizer(wx.HORIZONTAL)
11         conteneur = wx.Panel(self, 1)
12         etiquette = wx.StaticText(conteneur, 1, "Bonjour tout le monde !", style = wx.ALIGN_CENTRE)
13         panelSizer.Add(etiquette, 1, wx.ALIGN_CENTRE)
14         conteneur.SetSizer(panelSizer)
15         frameSizer.Add(conteneur, 1, wx.EXPAND)
16         self.SetSizer(frameSizer)
17         frameSizer.SetSizeHints(self)
18         self.SetSize((300, 150))
19         wx.EVT_SIZE(self, self.OnSize)
20
21     def OnSize(self, evt):
22         self.SetTitle("Exemple 5 %s" % evt.GetSize())
23
24 class MonApp(wx.App):
25     def OnInit(self):
26         fen = Bonjour("Exemple 5")
27         fen.Show(True)
28         self.SetTopWindow(fen)
29         return True
30
31 app = MonApp()
32 app.MainLoop()

Comme pour l'exemple 3, on intercepte l'évènement wx.SizeEvent à l'aide de la macro wx.EVT_SIZE(), et on définit la méthode OnSize() pour traiter cet événement, en modifiant la barre de titre.

Et à l'exécution ça donne ...

Catastrophe... On a bien la taille dans la barre de titre, mais notre texte n'est plus centré du tout, et il est même tronqué...

Pas d'affolement, il s'agit d'un effet tout à fait normal de l'interception de l'évènement wxSizeEvent qui est utilisé en automatique par les sizers. Le fait qu'on l'ait intercepté, l'évènement a échappé au sizer, qui n'a pas pu recalculer les positionnements.

Ce problème est très facile à résoudre. Il suffit, une fois l'évènement intercepté et utilisé, de le libérer pour d'autres gestionnaires d'évènements.

On libère un évènement en lui appliquant la méthode de la classe wxEvent Skip(), qu'on exécute en dernière ligne de la méthode de traitement de l'évènement, ce qui donne pour notre méthode OnSize() :

def OnSize(self, evt):
    self.SetTitle("Exemple 6 %s" % evt.GetSize())
    evt.Skip()

En lançant notre programme rectifié, on obtient :

Et tout est rentré dans l'ordre.

#!/usr/bin/python
# -*- coding: iso-8859-1 -*-

import wx

class Bonjour(wx.Frame):
    def __init__(self, titre):
        wx.Frame.__init__(self, None, 1, title = titre)
        frameSizer = wx.BoxSizer(wx.VERTICAL)
        panelSizer = wx.GridSizer(2, 2, 0, 0)
        conteneur = wx.Panel(self, 1)
        for x in range(4):
            y = x + 1
            etiquette = wx.StaticText(conteneur, 1, "Bonjour le monde ! (%s)" % y ,
                                      style = wx.ALIGN_CENTRE)
            panelSizer.Add(etiquette, 0, wx.ALIGN_CENTRE)
        conteneur.SetSizer(panelSizer)
        frameSizer.Add(conteneur, 1, wx.EXPAND)
        self.SetSizer(frameSizer)
        frameSizer.SetSizeHints(self)
        self.SetSize((400, 150))
        wx.EVT_SIZE(self, self.OnSize)
        
    def OnSize(self, evt):
        self.SetTitle("Exemple 7 %s" % evt.GetSize())
        evt.Skip()
        
class MonApp(wx.App):
    def OnInit(self):
        fen = Bonjour("Exemple 7")
        fen.Show(True)
        self.SetTopWindow(fen)
        return True
        
app = MonApp()
app.MainLoop()

Ce qui nous donne ceci à l'exécution :

A la place du wx.BoxSizer lié au wx.Panel, on crée cette fois un wx.GridSizer de deux lignes et deux colonnes, sans espace entre cellules.

On lance ensuite une boucle qui crée quatre wx.StaticText de style centré, et les place au fur et à mesure dans le wx.GridSizer.

On voit à cette occasion, grâce à la numérotation des contrôles effectuée au fur et à mesure de leur création, que le placement se déroule ligne par ligne, et que le passage à la ligne s'effectue lorsque toutes les colonnes de la ligne ont été servies.

En utilisant un wx.GridBagSizer, on aurait pu remplir la grille dans n'importe quel ordre de cellules.

On crée un objet wx.Menu destiné à rassembler les éléments constitutifs du menu. Si on va voir la documentation en ligne à la rubrique wxMenu, on voit que son constructeur est le suivant :

wxMenu(const wxString& title = "", long style = 0)

soit transposé en wxPython :

wx.Menu(title = "", style = 0)

Dans notre code, nous avons créé l'objet sans paramètre, car le paramètre title a pour objet de mettre en première position du menu, un élément correspondant à la chaîne de caractères passée, ce qui ne présente pas d'intérêt, puisqu'on verra que c'est lors de l'ajout du menu dans la barre de menu, qu'on donnera le titre qui doit y apparaître.

Quant au paramètre style, il est présent pour permettre de créer un menu détachable (avec le style wx.MENU_TEAROFF), qui n'est possible qu'avec MOTIF.

On ajoute les éléments du menu à l'aide de la méthode Append() de wx.Menu.

Cette méthode, prototypée de trois manières différentes en C++, est implémentée en wxPython sous la forme de trois méthodes séparées :

Append(id, string, helpStr="", checkable=false)

C'est la méthode classique, celle que nous avons utilisée dans l'exemple.

Explication des paramètres.

• id : Contrairement à ce qu'on a vu jusqu'ici, l'id d'un élément de menu ne doit surtout pas être laissé au choix de l'application à l'aide de la valeur -1, mais déterminé explicitement, et de préférence à l'aide d'une constante. Dans le cas contraire, il deviendrait impossible d'intercepter les évènements de menus (que nous verrons plus loin dans ce chapitre). Un nombre non négligeable de constantes ont été définies avec des noms explicites. Vous en trouverez la liste en consultant la rubrique «Event handling overview» de la documentation en ligne, au chapitre «Window identifiers».
• string : C'est le texte qui apparaîtra dans le menu. le caractère & souligne le caractère qui le suit immédiatement et permet d'utiliser la touche ALT suivi du dit caractère pour accéder directement à l'élément de menu.
  
  On peut également définir des raccourcis clavier liés au éléments de menu. Ces raccourcis sont composés d'une combinaison des touches CTRL, ALT ou SHIFT avec un caractère quelconque, ou une touche de fonction (F1 à F12).
  
  Pour définir ce type de raccourci, il suffit de compléter le paramètre string de la représentation d'une tabulation (\t) du code de la touche (CTRL, ALT ou SHIFT) , du signe + et du caractère ou du code la touche de fonction.
• HelpStr : Ce paramètre facultatif permet d'associer une phrase d'aide à l'élément de menu. Cette phrase d'aide apparaît dans la barre d'état de la fenêtre (quand il en existe une), dès que le curseur de la souris passe sur l'élément.
• checkable : Ce paramètre de type boolean est initialisé par défaut à False. Si on lui passe la valeur True, l'élément de menu devient un élément à cocher.

AppendMenu(id, string, wx.Menu, helpStr="")

Cette méthode permet de lier un objet wx.Menu à l'élément de menu, de façon à créer un sousmenu accessible depuis cet élément.

AppendItem(wx.MenuItem)

Cette méthode permet d'ajouter un élément de menu défini séparément à l'aide de la classe wx.MenuItem.

On ajoute une ligne de séparation au menu à l'aide de la méthode sans paramètre AppendSeparator()

On crée un objet wx.MenuBar destiné à recevoir le wx.Menu créé précedemment.

Le seul paramètre du constructeur, est le style qui est alimenté par défaut à zéro. La seule constante de style acceptée est wx.MB_DOCKABLE qui permet d'en faire une barre de menu détachable, mais elle n'a d'effet que sous GTK+.

On ajoute notre menu à la barre de menu à l'aide de la méthode de la classe wx.MenuBar Append().

Cette méthode ne prend que deux paramètres, la référence de l'objet wx.Menu à ajouter, et le titre de ce menu sous forme d'une chaîne de caractères.

Il ne nous reste plus qu'à lier la barre de menu à notre fenêtre à l'aide de la méthode de la classe wx.Frame SetMenuBar() qui ne prend pour seul paramètre que la référence de l'objet wx.MenuBar.

A noter que si cette méthode est omise, la barre de menu ne sera pas affichée, bien que créée.

Mais pour qu'une barre de menus soit réellement utile, encore faut-il que lorsqu'on choisit un menu quelque chose se passe. C'est ce que nous allons voir au chapitre suivant...

01 #!/usr/bin/python
02 # -*- coding: iso-8859-1 -*-
03
04 import wx
05
06 class LesMenus(wx.Frame):
07     def __init__(self, titre):
08         wx.Frame.__init__(self, None, 1, title = titre, size = (400, 200))
09
10         menuFichier = wx.Menu(style = wx.MENU_TEAROFF)
11         menuFichier.Append(wx.ID_OPEN, "&Ouvrir\tCTRL+o", "menu ouvrir")
12         menuFichier.Append(wx.ID_CLOSE, "&Fermer\tCTRL+f", "menu fermer")
13         menuFichier.AppendSeparator()
14         menuFichier.Append(wx.ID_EXIT, "&Quitter\tCTRL+q", "menu quitter")
15
16         menuBarre = wx.MenuBar()
17         menuBarre.Append(menuFichier, "&Fichier")
18         self.SetMenuBar(menuBarre)
19
20         self.barre = wx.StatusBar(self, 1)
21         self.barre.SetFieldsCount(2)
22         self.barre.SetStatusWidths([1,1])
23         self.SetStatusBar(self.barre)
24
25         wx.EVT_MENU(self, wx.ID_EXIT, self.OnExit)
26         wx.EVT_MENU(self, wx.ID_OPEN, self.OnOpen)
27         wx.EVT_MENU(self, wx.ID_CLOSE, self.OnClose)
28
29     def OnOpen(self, evt):
30         self.barre.SetStatusText("Choix = Ouvrir", 1)
31
32     def OnClose(self, evt):
33         self.barre.SetStatusText("Choix = Fermer", 1)
34
35     def OnExit(self, evt):
36         self.Destroy()
37
38 class MonApp(wx.App):
39     def OnInit(self):
40         fen = LesMenus("Exemple 9")
41         fen.Show(True)
42         self.SetTopWindow(fen)
43         return True
44
45 app = MonApp()
46 app.MainLoop()

En exécutant ce code, on voit que la partie gauche de la barre d'état située au bas de la fenêtre fait apparaître un message à chaque fois que le curseur de la souris passe sur un élément du menu, et que la partie droite ne fait apparaître un message que quand on clique sur un élément.

Quand on clique sur Quitter, l'application s'arrête.

La capture d'écran qui suit montre l'état de la fenêtre après qu'on ait cliqué sur Ouvrir...

Voyons comment on s'y est pris:

VI-B-1-a. Lignes 11, 12 et 14▲

VI-B-1-b. Ligne 20▲

VI-B-1-c. Ligne 21▲

VI-B-1-d. Ligne 22▲

VI-B-1-e. Ligne 23▲

VI-B-1-f. Lignes 25 à 27▲

VI-B-1-g. Lignes 29 à 36▲

On définit des ID pour les menus zoom + et zoom - car il n'y a pas de constantes prédéfinies en wxPython pour ces actions.

Je travaille sur une version unicode de wxPython, alors que celle qui est installée sur mon Windows XP de test est une version non-unicode.

Si les menus et divers messages de mon application ne comportaient pas de caractères accentués, on ne verrait pas de différence. Mais pour que l'application tourne sans erreur dans les deux environnements, il faut traiter les chaînes de caractères comportant des accentués.

Aux lignes 9 et 10 je déclare les chaînes en tant que chaînes unicodes (avec le u minuscule en préfixe).

A la ligne 11, je teste si la version de wx.Python est une version unicode en récupérant la valeur booléenne de la constante wx.USE_UNICODE, et dans le cas contraire, aux lignes 12 et 13 je décode les chaînes unicode de façon à les mettre au format latin 2 (iso-8859-15).

On ajoute la barre d'outils entre la ligne 80 et la ligne 109.

VII-B-1-a. Ligne 80▲

VII-B-1-b. Lignes 82 à 107▲

VII-B-1-c. Ligne 108▲

VII-B-1-d. Ligne 109▲

Il est dessiné entre les lignes 111 et 114.

On crée d'abord une boite de placement de classe wx.sizer.

Ensuite on crée une instance de la classe Visu, qui est une classe définie dans notre programme, et qui dérive de la classe wx.ScrolledWindow. On détaillera plus loin la classe Visu et son utilité.

On place ensuite l'objet de type Visu dans la boite de placement à l'aide de la méthode Add() dérivée de la classe wx.Sizer, et enfin on relie Le sizer à la fenêtre à l'aide de la méthode SetSizer() dérivée de la classe wx.Window.

De la ligne 116 à la ligne 121, on crée les gestionnaires d'évènement des menus à l'aide de la macro wx.EVT_MENU.

Ces gestionnaires seront également utilisés par les boutons de la barre d'outils.

C'est une classe qui dérive de la classe wx.Window, et qui comprend une gestion automatique d'ascenseurs verticaux et horizontaux, dès lors que la taille de son contenu dépasse la taille de sa zone cliente.

Elle gère donc une zone virtuelle avec des coordonnées propres.

C'est l'objet idéal pour afficher des contenus qu'on veut pouvoir agrandir à souhait sans en altérer les proportions.

Le constructeur C++ de la classe wx.ScrolledWindow est le suivant :

wxScrolledWindow(wxWindow* parent, wxWindowID id = -1, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxHSCROLL | wxVSCROLL, const wxString& name = "scrolledWindow")

qu'on peut traduire en wxPython :

wx.ScrolledWindow(parent, id = -1, pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.HSCROLL | wx.VSCROLL, name = "scrolledWindow")

Le seul argument obligatoire est l'argument parent, c'est pourquoi c'est aussi le seul argument exigé par la classe Visu.

Le style par défaut (wx.HSCROLL | wx.VSROLL) affiche les ascenseurs dans les deux sens, ce qui nous convient.

Dans la méthode __init__(), on ne définit aucun contrôle. On crée deux membres de classe self.bmp et self.image dont on aura utilité dans les méthode de la classe.

Cette méthode est celle qui affiche l'image chargée par le programme principal.

Elle prend deux paramètres:

• bmp : c'est un objet wx.Bitmap qui contient l'image à afficher.
• ratio : c'est le ratio utilisé pour calculer la taille de l'image à afficher par rapport à l'image initialement chargée. En fait c'est la proportion de zoom de l'image.

VII-C-2-a. Lignes 25 à 31▲

VII-C-2-b. Lignes 32 à 37▲

Cette méthode est définie entre la ligne 151 et la ligne 174 et est appelé quand on clique sur le bouton «ouvrir»ou sur l'élément de menu correspondant.

ligne 152

On teste si la valeur du membre de la classe Principale, imgORIG est différente de None. C'est à dire qu'on s'assure qu'une image n'est pas déjà chargée.

Dans le cas contraire, on lance un message d'avertissement demandant à l'utilisateur de fermer cette image avant d'en charger une autre.

Pour cela, à la ligne 153, on utilise une boite de dialogue construite avec la classe wx.MessageDialog, qui dérive de la classe wx.Dialog dont le constructeur est définit en c++ de la façon suivante :

wxMessageDialog(wxWindow* parent, const wxString& message, const wxString& caption = "Message box", long style = wxOK | wxCANCEL, const wxPoint& pos = wxDefaultPosition)

Ce qui donne en wxPython :

wx.MessageDialog(parent, message, caption = "Message box", style = wx.OK | wx.CANCEL, pos = wx.DefaultPosition)

parent : La fenêtre parente (en général, celle qui appelle)

message : Le message qu'on veut afficher

caption : le titre de la boite de dialogue

style : une combinaison des constantes suivantes

pos : la position de la fenêtre sous la forme d'un objet wx.Point S'agissant d'un message d'avertissement, on va n'afficher que le bouton Ok.

A la ligne 156, on affiche notre boite de dialogue à l'aide de la méthode ShowModal() dérivée de la classe wx.Dialog, et qui permet d'interdire toute inter-action avec le programme principal tant que la boite de dialogue reste visible.

La fenêtre sur mon système a l'apparence suivante:

Une fois la boite de dialogue fermée (quand l'utilisateur à cliqué sur Ok), on la détruit avec la méthode destroy() (ligne 157), afin qu'elle n'encombre pas la mémoire.

Si aucune image n'est encore chargée dans l'application, on passe à la ligne 159 pour créer une boite de dialogue d'ouverture de fichier.

On utilise pour cela la classe wx.FileDialog qui, elle aussi, dérive de wx.Dialog.

Son constructeur, en C++ est le suivant :

wxFileDialog(wxWindow* parent, const wxString& message = "Choose a file", const wxString& defaultDir = "", const wxString& defaultFile = "", const wxString& wildcard = "*.*", long style = 0, const wxPoint& pos = wxDefaultPosition)

Ce qui donne en wxPython:

wx.FileDialog(parent, message = "Choose a file", defaultDir = "", defaultFile = "", wildcard = "*.*", style = 0, pos = wx.DefaultPosition)

Signification des paramètres

parent : La fenêtre parente

message : Message à afficher.

defaultDir : Le répertoire de recherche par défaut, ou une chaîne vide.

defaultFile : Le fichier à rechercher par défaut ou une chaîne vide.

wildcard: le prototype tel que "*.*" ou "BMP files (*.bmp)|*.bmp|GIF files (*.gif)|*.gif".

Notez qu'un seul prototype est possible à la fois, et qu'il n'est pas possible d'afficher plus d'un type de fichier à la fois, sauf si le prototype est «*.*»

style : Un style parmi les suivants :

pos : Non implémenté à ce jour

On choisit le style wx.OPEN puisqu'on veut charger un fichier. Le wildcard est positionné à *.* de façon à obtenir l'affichage de tous les types de fichiers simultanément.

A la ligne 162, on affiche la fenêtre à l'aide de la méthode ShowModal() déjà décrite plus haut, et on stocke la valeur de retour dans une variable. Cette valeur varie selon les boutons positionnés à l'aide des styles dans les boites de dialogue. et peut-être une des suivantes:

• wx.ID_OK
• wx.ID_CANCEL
• wx.ID_APPLY
• wx.ID_YES
• wx.ID_NO

Cela donne ceci sur mon système :

Tant que la boite de dialogue est affichée, le programme reste en attente.

Ensuite, à la ligne 163 on récupère le chemin complet du fichier choisi à l'aide de la méthode GetPath(), qui renvoie un chaîne vide en cas de non choix.

Et à la ligne 164, on récupère le nom du fichier choisi sans son chemin (pour pouvoir l'afficher plus facilement). Là encore, la méthode GetFilename() employée renvoie une chaîne vide en cas de non choix.

On détruit la boite de dialogue qui ne nous sert plus à rien à la ligne 165.

Ensuite, à la ligne 166 on teste si l'utilisateur a bien pressé le bouton Ok et si il a bien choisi un fichier.

Si les deux conditions sont remplies, on va charger le fichier image.

Cela se fait à la ligne à la ligne 167 où on stocke dans le membre de classe imgORIG (pour image d'origine) un objet de type wx.Image après y avoir chargé le fichier.

Pourquoi wx.Image et non pas wx.Bitmap comme on l'avait vu pour les images des boutons ? Tout simplement parce que l'objet wx.Image possède des méthodes de manipulation d'image que wx.Bitmap ne possède pas.

Si vous consultez la documentation en ligne, vous constaterez que le constructeur de wx.Image possède cinq prototypes différents et spécifiques à l'implémentation wxPython.

C'est le premier prototype qui nous convient, puisque le but du programme est d'afficher le contenu d'un fichier image.

Le paramètre flag donne le type de fichier à charger. Il peut prendre les valeurs suivantes :

Comme l'utilisateur peut choisir n'importe quel type d'image, on choisi le drapeau wx.BITMAP_TYPE_ANY de façon à ce que l'objet wx.Image s'auto-détermine.

Une fois l'image chargée, on récupère aux lignes 168 et 169 les dimensions de l'image à l'aide des méthodes GetWidth() et GetHeight() de la classe wx.Image .

L'image étant destinée à être affichée dans le wx.StaticBitmap() de la classe Visu, il est obligatoire d'en créer une copie sous la forme d'un objet wx.Bitmap. En effet, un objet wx.Image est un objet qui ne peut être affiché en l'état.

C'est ce qu'on fait à la ligne 170 à l'aide de la méthode ConvertToBitmap().

En ligne 171, le nouvel objet est alors passé en paramètre à la méthode Affiche() de l'instance de la classe Visu, ainsi que le ratio (initialisé à 100).

En ligne 172 on ajoute le nom du fichier image au titre de la fenêtre, et en ligne 173 la taille de l'image et le ratio d'affichage dans la zone 2 de la barre d'état.

Cette méthode est appelée lorsque l'utilisateur clique sur le bouton Zoom + de la barre d'outils ou le menu agrandir.

A la ligne 132, on s'assure qu'une image est bien chargée.

Ensuite, on modifie la valeur de ratio en lui ajoutant la valeur du membre de classe inc (5%) On calcule de nouvelles dimensions en appliquant le nouveau ratio aux dimensions originales de l'image.

En ligne 136, on crée un objet wx.Bitmap à partir de l'objet wx.Image original, retaillée à l'aide de la méthode Scale() aux nouvelles dimensions calculées.

En ligne 137, on appelle la méthode Affiche() de l'instance de la classe Visu, en lui passant ce nouveau Bitmap, accompagné de la nouvelle valeur de Ratio.

Le wx.StaticBitmap contenant l'image avant zoom est alors détruit, pour laisser la place à un nouveau wx.StaticBitmap contenant l'image redimensionnée.

On repart systématiquement de l'image originale pour appliquer le nouveau ratio, pour éviter la dégradation de la qualité de l'image affichée qui ne manquerait pas de se produire si on partait de l'image précédemment affichée.

En ligne 137, on met à jour la barre d'état.

Voici ce que donne notre python vert zoomé à 315%:

Elle est appelée lorsque l'utilisateur clique sur le bouton zoom- ou le menu diminuer.

C'est exactement le même mécanisme que celui mis en oeuvre dans la méthode Plus() avec décrémentation du ratio au lieu de l'incrémentation.

Simplement, on s'assure à la ligne 142 que le ratio ne descendra pas en dessous de zéro.

Ci-après Notre python vert ramené à 15% de ses dimensions originales.

Cette méthode est appelée quand l'utilisateur clique sur le bouton taille originale ou le menu correspondant.

Il s'agit tout simplement de remettre l'image originale en affichage et le ratio à 100%

Cette méthode est appelée quand l'utilisateur clique sur le bouton fermer ou le menu correspondant.

La méthode Efface() de l'instance de la classe Visu est appelée, qui détruit le wx.StaticBitmap et donc l'image contenue.

Tous les membres des deux classes sont remises en l'état initial, de façon à pouvoir charger sans inconvénient une nouvelle image.

Cette méthode est appelée lorsque l'utilisateur clique sur le bouton quitter, le menu correspondant ou clique sur la croix de fermeture de la fenêtre.

La fenêtre est alors détruite ainsi que toutes ses composantes, et la mémoire est libérée. Le toplevel de l'application wxPython étant détruit, l'application s'arrête.