PureBasic

Bonjour tout le monde,

Ancien programmeur (il y a plus de 10 ans!), j'aimerais m'y remettre à titre personnel et développer une petite application de gestion de membres, cotisations, etc.
En cherchant sur le net un language s'approchant du BASIC, je suis tombé sur PureBasic qui semble très intéressant (je ne veux pas d'usine à gaz du style Visual XXXXX)

Désolé pour la tartine qui suit mais je ne sais pas trop par où commencer avec PureBasic.
En expliquant le contexte j'espère que vous cernerez mieux les problèmes que je rencontre.
Malgré plusieurs heures de recherche (forums, tutoriaux, etc), je ne trouve pas les réponses à mes questions.

Je me lance.

A l'époque, je programmais toutes sortes de logiciels de gestion (comptabilité, stock, facturation, etc).
Le language utilisé était du B.A.L. (1 des nombreuses variantes du BASIC) de la société Prologue.

Il n'était pas question de programmation objet ou évènementiel.
C'était de la programmation linéraire de la plus classique.

Les données étaient stockées dans un système de fichiers séquentiels indéxés (gérés par le système).
Les applications étaient en mode texte (rendu DOS like

et tournaient sur un OS multi-utilisateur et multi-postes (achitecture ordinateur central et terminaux texte connectés en RS 232).

Les menus étaient présentés sous forme :

1. Gestion des adresses clients
2. Gestion des adresses fournisseurs
3. Facturation
4. ....
99. Paramètres

Chaque option appelait un sous-menu ou un masque de saisie en vue d'un traitement.

Les masques comportaient des Étiquettes (labels) et les champs de saisie correspondants :

Nom [ ]
Prénom [ ]
Date de naissance [ / / ]

La saisie des données pouvait être validée au niveau du champ (contrôle de la validité de la saisie du d'une date) et du masque (cohérence des données saisie sur l'ensemble du masque).
Le source était découpé en modules (1 par fonctionnalité) et liés à la compilation par un système d'includes.

Bref.
Un environnement de développement sans IDE, librairies ou je ne sais quoi.
On programmait de haut en bas tout soi-même y compris les "drivers" d'imprimante, des routines de saisie au claviers, etc

Vous voyez où je me situe ???

Aujourd'hui on parle de progammation objet, évènementielle, etc...
Je suis complètement dépassé.
J'ai bien essayé en vitesse du Visual Basic et Cie mais j'avoue ne pas aimer du tout la programmation Drag & Drop via une interface graphique.
J'ai toujours l'impression de faire un collage ou un patchwork de fonctions et objets avec 1000 paramètres.

Questions :

1. A ce que j'ai pu lire, PB se base sur l'évènementiel (tout se déroule dans une grande boucle).
Juste ?
2. La stucture générale serait : includes (déclarations et autres), l'initialisation, le traitement (boucle), fin
Juste ?
3. Comment procéder pour l'affichage ? Tous se déroule dans une même fenêtre (à l'époque on faisie un CLEAR de l'écran et on affichait le nouveau masque) ?
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) ?

Désolé pour ces questions qui peuvent paraitre "simplistes".
J'espère que vous pourrez me donner des pistes

Bonjour jump et bienvenue,

un programme en PB regroupe les éléments suivant :

- Une énumération comprenant la liste de fenêtre(s) et gadget(s)
- Des variables et des constantes
- Une boucle évènementielle permettant de gérer les précédents évènements sur fenetre et gadgets.

Exemple tout simple :

Code : Tout sélectionner


;{ Windows
Enumeration
  #Win
EndEnumeration

;{ Gadgets
Enumeration
  #Button_0
  #Button_1
EndEnumeration

; une variable qu'on initialise à 0 de type Byte (.b) => -128 à 128
cache.b = 0

; on ouvre notre fenêtre
OpenWindow(#Win, 450, 200, 150, 151, "Test", #PB_Window_SystemMenu|#PB_Window_SizeGadget|#PB_Window_MinimizeGadget|#PB_Window_TitleBar)

; On place deux boutons
      ButtonGadget(#Button_0, 10, 20, 125, 45, "Cacher le bouton")
      ButtonGadget(#Button_1, 10, 80, 125, 45, "Bouton 2")

  


;{- Boucle principale
Repeat
  Select WaitWindowEvent() ; on attend un évènement dans la fenêtre
    ; ///////////////////
    Case #PB_Event_Gadget ; On surveille un evenement sur les gadgets
      Select EventGadget() ; Choix de l'élément
        
        Case #Button_0 ; si c'est le bouton 0
        If cache = 0
          Message.s = "Afficher le bouton"
          cache + 1
        ElseIf cache = 1
          Message.s = "Cacher le bouton"
          cache -1
        EndIf
        
        SetGadgetText(#Button_0,message)
        HideGadget(#Button_1,cache) ; On cache ou affiche le bouton 1 selon la variable 'cache'
        
        Case #Button_1 ; si c'est le bouton 1
        MessageRequester("Test","Hello World",0)
        
        
      EndSelect
    ; ////////////////////////
      
    Case #PB_Event_CloseWindow ; Si on clique sur la croix
      Select EventWindow()
        Case #Win ; de la fenêtre #WIN
          CloseWindow(#Win) ; Alors on la ferme
          End
      EndSelect
  EndSelect
ForEver

Je te conseils de télécharger la version d'évaluation gratuite de PB et de potasser la notice.

Bienvenue Jump !

si tu as plus l'habitude de basic en mode console (sans fenêtre) il est possible de commencer facilement en purebasic.

La partie la plus difficile à intégrer est l'utilisation de fenêtre car le mode de gestion est lié aux OS modernes :

1) créer les ressources graphiques (idéalement, dans une procédure) : chaque ressource possède un numéro "unique".
2) afficher les ressource (appel de la procédure)
3) boucle de surveillance (Repeat ... Until avec appel de la surveillance des évènements par l'OS : event=waitwindowevent() ).
4) actions à faire en cas d'évènement

Tu peux commencer par l'exemple de l'aide : http://www.purebasic.com/documentation/ ... ow.pb.html
Tu trouveras également l'aide locale en appuyant sur F1 : des tonnes de lecture en perspectives

Enfin, tu as un editeur visuel intégré à Purebasic, qui peut te générer automatiquement une bonne partie du code (parties 1, 2 et 3 ci-dessus) : ALT+V dans l'IDE (éditeur)

Bon courage,
David

Purée ! Vous allez lui faire peur ! Bienvenue Jump !

Bon tu vas être content, Purebasic est très simple, et tu peux même faire tourner quelque chose de très ressemblant à ce que tu faisais dans le temps. Les print, input, locate fonctionnent ! Mais maintenant, on ne s'en sert plus beaucoup.

On a différencié l'affichage du traitement. Bref, maintenant on bosse souvent avec des fenêtres, et y'en a qui aimeraient bien qu'on gère ça comme des objets, mais nous les vieux on n'aime pas ça ! Alors PB va nous présenter ça à l'ancienne, en nous proposant même un petit éditeur et ça nous va très bien. Tu n'auras pas à recoder en dur la gestion des impressions, des menus, etc. C'est beaucoup plus simple qu'avant.

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.

Mesa> Juste un petit mot en passant : super !

Un grand merci à vous tous !

Je vais essayer tout ça

PureBasic

Je n'arrive même pas à débuter ;-) HELP !

Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !

Re: Je n'arrive même pas à débuter ;-) HELP !