PureBasic

Régis , pendant que l'accès au musée est possible , j'en profite pour coller ici tes posts

tu pourras les mettre en tête , je ne sais plus comment ça s'appelle , mais bon , comme sur le musée quoi

et ensuite effacer ce post qui n'aura plus lieu d'être

Et merci pour ces tuts , je me rends compte en les recopiant que c'était un sacré boulot .

>> Le Soldat Inconnu : j'écrit ici pour éviter de mettre du bazar à la fin du tuto

Merci Comtois pour avoir recopier ici mes tus

J'en profite aussi pour signaler les points suivants :
- Si vous désirez d'autres exemples, merci de me faire parvenir vos idées par message privé
- De même si vous avez des remarques au sujet des codes de ces tuts
Le but étant de laisser des tus propres pour les personnes qui en ont besoin

Avant propos :
Ce que je dis est à titre d'exemple, à vous d'adapter en fonction de vos besoin.
Il ne s'agit que d'une méthode parmis tant d'autre, je la trouve simple et facile à comprendre pour un débutant, c'est tout.

Structure générale d'un programme
La structure d'un programme doit être basé sur la forme suivante :

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans une rubrique
; Window
#fenetre_principale = 0

; Gadget
#gadget_bouton_ok = 0

;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
; la aussi, il faut donner des noms explicites

Global Texte1.s, Nombre1.l, Texte2.s, Nombre2.l
;======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
     EndIf
EndProcedure

;=====================================
;- Debut du programme

; On initialise tous d'abord les valeurs
Nombre1 = 0
Nombre2 = 10

; On affiche la fenêtre
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte

Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

La partie "boucle de gestion des évènements" doit ête la plus courte possible pour arriver à se répérer facilement donc les opérations complexe doivent être traitées dans une procedure.
la légereté et l'aération du code est la base d'une programmation facile à comprendre.
J'ai eu un code d'une personne du forum dans les mains tous à l'heure et la première chose que j'ai dit, c'est "quel bazard la dedans" j'ai commencé par passé un oup de mise en forme (il s'agit d'un logiciel que j'ai développé et qui est disponible sur mon site) et mettre des "enter" après chaque éléments important, après, j'ai réellement pu étudier le code et trouvé l'erreur.

les fonctions goto au autre sont à proscrire, il s'agit de solution de faciliter qui ne font qu'alourdir le code et rende difficile sa compréhension.
il faut utiliser au maximum les procedures.
Lorsque l'on fait un programme court, pourquoi pas

, mais un programme devient vite long et si vous utiliser des goto partout, il vous sera alors très difficile de vous y retrouver et quasiment impossible si vous souhaiter apporter une nouveauté ou réaliser une correction dans votre code un mois après sa réalisation

[Avancé] dire que l'on met un gosub pour augmenter la rapidité d'un programme n'est pas utilie dans tous les cas. D'autant que PB est déjà très rapide en lui même.

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

voici un exemple de boucle de gestion des évènements qui donne un exemple des différents cas que l'on peut rencontrer.

Repeat
    Event = WaitWindowEvent ()
     If Event = #PB_EventMenu
         Select EventMenu () ; menu et barre d'outils
             Case

             Case
         EndSelect
     EndIf



     If Event = #PB_EventGadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case


             Case

         EndSelect
     EndIf


     If Event = #WM_RBUTTONDOWN ; clic droit avec la souris
     EndIf


     If Event = #PB_Event_SysTray ; évenement du systemtray ( ce qui est à coté de l'horloge)
         Select EventType ()
             Case #PB_EventType_LeftClick ; clic gauche sur l'icone

         EndSelect
     EndIf


Until Event = #PB_Event_CloseWindow

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

remarque importante au sujet des constantes :
il faut obligatoirement que pour chaque catégories de constantes, (pour les images, les fenetres, les gadgets, ...) chaque constantes est une valeur différentes

il est possible d'énuméré les constantes de la façon suivante pour éviter ce problème :

Enumeration
   #OuvrirXP
   #Ouvrir2XP
   #NouveauXP
   #SauverXP
   #Sauver2XP
   #ActualiserXP
   #AffichageXP
EndEnumeration

donc on obtient :
#OuvrirXP = 0
#Ouvrir2XP = 1
etc ...

Remarque importante au sujet de la boucle d'évènement
il ne faut pas mettre dans la boucle des actions qui seront exécutées automatiquement (ou qui ne sont pas déclenchées par un évènement) car ces fonctions vont être exécutés sans cesse (à chaque déplacement de la souris ou clic ou etc...) ce qui va rendre le programme lourd et cela va également utilsé énormément de ressource pour rien.

il en est de même pour le delay(...)
il est inutile de placer un delay dans une boucle d'évènement car la fonction waitwindowevent() attend la prochaine action de l'utilisateur.
donc si la souris ne bouge pas ou n'est pas au dessus de la fenêtre, la boucle s'arrête sur le waitwindowevent() et attend le prochain évènement.

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Voici un code de gestion des évènements :

il montre et explique l'importance et l'utilité de gérer les évènement complexe dans une procedure

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité

; on déclare chaque type de constantes dans une rubrique

; Window
#fenetre_principale = 0
; Gadget
#gadget_bouton_ok_1 = 0
#gadget_bouton_ok_2 = 1
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
;======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_ok_1 , 10, 10, 180, 20, "OK 1" )
             ButtonGadget ( #gadget_bouton_ok_2 , 10, 40, 180, 20, "OK 2" )
         EndIf
     EndIf
EndProcedure

Procedure Gestion_bouton_OK(Numero_bouton.l)

     MessageRequester ( "Info" , "Vous avez appuyé sur le bouton " + Str (Numero_bouton), 0 + 4 * 16)

     ; pour les paramètre d'un message requester, voir dans truc et astuces "messagerequesterplus()"

EndProcedure

;=====================================
;- Debut du programme

; On affiche la fenêtre les boutons

Ouvre_Fenetre_principale()

; On lance la boucle de gestion des évènements de la fenêtre ouverte

Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_ok_1
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_bouton_OK(1)
             Case #gadget_bouton_ok_2
                Gestion_bouton_OK(2)
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme

End ; Fin du programme

dans cet exemple, j'utilise la function MessageRequester(), reportez vous, pour les paramètres d'un message requester, à mon code source "messagerequesterplus()" que vous trouverez dans "trucs et astuces"

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Mettre un bouton ou un menu quitter

voilà un exemple avec un bouton quitter :

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans une rubrique
; Window
#fenetre_principale = 0
; Gadget
#gadget_bouton_ok = 0
#gadget_bouton_quitter = 1
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
;======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_ok , 10, 10, 180, 20, "OK" )
             ButtonGadget ( #gadget_bouton_quitter , 10, 40, 180, 20, "Quitter" )
         EndIf
     EndIf
EndProcedure

Procedure Gestion_bouton_OK(Numero_bouton.l)
     MessageRequester ( "Info" , "Vous avez appuyé sur le bouton " + Str (Numero_bouton), 0 + 4 * 16)
     ; pour les paramètre d'un message requester, voir mon code source "messagerequesterplus()"
EndProcedure

;=====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_ok
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_bouton_OK(1)
             Case #gadget_bouton_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

Cette solution n'est pas la seule, il existe plusieurs façon de faire. elle est simplement pas très compliqué et facile à mettre en place.

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Utiliser un menu et modifier un texte du menu
Modifier le texte d'un menu est utile par exemple pour faire une liste de fichiers récents.

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans un rubriques
; Window
#fenetre_principale = 0
; Gadgets
#gadget_bouton_changer_le_texte = 0
#gadget_bouton_quitter = 1
; noms des menus
#menu_fenetre_principale = 0
; elements du menu
#menu_fichier_changer_le_texte = 0
#menu_fichier_texte = 1
#Menu_fichier_quitter = 2
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
Global Texte.s
;======================================
;- declaration des procedures

Procedure Menu_fenetre_principale()
     If CreateMenu ( #menu_fenetre_principale , WindowID ( #fenetre_principale )) ; on crée le menu
         MenuTitle ( "Fichier" ) ; ajoute un titre dans le menu
         MenuItem ( #menu_fichier_changer_le_texte , "Changer le texte du menu" ) ; ajoute un élément dans le menu "Fichiers"
         MenuBar () ; met une barre de séparation dans le menu
         MenuItem ( #menu_fichier_texte , Texte)
         MenuBar ()
         MenuItem ( #Menu_fichier_quitter , "Quitter" )
     EndIf
EndProcedure

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_changer_le_texte , 10, 10, 180, 20, "Changer le texte du menu" )
             ButtonGadget ( #gadget_bouton_quitter , 10, 40, 180, 20, "Quitter" )
         EndIf
         ; On crée le menu
        Menu_fenetre_principale()
     EndIf
EndProcedure

Procedure Gestion_changer_le_texte() ; cette procedure met à jour un texte du menu
    Texte = "Nouveau texte"
     FreeMenu ( #menu_fenetre_principale ) ; on supprime le menu
    Menu_fenetre_principale() ; on affiche le menu avec le nouveau texte
EndProcedure

;=====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
Texte = "Texte d'origine"
; on initialise un texte du menu qui sera modifié par la suite
; d'ou l'utilité de la variable string qui va permettre de réafficher le menu avec un nouveau texte
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte

Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_changer_le_texte
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_changer_le_texte()
             Case #gadget_bouton_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
     If Event = #PB_Event_Menu
         Select EventGadget () ; Menu, barre d'outils, ...
             Case #menu_fichier_changer_le_texte
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_changer_le_texte()
             Case #Menu_fichier_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

Ici, le fait d'utiliser des procedures pour gérer les évènements prend toute son importance car il y a les même fonctions dans le menu et avec les boutons.

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Mise en place de touches de raccourci dans le menu

Il ne faut pas utiliser de

Code : Tout sélectionner

"Menu           Ctrl+T"

pour aligner les touches de raccourci à droite mais

Code : Tout sélectionner

"Menu" + chr(9) + "Ctrl+T"

Exemple :

; Mis en Version 4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans une rubrique
; Window
#fenetre_principale = 0
; Gadgets
#gadget_bouton_changer_le_texte = 0
#gadget_bouton_quitter = 1
; Noms des menus
#menu_fenetre_principale = 0
; Elements du menu
#menu_fichier_changer_le_texte = 0
#menu_fichier_texte = 1
#Menu_fichier_quitter = 2
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
Global Texte.s
;======================================
;- declaration des procedures

Procedure Menu_fenetre_principale()
     If CreateMenu ( #menu_fenetre_principale , WindowID ( #fenetre_principale )) ; on crée le menu
         MenuTitle ( "Fichier" ) ; ajoute un titre dans le menu
         MenuItem ( #menu_fichier_changer_le_texte , "Changer le texte du menu" + Chr (9) + "Ctrl+T" ) ; ajoute un élément dans le menu "Fichiers" avec le nom de la touche de raccourci
         ; le chr(9) correspond à une tabulation
         MenuBar () ; met une barre de séparation dans le menu
         MenuItem ( #menu_fichier_texte , Texte)
         MenuBar ()
         MenuItem ( #Menu_fichier_quitter , "Quitter" + Chr (9) + "Echap" )
     EndIf
EndProcedure

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_changer_le_texte , 10, 10, 180, 20, "Changer le texte du menu" )
             ButtonGadget ( #gadget_bouton_quitter , 10, 40, 180, 20, "Quitter" )
         EndIf
         ; on crée le menu
        Menu_fenetre_principale()
         ; on ajoute les touches de raccourci
         ; raccourci clavier "Ctrl + T"
         AddKeyboardShortcut ( #fenetre_principale , #PB_Shortcut_Control | #PB_Shortcut_T , #menu_fichier_changer_le_texte ) ; on associe à la touche de raccourci la constante du menu correspondant
         ; raccourci clavier "Echap"
         AddKeyboardShortcut ( #fenetre_principale , #PB_Shortcut_Escape , #Menu_fichier_quitter )
     EndIf
EndProcedure

Procedure Gestion_changer_le_texte() ; cette procedure met à jour un texte du menu
    Texte = "Nouveau texte"
     FreeMenu ( #menu_fenetre_principale ) ; on supprime le menu
    Menu_fenetre_principale() ; on affiche le menu avec le nouveau texte
EndProcedure

;=====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
Texte = "Texte d'origine"
; on initialise un texte du menu qui sera modifié par la suite
; d'ou l'utilité de la variable string qui va permettre de réafficher le menu avec un nouveau texte
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_changer_le_texte
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_changer_le_texte()
             Case #gadget_bouton_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
     If Event = #PB_Event_Menu
         Select EventGadget () ; Menu, barre d'outils, ...
             Case #menu_fichier_changer_le_texte
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_changer_le_texte()
             Case #Menu_fichier_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Créer une nouvelle fenêtre

L'architecture du code de la seconde fenêtre et de la gestion de ces évènements restent basé sur le même principe que précédemment.

;Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans une rubrique
; Windows
#fenetre_principale = 0
#fenetre_secondaire = 1
; Gadgets de la fenêtre principale
#gadget_bouton_ouvrir = 0
#gadget_bouton_quitter = 1
#gadget_bouton_ouvrir_masquer = 2
; Gadget de la fenêtre secondaire, attention, ne pas mettre les mêmes valeurs !!
#gadget_bouton_quitter2 = 3
; ======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
; ======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 300, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 3 boutons
             ButtonGadget ( #gadget_bouton_ouvrir , 10, 10, 280, 20, "Ouvrir une seconde fenêtre" )
             ButtonGadget ( #gadget_bouton_ouvrir_masquer , 10, 40, 280, 20, "Ouvrir une seconde fenêtre en masquant la première" )
             ButtonGadget ( #gadget_bouton_quitter , 10, 70, 280, 20, "Quitter" )
         EndIf
     EndIf
EndProcedure

Procedure Ouvre_Fenetre_secondaire()
     If OpenWindow ( #fenetre_secondaire , 0, 0, 200, 100, "fenêtre secondaire" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_secondaire ))
             ; on crée 1 boutons
             ButtonGadget ( #gadget_bouton_quitter2 , 10, 10, 180, 20, "Quitter la fenêtre secondaire" )
         EndIf
     EndIf
EndProcedure

Procedure Fenetre_secondaire()
     ; on affiche la fenêtre secondaire
    Ouvre_Fenetre_secondaire()
     Repeat
        Event = WaitWindowEvent ()
         If Event = #PB_Event_Gadget
             Select EventGadget () ; boutons, zone de texte, ...
                 Case #gadget_bouton_quitter2
                    Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
             EndSelect
         EndIf
     Until Event = #PB_Event_CloseWindow
     ; on ferme la fenêtre secondaire
     CloseWindow ( #fenetre_secondaire )
EndProcedure

; =====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_ouvrir
                 ; on ouvre la deuxième fenêtre, les gestion des évènement sera gérer dans une procedure
                 ; cette procedure doit respecter la même architecture que la boucle gérant les évènements de la fenêtre principale
                Fenetre_secondaire()
                 SetActiveWindow ( #fenetre_principale ) ; pour pouvoir utiliser la fenêtre principale car la fenête par défaut est la dernière crées donc la fenêtre #fenetre_secondaire

             Case #gadget_bouton_ouvrir_masquer
                 HideWindow ( #fenetre_principale , 1) ; on masque la première fenêtre
                Fenetre_secondaire()
                 HideWindow ( #fenetre_principale , 0) ; on affiche la fenêtre
                 SetActiveWindow ( #fenetre_principale )
             Case #gadget_bouton_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

Cet exemple montre comment ouvrir une nouvelle fenêtre sans masquer la première fenêtre ou en la masquant.

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Quitter un programme qlq soit la fenêtre

Voilà un exemple pour quitter le programme qlq soit la fenêtre sur laquelle on se trouve.
il s'agit d'un principe qui permet de quitter le programme toujours par le même endroit. ceci permet de faire par exmple un enregistrement de données avant la fin du programme par exemple.

le code :

; Mis en V 4.00 Dobro
; ======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans une rubrique
; Window
#fenetre_principale = 0
#fenetre_secondaire = 1
; Gadget de la fenêtre principale
#gadget_bouton_ouvrir = 0
#gadget_bouton_quitter = 1
#gadget_bouton_ouvrir_masquer = 2
; Gadget de la fenêtre secondaire, attention, ne pas mettre les mêmes valeurs !!
#gadget_bouton_quitter2_fenetre = 3
#gadget_bouton_quitter2_programme = 4
; ======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
Global Quitter.l
; ======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 300, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 3 boutons
             ButtonGadget ( #gadget_bouton_ouvrir , 10, 10, 280, 20, "Ouvrir une seconde fenêtre" )
             ButtonGadget ( #gadget_bouton_ouvrir_masquer , 10, 40, 280, 20, "Ouvrir une seconde fenêtre en masquant la première" )
             ButtonGadget ( #gadget_bouton_quitter , 10, 70, 280, 20, "Quitter" )
         EndIf
     EndIf
EndProcedure

Procedure Ouvre_Fenetre_secondaire()
     If OpenWindow ( #fenetre_secondaire , 0, 0, 200, 100, "fenêtre secondaire" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_secondaire ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_quitter2_fenetre , 10, 10, 180, 20, "Quitter la fenêtre secondaire" )
             ButtonGadget ( #gadget_bouton_quitter2_programme , 10, 40, 180, 20, "Quitter le programme" )
         EndIf
     EndIf
EndProcedure

Procedure Fenetre_secondaire()
     ; on affiche la fenêtre secondaire
    Ouvre_Fenetre_secondaire()
     Repeat
        Event = WaitWindowEvent ()
         If Event = #PB_Event_Gadget
             Select EventGadget () ; boutons, zone de texte, ...
                 Case #gadget_bouton_quitter2_fenetre
                    Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
                 Case #gadget_bouton_quitter2_programme
                    Quitter = 1 ; cette variable permet de quitter le programme, il s'agit d'une variable globale donc elle connu dans tout le programme
                     ; Je n'utilise pas de End afin de quitter le programme par la voie normale
                     ; Ainsi, par exemple, si il y a un enregistrement à faire avant de quitter ou une autre action, il suffit de la placer à la fin du programme
                     ; Si vous respecter ce principe, il suffit alors de placer à la fin du programme les enregistrements de donner ou autre nécessaire à votre programme
             EndSelect
         EndIf
     Until Event = #PB_Event_CloseWindow Or Quitter
     ; on ferme la fenêtre secondaire
     CloseWindow ( #fenetre_secondaire )
EndProcedure

; ====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
Quitter = 0 ; cette variable va permettre de quitter le programme à partir de la seconde fenêtre
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_ouvrir
                 ; on ouvre la deuxième fenêtre, les gestion des évènement sera gérer dans une procedure
                 ; cette procedure doit respecter la même architecture que la boucle gérant les évènements de la fenêtre principale
                Fenetre_secondaire()
                 SetActiveWindow ( #fenetre_principale ) ; pour pouvoir utiliser la fenêtre principale car la fenête par défaut est la dernière crées donc la fenêtre #fenetre_secondaire

             Case #gadget_bouton_ouvrir_masquer
                 HideWindow ( #fenetre_principale , 1) ; on masque la première fenêtre
                Fenetre_secondaire()
                 HideWindow ( #fenetre_principale , 0) ; on affiche la fenêtre
                 SetActiveWindow ( #fenetre_principale )
             Case #gadget_bouton_quitter
                Event = #PB_Event_CloseWindow ; on stocke dans event l'évènement quitter, ainsi l'appui sur le bouton quitter rvient à l'appui sur la croix
         EndSelect
     EndIf
Until Event = #PB_Event_CloseWindow Or Quitter ; si on appui sur la croix, on ferme le programme
; par la méthode proposée, ce message s'affichera dans tous les cas lorsque vous quitter le programme
MessageRequester ( "" , "Vous quittez le logiciel" , 0)
End ; Fin du programme

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Abordons maintenant un autre sujet :

Comment redimensionner une fenêtre

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans un rubriques
; Window
#fenetre_principale = 0
; Gadget
#gadget_bouton_ok_1 = 0
#gadget_bouton_ok_2 = 1
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
;======================================
;- declaration des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered | #PB_Window_SizeGadget )
         ; on ajoute l'option #PB_Window_SizeGadget à OpenWindow() pour permettre le redimensionnement de la fenêtre
         ; on créer la liste des éléments (gadget) de la fenètre
         If CreateGadgetList ( WindowID ( #fenetre_principale ))
             ; on crée 2 boutons
             ButtonGadget ( #gadget_bouton_ok_1 , 10, 10, 180, 20, "OK 1" )
             ButtonGadget ( #gadget_bouton_ok_2 , 10, 170, 180, 20, "OK 2" )
         EndIf
     EndIf
EndProcedure

Procedure Redimensionne()
     ; on récupère la taille de la fenêtre
    x = WindowWidth ( #fenetre_principale )
    Y = WindowHeight ( #fenetre_principale )
     ; On redimentionne les bouton en fonction de la taille de la fenêtre et on met #PB_Ignore pour indiqué les dimension qui ne change pas
     ResizeGadget ( #gadget_bouton_ok_1 , #PB_Ignore , #PB_Ignore , x - 20, #PB_Ignore )
     ResizeGadget ( #gadget_bouton_ok_2 , #PB_Ignore , Y - 30, x - 20, #PB_Ignore )
EndProcedure

Procedure Gestion_bouton_OK(Numero_bouton.l)
     MessageRequester ( "Info" , "Vous avez appuyé sur le bouton " + Str (Numero_bouton), 0 + 4 * 16)
     ; pour les paramètre d'un message requester, voir mon code source "messagerequesterplus()"
EndProcedure

;=====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
     If Event = #PB_Event_Gadget
         Select EventGadget () ; boutons, zone de texte, ...
             Case #gadget_bouton_ok_1
                 ; l'avantage de mettre une procedure est de pouvoir la réutiliser pour un autre évènement
                 ; par exmple : un bouton et un menu qui doivent réalisé la même chose
                Gestion_bouton_OK(1)
             Case #gadget_bouton_ok_2
                Gestion_bouton_OK(2)
         EndSelect
     EndIf
     If Event = #WM_SIZE ; si on redimmentione la fenêtre
        Redimensionne()
     EndIf
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

Une remarque de Dr. Dri ( Merci )

l'utilisation d'un declare permet de ne pas avoir à ce soucier de l'ordre des procedures
normalement, il faut placer le procedure appelée avant la procedure appelantes
avec les declare, l'ordre n'a plus d'importance
il devient possible par exemple de placer les procedures à la fin du programme suivant les gouts.

; Mis en V4.00 Dobro
;======================================
;- declaration des constantes
; il faut donner au maximum un nom a la constantes qui représente son utilité
; on déclare chaque type de constantes dans un rubriques
; Window
#fenetre_principale = 0
; Gadget
#gadget_bouton_ok = 0
;======================================
;- declaration des variables globales, des strutures, des listes ou tableau, ...
; la aussi, il faut donner des noms explicites
Global Texte1.s, Nombre1.l, Texte2.s, Nombre2.l
;======================================
;- declaration des procedures
; l'utilisation d'un declare permet de ne pas avoir à ce soucier de l'ordre des procedures
; normalement, il faut placer le procedure appelée avant la procedure appelantes
; avec les declare, l'ordre n'a plus d'importance
; il devient possible par exemple de placer les procedures à la fin du programme suivant les gouts
Declare Ouvre_Fenetre_principale()

;=====================================
;- Debut du programme
; On initialise tous d'abord les valeurs
Nombre1 = 0
Nombre2 = 10
; On affiche la fenêtre les boutons
Ouvre_Fenetre_principale()
; On lance la boucle de gestion des évènements de la fenêtre ouverte
Repeat
    Event = WaitWindowEvent ()
     ; Mettre ici la gestion des évènements
Until Event = #PB_Event_CloseWindow ; si on appui sur la croix, on ferme le programme
End ; Fin du programme
;======================================
;- definition des procedures

Procedure Ouvre_Fenetre_principale()
     If OpenWindow ( #fenetre_principale , 0, 0, 200, 200, "fenêtre principale" , #PB_Window_SystemMenu | #PB_Window_WindowCentered )
     EndIf
EndProcedure

Un autre truc utile est de se servir des ;- comme je l'ai fais pour ajouter des marqueurs. Cela permet de se promener rapidement dans le programme (Ils sont listés dans le procedure browser avec les procedures du programme, voir les options de l'éditeur de PureBasic)

--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.

suite des cours ici :

http://www.purebasic.fr/french/viewtopic.php?t=185

PureBasic

[TUTO] Quelques tutoriaux pour bien débuter

[TUTO] Quelques tutoriaux pour bien débuter