[TUTO] Quelques tutoriaux pour bien débuter
[TUTO] Quelques tutoriaux pour bien débuter
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
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
Dernière modification par comtois le mar. 24/févr./2004 19:36, modifié 1 fois.
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 :
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.
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.
--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.
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 :
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.
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
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.
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 :
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.
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.
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.
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
pour aligner les touches de raccourci à droite mais
Exemple :
--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.
Il ne faut pas utiliser de
Code : Tout sélectionner
"Menu Ctrl+T"
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.
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.
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 :
--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.
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
--------------------
Le Soldat Inconnu [Régis]
Méfiez vous de l'eau qui dort, les ténèbres sommeillent sous sa surface.
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.
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.
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.