• 10 hours
  • Easy

Free online content available in this course.

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 1/7/13

La gestion des évènements

Log in or subscribe for free to enjoy all this course has to offer!

Allez, on attaque un gros morceau maintenant, soyez en forme ! ;)

Introduction

Comme nous l'avons vu dans le chapitre précédent (création d'une GUI simple), la gestion d'une fenêtre GUI se fait par deux sous-ensembles distincts :

La construction de la GUI avec ses objets et son affichage
#include <ButtonConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>

$GUI = GUICreate("Ma GUI", 200, 200, 300, 200)
$Bouton1 = GUICtrlCreateButton("OK", 60, 130, 75, 25)
GUISetState(@SW_SHOW)
La gestion des événements liés à cette GUI ou aux objets qu'elle contient
While 1
        $nMsg = GUIGetMsg()
        Switch $nMsg
                Case $GUI_EVENT_CLOSE
                        Exit

                Case $Bouton1
                        MsgBox(64 + 8192, 'Message', 'Vous avez cliquez sur le bouton OK')
        EndSwitch
WEnd

Nous allons voir maintenant comment gérer deux fenêtres (et plus) dans un seul et même code.
Pour cela, plusieurs solutions sont envisageables, ayant chacune leurs avantages et inconvénients.

Nous allons étudier dans les chapitres qui vont suivre la création de deux fenêtres GUI :

  • La première comportera une boite à cocher (CheckBox) ainsi qu'un bouton pour afficher la GUI2.

  • La seconde comportera un bouton radio (RadioBox) ainsi qu'un bouton pour afficher la GUI1.

Nous allons aussi, par la même occasion, gérer les événements liés à la fermeture des fenêtres, la CheckBox ainsi que la RadioBox par un message indiquant le contrôle cliqué.

Pour finir ce tour d'horizon, nous allons aussi aborder le mode événementiel, qui est structuré différemment de ce que vous avez pu voir jusqu'à présent.
Ce mode assez méconnu apporte une autre manière de gérer son interface graphique, avec là encore des avantages et des inconvénients. :-°

Mini-TP : Gestion de 2 fenêtres

C'est l'heure de coder

Vous vous sentez à l'aise ? Vous êtes en train de vous dire "Tiens, je vais commencer ce chapitre tranquillement..." ?
C'est loupé, c'est l'heure pour vous de travailler, je trouve que j'en ai assez fait à votre place !
Le principe de ce mini-TP est très simple, c'est une simple application du chapitre précédent ; mais je n'avais alors géré qu'une seule interface, vous allez devoir en gérer deux !

Et comme si cela ne suffisait pas, vous allez devoir vous débrouiller seul.

Que dois-je faire?

Vous devez créer 2 GUIs :

  • La première comportera une boite à cocher (CheckBox) ainsi qu'un bouton pour afficher la GUI2.

  • La seconde comportera un bouton radio (RadioBox) ainsi qu'un bouton pour afficher la GUI1.

Vous devez également gérer les événements liés à la fermeture des fenêtres, la CheckBox ainsi que la RadioBox par un message indiquant le contrôle cliqué.
Et tout ceci en moins de 50 lignes... Au travail !

Indices et correction

Si vous lisez ceci, j'espère que c'est parce que vous avez terminé et que vous voulez voir si votre programme ressemble à ce que j'ai fait. Sinon vous pouvez revenir en arrière... :-°

Si vous avez du mal, la seule chose qui change de tout à l'heure, c'est le GuiSetState(). Allez voir dans l'aide, tout est expliqué. Si vous ne comprenez toujours pas, jetez donc un coup d'œil sur la correction.

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>

; ########## Début de la création de la GUI 1 ##########
$GUI1 = GUICreate("GUI1", 250, 150, -1, -1) ; Création de la GUI1
$Lb1 = GUICtrlCreateLabel("Fenêtre 1", 85, 10, 120, 24) ; Création du label1
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label1)
$Chb1 = GUICtrlCreateCheckbox("Checkbox1", 90, 60, 100, 20) ; Création d'une CheckBox
$Btn1 = GUICtrlCreateButton("Masque la GUI1 et Affiche la GUI2", 35, 110, 180, 25) ; Création d'un bouton simple
; ########## Fin de la création de la GUI 1 ##########

; ########## Début de la création de la GUI 2 ##########
$GUI2 = GUICreate("GUI2", 250, 150, -1, -1) ; Création de la GUI2
$Lbl2 = GUICtrlCreateLabel("Fenêtre 2", 85, 10, 120, 24) ; Création du label2
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label2)
$Rd1 = GUICtrlCreateRadio("Radio1", 100, 60, 100, 20) ; Création d'un bouton radio
$Btn2 = GUICtrlCreateButton("Masque GUI 1 et Affiche GUI 2", 35, 110, 180, 25) ; Création d'un bouton simple
; ########## Fin de la création de la GUI 2 ##########

GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI1 (la GUI2 reste masquée)

While 1 ; Début de la boucle infinie

    $nMsg = GUIGetMsg() ; Récupération des messages GUI
    Switch $nMsg ; Début du sélecteur de cas

        Case $GUI_EVENT_CLOSE ; Si clic fermeture fenêtre GUI1 ou GUI2 on sort
            MsgBox(64, 'Info', 'Vous avez choisi de fermer la fenêtre en cours') ; Message
            Exit ; Fin du script

        Case $Btn1 ; Si clic sur le bouton $Btn1
            GUISetState(@SW_HIDE, $GUI1) ; On masque la GUI 1
            GUISetState(@SW_SHOW, $GUI2) ; On affiche la GUI 2

        Case $Chb1 ; Si clic sur le contrôle $Chb1 (CheckBox)
            MsgBox(64, 'Info', 'Vous avez cliqué sur la CheckBox') ; Message

        Case $Btn2 ; Si clic sur le bouton $Btn2
            GUISetState(@SW_HIDE, $GUI2) ; On masque la GUI 2
            GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI 1

        Case $Rd1 ; Si clic sur le contrôle $Rd1 (RadioBox)
            MsgBox(64, 'Info', 'Vous avez cliqué sur la RadioBox') ; Message

    EndSwitch ; Fin du sélecteur de cas
WEnd ; Fin de la boucle infinie

Explications

Les 20 premières lignes de code permettent la création des différents éléments graphiques (fenêtres et contrôles).
L'identifiant de chaque objet graphique est stocké dans une variable au nom unique.

Juste après la création du label, on utilise une fonction qui permet de modifier la police et le style de certains contrôles. Ceci est facultatif.
Le nombre -1 est utilisé pour spécifier que nous souhaitons faire cette modification sur le contrôle qui a été créé juste avant cette commande.
Si vous utilisez cette commande à un autre endroit dans le script, vous devez utiliser la variable de l'identifiant de ce contrôle (dans l'exemple précédent, nous utiliserons $Chb1 pour la CheckBox1).

La ligne GUISetState(@SW_SHOW, $GUI1) nous permet de spécifier l'affichage de la GUI1 (la GUI2 et ses objets graphiques existe malgré tout mais elle est n'est pas visible).

Ensuite, nous attaquons la boucle de lecture des événements graphiques (While 1 / Wend). N'oubliez pas que cette boucle doit être permanente (infinie) sans quoi la GUI1 disparaitra dès que le reste du code aura été exécuté. Cette boucle permet donc d'exécuter le code qui se trouve à l'intérieur de celle-ci aussi longtemps que nous le souhaitons. Comme nous l'avons vu dans le chapitre sur les boucles, While 1 permet justement de créer une boucle infinie. ;)

La ligne $nMsg = GUIGetMsg() va nous permettre de 'capturer' les événements graphiques dans une variable. En effet, chaque action sur la GUI ou un de ses objets renvoie un code et c'est ce code que nous voulons analyser afin de lancer l'action qui correspond.

La ligne Switch $nMsg permet à AutoIt de 'commuter' ou 'sélectionner' l'un des cas possibles décrit dans les lignes qui suivent. Les cas sont tout simplement gérés par des commandes Case successives.
Ici, chaque Case doit correspondre à une valeur possible de la variable $nMsg (c'est-à-dire à l'identifiant d'un des contrôles de nos GUIs).

Regardons les 5 cas présents dans l'exemple ci-dessus :

  • Cas n°1 (Case $GUI_EVENT_CLOSE) - Ce cas, teste la variable $nMsg et la variable $GUI_EVENT_CLOSE (qui correspond à l'événement du clic sur la fermeture d'une fenêtre). Si les deux variables correspondent, alors le code qui se trouve en dessous jusqu'au prochain Case sera exécuté. En l'occurrence, c'est l'affichage d'une boite de dialogue puis la sortie du script.

  • Cas n°2 (Case $Btn1) - Ici, le cas correspond au clic sur le bouton de la GUI1. Cela permet d'utiliser deux fois la commande GUISetState() qui nous permet de masquer la GUI1 puis d'afficher la GUI2.

  • Cas n°3 (Case $Chb1) - Ici, le cas correspond au clic dans la case à cocher de la GUI1. Cela permet d'afficher une boite de dialogue indiquant l'action.

  • Cas n°4 ($Btn2) - Ici, le cas correspond au clic sur le bouton de la GUI2. Cela permet d'utiliser deux fois la commande GUISetState() qui nous permet de masquer la GUI2 puis d'afficher la GUI1.

  • Cas n°5 ($Rd1) - Ici, le cas correspond au clic dans le bouton radio de la GUI2. Cela permet d'afficher une boite de dialogue indiquant l'action.

Les deux dernières lignes du code, EndSwitch et WEnd permettent de 'fermer' respectivement les blocs Switch et While.

GuiGetMsg() en Mode Avancé

GuiGetMsg()

Depuis le début de ce cours, vous n'avez vu que l'utilisation de GuiGetMsg() en mode classique. Il existe également un mode avancé que je vais vous présenter succinctement. Vous n'êtes pas obligé de l'utiliser, mais il peut s'avérer utile pour certaines applications.

Par exemple, dans le mini-TP précédent, le GuiGetMsg() recevait des évènements mais vous ne saviez pas de quelle fenêtre provenaient ces évènements. Ceci ne posait alors pas de problème, mais imaginons maintenant que vous souhaitiez lancer la même fonction lorsque l'utilisateur clique sur le bouton radio ou la boîte à cocher, en changeant le titre du message : vous seriez alors content de savoir si l'utilisateur à cliquer sur telle ou telle fenêtre, et c'est le mode avancé de GuiGetMsg() qui va nous le permettre.

Pour utiliser ce mode, nous devons rajouter un commutateur spécifique à la commande GUIGetMsg().
Si vous ne spécifiez aucun commutateur, la commande est sous-entendue comme ceci GUIGetMsg(0) (paramètre par défaut) et la commande GUIGetMsg(1) vous permettra d'utiliser le mode étendu.

En mode normal, nous avons vu que la commande GUIGetMsg() renvoie tout simplement un EventID ou un ControlID dans la variable qui lui est associée ($nMsg = GUIGetMsg()).
En mode avancé, la commande GUIGetMsg(1) renvoie une variable tableau de 5 éléments :

  • $nMsg[0] = 0 ou l'EventID ou le ControlID ;

  • $nMsg[1] = Le handle de la fenêtre de l'événement ;

  • $nMsg[2] = Le handle du contrôle de l'événement (si applicable) ;

  • $nMsg[3] = La position X du curseur de la souris (relatif à la fenêtre GUI) ;

  • $nMsg[4] = La position Y du curseur de la souris (relatif à la fenêtre GUI).

Voici la liste des EventID (et leur équivalent numérique) qui sont à disposition dans AutoIt :

  • 0 = Pas d'événement.

  • $GUI_EVENT_CLOSE (-3) = La boite de dialogue a été fermée (par le menu système ou un bouton défini).

  • $GUI_EVENT_MINIMIZE (-4) = La boite de dialogue a été minimisée par le bouton de la barre de titre.

  • $GUI_EVENT_RESTORE (-5) = La boite de dialogue a été restaurée en cliquant sur son icône dans la barre des tâches.

  • $GUI_EVENT_MAXIMIZE (-6) = La boite de dialogue a été agrandie par le bouton de la barre de titre.

  • $GUI_EVENT_MOUSEMOVE (-11) = Le curseur de la souris a été bougé.

  • $GUI_EVENT_PRIMARYDOWN (-7) = Le bouton gauche de la souris a été enfoncé.

  • $GUI_EVENT_PRIMARYUP (-8) = Le bouton gauche de la souris a été relâché.

  • $GUI_EVENT_SECONDARYDOWN (-9) = Le bouton droit de la souris a été enfoncé.

  • $GUI_EVENT_SECONDARYUP (-10) = Le bouton droit de la souris a été relâché.

  • $GUI_EVENT_RESIZED (-12) = La boite de dialogue a été redimensionnée.

  • $GUI_EVENT_DROPPED (-13) = Signale la fin d'une action de Drag&Drop @GUI_DRAGID, @GUI_DRAGFILE et @GUI_DROPID seront utilisés pour retrouver l'ID/fichiers correspondant au contrôle concerné.

Un peu de code

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>

; ########## Début de la création de la GUI 1 ##########
$GUI1 = GUICreate("GUI1", 250, 150, -1, -1) ; Création de la GUI1
$Lb1 = GUICtrlCreateLabel("Fenêtre 1", 85, 10, 120, 24) ; Création du label1
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label1)
$Chb1 = GUICtrlCreateCheckbox("Checkbox1", 90, 60, 100, 20) ; Création d'une CheckBox
$Btn1 = GUICtrlCreateButton("Masque la GUI1 et Affiche la GUI2", 35, 110, 180, 25) ; Création d'un bouton simple
; ########## Fin de la création de la GUI 1 ##########

; ########## Début de la création de la GUI 2 ##########
$GUI2 = GUICreate("GUI2", 250, 150, -1, -1) ; Création de la GUI2
$Lbl2 = GUICtrlCreateLabel("Fenêtre 2", 85, 10, 120, 24) ; Création du label2
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label2)
$Rd1 = GUICtrlCreateRadio("Radio1", 100, 60, 100, 20) ; Création d'un bouton radio
$Btn2 = GUICtrlCreateButton("Masque GUI 1 et Affiche GUI 2", 35, 110, 180, 25) ; Création d'un bouton simple
; ########## Fin de la création de la GUI 2 ##########

GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI1 (la GUI2 reste masquée)

While 1 ; Début de la boucle infinie

    $nMsg = GUIGetMsg(1) ; Récupération des messages GUI avancés

        Switch $nMsg[0] ; Début du sélecteur de cas sur l'EventID ou sur le ControlID

                Case $GUI_EVENT_CLOSE ; Si clic fermeture fenêtre GUI1 ou GUI2
                        ; Si l'événement provient de la GUI1 :
                        If $nMsg[1] = $GUI1 Then MsgBox(64, 'Info', 'Vous avez choisi de fermer la fenêtre 1 ayant pour handle : ' & $nMsg[1]) ; Message
                        ; Si l'événement provient de la GUI2 :
                        If $nMsg[1] = $GUI2 Then MsgBox(64, 'Info', 'Vous avez choisi de fermer la fenêtre 2 ayant pour handle : ' & $nMsg[1]) ; Message
                        Exit ; Fin du script

                Case $Btn1 ; Si clic sur le bouton $Btn1
                        GUISetState(@SW_HIDE, $GUI1) ; On masque la GUI 1
                        GUISetState(@SW_SHOW, $GUI2) ; On affiche la GUI 2

                Case $Chb1 ; Si clic sur le contrôle $Chb1 (CheckBox)
                        MsgBox(64, 'Info', 'Vous avez cliqué sur la CheckBox aux coordonnées : ' & @CRLF & _
                        'X=' & $nMsg[3] & ' Y=' & $nMsg[4] & ' de la fenêtre') ; Message

                Case $Btn2 ; Si clic sur le bouton $Btn2
                        GUISetState(@SW_HIDE, $GUI2) ; On masque la GUI 2
                        GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI 1

                Case $Rd1 ; Si clic sur le contrôle $Rd1 (RadioBox)
                        MsgBox(64, 'Info', 'Vous avez cliqué sur la RadioBox aux coordonnées : ' & @CRLF & _
                        'X=' & $nMsg[3] & ' Y=' & $nMsg[4] & ' de la fenêtre') ; Message

    EndSwitch ; Fin du sélecteur de cas
WEnd ; Fin de la boucle infinie

Ce code est sensiblement le même que tout à l'heure. Vous arriverez facilement à le comprendre. Il faut simplement vous rappeler du cours sur les tableaux pour le comprendre, mais ceci devrait déjà être assimilé si vous lisez ce chapitre.

Le Mode événementiel

La programmation évènementielle

Que dit Wikipédia ?

Citation : Wikipedia

En informatique, une programmation événementielle se dit d'un type de programmation fondé sur les événements. Elle s'oppose à la Programmation séquentielle. Le programme sera principalement défini par ses réactions aux différents événements qui peuvent se produire.

La programmation événementielle peut être réalisée dans n'importe quel langage de programmation, bien que la tâche soit plus aisée dans les langages de haut niveau (comme Java). Certains environnements de développement intégré (par exemple Qt Software) permettent de générer automatiquement le code des tâches récurrentes dans la gestion des événements.

Vous l'aurez compris avec AutoIt, la programmation évènementielle c'est du gâteau !

Plus précisément, avec AutoIt

Dans ce mode, il vous faudra prévoir lors de la construction de votre interface graphique chaque événement de fenêtre ou de contrôle et le lier à une action. Cela permet un code plus structuré et une facilité de gestion des événements, mais cela implique parfois un code légèrement plus long. ;)

Malheureusement, par méconnaissance, ce mode n'est pas le plus utilisé, malgré une grande souplesse d'utilisation et une lecture et compréhension du code bien plus aisées. Mais je compte bien sur vous, amis zéros, pour le promouvoir et le porter dans votre cœur !

Il faut savoir que dans ce mode, votre interface graphique produira deux types d'événements :

  • Événement de Contrôle (Control Event)

  • Événement Système (System Event)

Chaque élément graphique ou fenêtre GUI se voit attribué une ou plusieurs fonctions liées aux types d'événements. Pour un contrôle graphique, l'action sera généralement le clic effectué sur celui-ci (Control Event). Pour une fenêtre GUI il s'agira d'un événement système (System Event) :

  • $GUI_EVENT_CLOSE

  • $GUI_EVENT_MINIMIZE

  • $GUI_EVENT_RESTORE

  • $GUI_EVENT_MAXIMIZE

  • $GUI_EVENT_PRIMARYDOWN

  • $GUI_EVENT_PRIMARYUP

  • $GUI_EVENT_SECONDARYDOWN

  • $GUI_EVENT_SECONDARYUP

  • $GUI_EVENT_MOUSEMOVE

  • $GUI_EVENT_RESIZED

  • $GUI_EVENT_DROPPED

Une fois l'événement capturé, le code est directement dirigé vers la fonction qui lui est attribuée. Dans cette fonction, vous pourrez utiliser trois variables principales, qui vous donneront des éléments complémentaires. Ces variables sont :

  • @GUI_CTRLID = Le ControlID du contrôle qui envoie le message, ou l'ID de l'événement système ;

  • @GUI_WINHANDLE = Le handle de la GUI qui envoie le message ;

  • @GUI_CTRLHANDLE = Le handle du contrôle qui envoie le message (si applicable).

Mais comme rien ne vaut du code clair et commenté pour comprendre, je laisse AutoIt parler de lui même.
Le Site du Zéro ne supportant pas (encore... ;) ) la coloration des codes AutoIt, et comme le code que je vous propose commence à être conséquent, je vous propose de le copier/coller dans Scite4Autoit pour que celui-ci soit plus simple à lire et comprendre.

Le code

#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
Opt("GUIOnEventMode", 1) ; Activation du mode événementiel

; ########## Début de la création de la GUI 1 ##########
$GUI1 = GUICreate("GUI1", 250, 150, -1, -1) ; Création de la GUI1
GUISetOnEvent($GUI_EVENT_CLOSE, "FermeGUI") ; Attribution de la fonction FermeGUI pour l'événement $GUI_EVENT_CLOSE
$Lb1 = GUICtrlCreateLabel("Fenêtre 1", 85, 10, 120, 24) ; Création du label1
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label1)
$Chb1 = GUICtrlCreateCheckbox("Checkbox1", 90, 60, 100, 20) ; Création d'une CheckBox
GUICtrlSetOnEvent($Chb1, "CheckBox1") ; Attribution de la fonction CheckBox1 pour un clic sur $Chb1
$Btn1 = GUICtrlCreateButton("Masque la GUI1 et Affiche la GUI2", 35, 110, 180, 25) ; Création d'un bouton simple
GUICtrlSetOnEvent($Btn1, "Bouton1") ; Attribution de la fonction Bouton1 pour un clic sur $Btn1
; ########## Fin de la création de la GUI 1 ##########

; ########## Début de la création de la GUI 2 ##########
$GUI2 = GUICreate("GUI2", 250, 150, -1, -1) ; Création de la GUI2
GUISetOnEvent($GUI_EVENT_CLOSE, "FermeGUI") ; Attribution de la fonction FermeGUI pour l'événement $GUI_EVENT_CLOSE
$Lbl2 = GUICtrlCreateLabel("Fenêtre 2", 85, 10, 120, 24) ; Création du label2
GUICtrlSetFont(-1, 12, 800, 0, "MS Sans Serif") ; Mise en gras du texte du contrôle précédent (Label2)
$Rd1 = GUICtrlCreateRadio("Radio1", 100, 60, 100, 20) ; Création d'un bouton radio
GUICtrlSetOnEvent($Rd1, "Radio1") ; Attribution de la fonction Radio1 pour un clic sur $Rd1
$Btn2 = GUICtrlCreateButton("Masque GUI 1 et Affiche GUI 2", 35, 110, 180, 25) ; Création d'un bouton simple
GUICtrlSetOnEvent($Btn2, "Bouton2") ; Attribution de la fonction Bouton2 pour un clic sur $Btn2
; ########## Fin de la création de la GUI 2 ##########

GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI1 (la GUI2 reste masquée)

While 1 ; Début de la boucle infinie
        Sleep(1000) ; Pause du script
WEnd ; Fin de la boucle infinie

Func FermeGUI() ; Début de la fonction
        If @GUI_WINHANDLE = $GUI1 Then ; Contrôle de la valeur de @GUI_WINHANDLE
                MsgBox(64, 'Info', 'Vous avez choisi de fermer la fenêtre 1 ayant pour handle : ' & @GUI_WINHANDLE) ; Message
        Else ; Sinon
                MsgBox(64, 'Info', 'Vous avez choisi de fermer la fenêtre 2 ayant pour handle : ' & @GUI_WINHANDLE) ; Message
        EndIf ; Fin de la condition If
        Exit ; Sortie du script
EndFunc ; Fin de la fonction

Func CheckBox1() ; Début de la fonction
        MsgBox(64, 'Info', 'Vous avez cliqué sur la CheckBox') ; Message
EndFunc ; Fin de la fonction

Func Bouton1() ; Début de la fonction
        GUISetState(@SW_HIDE, $GUI1) ; On masque la GUI 1
        GUISetState(@SW_SHOW, $GUI2) ; On affiche la GUI 2
EndFunc ; Fin de la fonction

Func Radio1() ; Début de la fonction
        MsgBox(64, 'Info', 'Vous avez cliqué sur la RadioBox') ; Message
EndFunc ; Fin de la fonction

Func Bouton2() ; Début de la fonction
        GUISetState(@SW_HIDE, $GUI2) ; On masque la GUI 2
        GUISetState(@SW_SHOW, $GUI1) ; On affiche la GUI 1
EndFunc ; Fin de la fonction

Explications

  • Opt("GUIOnEventMode", 1) va nous permettre de spécifier que nous souhaitons utiliser le mode événementiel.

  • GUISetOnEvent($GUI_EVENT_CLOSE, "FermeGUI") placé juste après la création de la GUI, nous permet d'associer un événement système (dans le cas présent, c'est la fermeture de la fenêtre) lié à cette fenêtre, avec une fonction qui permettra un traitement défini par l'utilisateur.

  • GUICtrlSetOnEvent($Chb1, "CheckBox1") nous permet d'associer un événement de contrôle (dans le cas présent, le clic dans la case à cocher) lié à cette fenêtre, avec une fonction qui permettra un traitement défini par l'utilisateur.

  • If @GUI_WINHANDLE = $GUI1 Then : Ici, nous utilisons une condition, pour savoir si la macro @GUI_WINHANDLE correspond au handle de la fenêtre GUI1.
    En fonction du résultat, on exécute la ligne qui suit (message fenêtre GUI1), sinon (Else) on exécute la ligne suivante (message fenêtre GUI2). Une fois la condition terminée (EndIf), on quitte le script (Exit).

Vous avez pu voir les méthodes principales de création et d'utilisation d'une interface graphique avec AutoIt.

Bien que la plupart d'entre vous utiliseront probablement la méthode classique, ne perdez pas de vue que la méthode événementielle peut vous apporter une plus grande souplesse de gestion des événements.

Example of certificate of achievement
Example of certificate of achievement