Moi aussi j'ai connu la programmation linéaire que l'on appelle aussi la programmation "spaghetti"...
Si j'ai bien compris, on parle de programmer avec des GOTO et autre GOSUB/RETURN.
Comme ça:
Code : Tout sélectionner
CLS
PRINT "in module-level code"
GOSUB Sub1
PRINT "this line in main routine should be skipped"
Label1:
PRINT "back in module-level code"
END
Sub1:
PRINT "in subroutine one"
GOSUB Sub2
PRINT "this line in subroutine one should be skipped"
Label2:
PRINT "back in subroutine one"
RETURN Label1
Sub2:
PRINT "in subroutine two"
RETURN Label2 'Cannot return from here to main
'program - only to SUB1.
Après la programmation linéaire, est apparue la programmation procédurale puis la programmation orientée objet (POO, oop en anglais). Quant à la programmation événementielle, elle est apparue avec les interfaces graphiques de type "windows".
PureBasic est procédural et événementiel.
Comme les programmes devinrent de plus en plus énormes, il devenait impossible de faire la maintenance d'un code de plusieurs millions de lignes alors la stratégie du morcellement d'un gros code en plusieurs petit (GOSUB) a été amélioré. Les procédures et les fonctions sont apparues et la programmation procédurales avec elles. Une fonction est une procédure qui renvoie une donnée. PB n'utilise que le mot-clé PROCEDURE à la fois pour les procédures et les fonctions.
Pour simplifier, la programmation procédurale consiste à remplacer les GOSUB par des appels à des procédures.
Les procédures sont donc des sous-programmes que l'on appelle par leur nom et nom pas par un numéro de ligne ou un label. Les premiers Basic procéduraux utilisaient le mot-clé SUB ou FUNCTION (pour fonction). PureBasic utilise lui, le mot-clé PROCEDURE.
Traduisons ce programme linéaire en procédure:
Code : Tout sélectionner
PRINT "code"
GOSUB Sub1
PRINT "fin"
END
Sub1:
PRINT "sous-programme"
RETURN
Pour info, il faut savoir que PB utilise toujours GOTO et GOSUB, la preuve:
Code : Tout sélectionner
Debug "code"
Gosub Sub1
debug "fin"
End
Sub1:
Debug "sous-programme"
Return
Ce programme compile et s'exécute sous PB.
Le mot-clé "Debug" permet d'afficher du texte dans la fenêtre du débogueur, c'est plus simple que d'ouvrir une console toute noire et déprimante...
De nos jour, il est déconseillé d'utiliser GOTO afin d'éviter la programmation spaghetti et quant aux GOSUB/RETURN, il faut s'en passer définitivement à cause de la mauvaise gestion de la pile (plantage quasi garanti).
Traduction avec une procédure:
Code : Tout sélectionner
;La procédure doit exister avant de l'appeler.
;Le point d'entrée du programme est plus bas et sans avoir à utiliser de GOTO pour passer la procedure Sub1(), le compilateur s'en charge.
;Ici la procedure n'est pas exécutée.
Procedure Sub1()
Debug "sous-programme"
EndProcedure ; Fin de la procédure.
;Programme principal = Point d'entrée.
Debug "code"
Sub1() ; Appel de la procédure (du sous-programme), ici la procédure est exécutée.
Debug "fin"
End
Pour comprendre la différence entre une procédure et un GOSUB, va dans l'aide de PB, rubrique "Procedure" et lis tout ce qui concerne les mots-clé "ProcedureReturn" et "Protected".(Une procédure a sa propre pile)
1. A ce que j'ai pu lire, PB se base sur l'évènementiel (tout se déroule dans une grande boucle).
Juste ?
Juste.
La programmation évènementielle permet à un programme d'utiliser la souris et le clavier alors qu'ils sont gérés par le système d'exploitation. La programmation événementielle permet le partage des ressources matériels (et d'autres choses...).
Un clic gauche provoque un événement, un double-clic, un autre événement, l'appui sur une touche du clavier encore un autre événement...
La grande différence avec la gestion des interruptions que l'on pratiquait jadis est qu'un évènement ne peut pas être interrompu par un autre évènement et que l'OS s'en mêle...
Tous ces évènements doivent être scrutés en permanence dans une boucle.
2. La stucture générale serait : includes (déclarations et autres), l'initialisation, le traitement (boucle), fin
Juste ?
Juste.
Include + Procédures
appel de procédures
Boucle (= évènement +/- appel de procédures)
Fin
Ou
Include
Déclaration des procédures (voir le mot-clé "Declare" dans l'aide)
appel de procédures
Boucle (= évènement +/- appel de procédures)
Fin
Procédures
Pour comprendre, ouvre des exemples dans le répertoire 'Example' de PB.
3. Comment procéder pour l'affichage ? Tout se déroule dans une même fenêtre (à l'époque on faisait un CLEAR de l'écran et on affichait le nouveau masque) ?
PB ne fonctionne pas sous DOS donc il faut ouvrir une fenêtre. Soit une fenêtre console ("toute noire") soit une fenêtre standard, de type Windows.
Pour ouvrir une fenêtre console:
Code : Tout sélectionner
OpenConsole() (voir l'aide de PB)
Print("Ce programme quittera dans 5 secondes...")
Delay(5000)
(Attention au format de l'exécutable Win32 ou console (voir l'aide de PB rubrique OpenConsole())
Je te déconseille de continuer à programmer des consoles car elles sont limitées surtout si l'utilisateur interagit avec l'écran. La gestion des masques va être longue et pénible. Autant sauter le pas, et utiliser tout ce temps sur la gestion des masques sur une fenêtre standard.
Code : Tout sélectionner
;Ouverture d'une fenêtre
OpenWindow(0, 100, 200, 360, 260, "PureBasic Window", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget)
;La boucle évènementielle
Repeat
Event = WaitWindowEvent()
If Event = #PB_Event_CloseWindow ; Si l'utilisateur clique sur le bouton fermer
Quit = 1
EndIf
Until Quit = 1
End
De nos jour, on n'efface plus une fenêtre pour changer l'affichage, on pose des gadgets dont on change l'affichage. Il faudra choisir parmi les gadgets celui qui conviendra le mieux à ton application (tes masques).
Code : Tout sélectionner
;Ouverture d'une fenêtre
OpenWindow(0, 100, 200, 360, 260, "PureBasic Window", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget)
;Un gadget qui affiche un texte
TextGadget(0, 10, 10, 350,20,"Gadget texte standard (texte aligné à gauche)")
;La boucle évènementielle
Repeat
Event = WaitWindowEvent()
If Event = #PB_Event_CloseWindow ; Si l'utilisateur clique sur le bouton fermer
Quit = 1
EndIf
Until Quit = 1
End
Code : Tout sélectionner
;Ouverture d'une fenêtre
OpenWindow(0, 100, 200, 360, 260, "PureBasic Window", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_MaximizeGadget)
;Un gadget qui affiche un texte
TextGadget(0, 10, 10, 350,20,"Gadget texte standard (texte aligné à gauche)")
;Un bouton
ButtonGadget(1, 10, 50, 200, 50, "Bouton standard")
;La boucle évènementielle
Repeat
Event = WaitWindowEvent()
If EventGadget() = 1 ; Si l'évènement concerne le bouton 1
If EventType() = #PB_EventType_LeftClick ; Si c'est un clic gauche
SetGadgetText(0, "Nouveau texte") ; Alors changer le texte du gadget 0 = le textegadget
EndIf
EndIf
If Event = #PB_Event_CloseWindow ; Si l'utilisateur clique sur le bouton fermer
Quit = 1
EndIf
Until Quit = 1
End
4. Comment gérer un menu déroulant qui peut changer en fonction du contexte où l'on se trouve (options 'grisées' ou 'masquées' selon où l'on se trouve) ?
Voir l'aide, Sommaire\Menu, tout y est expliqué avec 2 exemples
Option grisé,voir DisableMenuItem
Je passe très brièvement sur la programmation orientée objet POO car PureBasic ne l'utilise pas en natif. La POO est une programmation procédurale poussée à l'extrême avec l'apparition de nouvelles notions comme l'héritage, etc.
Pour fabriquer ta " petite application de gestion de membres, cotisations", il te faudra ouvrir un fenêtre (Aide/Window), commencer à maîtriser les gadgets (Aide/Gadget), les menus (AideMenu) et enregistrer des données dans un fichier (Aide/File). Il y a des exemples à chaque fois dans l'aide.
Puisque tu as déjà programmé, je pense qu'en 1 semaine, tu devrais pouvoir nous donner un code.
Quand tu seras plus à l'aise avec PB, tu pourras enregistrer les données dans une base de données (Aide/DataBase), avec SQL par exemple...
Si tu veux plus d'aide, il faut impérativement que tu post un code, même s'il ne fonctionne pas. Les membres du forum le corrigeront et plus encore, mais envoie quelque chose.
Mesa.
et tournaient sur un OS multi-utilisateur et multi-postes (achitecture ordinateur central et terminaux texte connectés en RS 232).
