FutureBasic-Europe

CHAPITRE

APPRENDRE À PROGRAMMER AVEC FUTUREBASIC

NOTES

Branchements VI

La vectorisation

Leçon 15 : La programmation événementielle

La vectorisation
La programmation événementielle qui a été mise au goût du jour avec le Macintosh a introduit un autre concept dans le déroulement d'un programme. L'utilisateur final d'une application à la Macintosh était libre de déclencher à tout moment divers types d'opérations qui pouvaient éventuellement n'avoir aucune relation entre elles (cliquer sur un bouton, déplacer la souris, choisir un menu, redimensionner une fenêtre, enfoncer une touche du clavier, activer une autre application, etc.) Les choix de l'utilisateur n'étaient plus contraints par le flux du programme, mais c'était au contraire au programme à se plier aux choix de l'utilisateur.

On devine que de tels programmes sont plus difficiles à écrire, il faut apprendre à prévoir l'imprévisible. S'il est toujours possible avec FutureBASIC de réaliser des applications qui contraignent l'utilisateur à suivre un cheminement imposé par le programme, il est aussi certain que vous ne trouverez plus beaucoup d'utilisateurs satisfaits par votre travail. Il est donc nécessaire de se plier au mécanisme mis en place pour gérer cette "nouvelle" façon de faire.

A tout instant le système intercepte les événements qui surviennent sur votre machine, il les codifie et les place dans une file d'attente. Les programmes ont alors la charge d'extraire les événements qui les concernent. Les événements les plus anciens sont extraits les premiers, notez toutefois que la file d'attente n'est pas extensible et que si votre programme n'extrait pas les événements aussi vite que possible, les plus anciens peuvent être perdus à jamais. La méthode à adopter pour écrire des programmes dirigés par les événements est d'installer le flux du programme après son initialisation dans une boucle aussi rapide que possible pour extraire les événements à mesure qu'ils surviennent et bien sûr de réagir en conséquence. La plupart des programmes passent leur temps piégés dans cette boucle sans fin à ne pas faire grand-chose, mais à le faire vite.

Lorsqu'un événement survient, le programme doit le déchiffrer pour en déterminer la nature et d'autres informations qui pourraient être utiles pour ensuite diriger le flux du programme vers une routine qui exécute les traitements spécifiques à l'application en réponse à ce type d'événement.

Nous n'entrerons pas ici dans le détail du mécanisme, bien qu'il soit tout à fait possible de le programmer en utilisant les fonctions de la Toolbox, mais nous parlerons plutôt du système mis en place dans le Runtime de FutureBASIC qui nous simplifiera de manière considérable le travail.

La commande HANDLEEVENTS, qui doit être placée dans la boucle événementielle au niveau de la partie principale du programme, extrait les événements de la file d'attente. Non seulement les événements sont extraits mais ils sont recodifiés par le Runtime pour en simplifier l'analyse.

Pour que votre programme réagisse aux événements qui sont interceptés par le Runtime, il faut signaler à FutureBASIC la routine spécifique qui doit être invoquée lorsqu'un certain type d'événement est survenu. On appelle ce mécanisme la vectorisation, et il se met en place d'une manière simplissime. Les commandes du modèle ON typeEvenement FN routineSpecifique, sont prévues à cet effet et on les met en place juste avant que le programme n'entre dans la boucle principale. Les routines invoquées sont appelées souvent des gestionnaires (ou handlers en anglais). A priori rien ne les distingue des fonctions locales traditionnelles, si ce n'est que la documentation précise qu'elles ne peuvent pas prendre de paramètres, ne peuvent retourner de résultat et qu'elles sont automatiquement appelées par le Runtime au moment opportun.

Voici un programme qui réagit à la sélection d'un menu par l'utilisateur :

_menuFichier = 1
BEGIN ENUM
  _titreMenuFichier
  _articleBiper
  _articleQuitter
END ENUM

LOCAL FN gererMenu
  DIM AS INT monMenu,monArticle

  monMenu    = MENU(_menuID)
  monArticle = MENU(_itemID)
  SELECT monMenu
    CASE _menuFichier
      SELECT monArticle
        CASE _articleBiper : BEEP
        CASE _articleQuitter : END
      END SELECT
  END SELECT
  MENU
END FN

// Programme principal
MENU _menuFichier, _titreMenuFichier,_enable,"Fichier"
MENU _menuFichier, _articleBiper ,_enable,"Biper/B"
MENU _menuFichier, _articleQuitter ,_enable,"Quitter/Q"

ON MENU FN gererMenu

DO
  HANDLEEVENTS
UNTIL _nil

Le programme ci-dessus, montre combien il est simple de vectoriser un gestionnaire d'événement avec FutureBASIC. Le programme principal commence par installer un menu et ses articles, puis il déclare un gestionnaire pour les événements de type menu, et enfin il s'installe dans une boucle infinie. Grâce à la commande HANDLEEVENTS et au travail du Runtime, lorsque l'utilisateur choisira un article de menu ou bien utilisera un équivalent clavier, notre gestionnaire sera automatiquement appelé. Le gestionnaire a la charge de récupérer les informations concernant l'événement qui a déclenché son appel. FutureBASIC met ici la fonction MENU à notre disposition : MENU(0) retourne le numéro identifiant du menu et MENU(1) retourne le numéro identifiant de l'article choisi. Le programme utilise ici les constantes prédéfinies par FutureBASIC _menuID et _itemID comme paramètres à cette fonction. La dernière commande MENU de notre gestionnaire désélectionne le titre du menu choisi qui apparaît en vidéo inverse à l'écran.

Il y a un certain nombre de gestionnaires qui peuvent être mis en place, mais tous ne seront pas nécessairement utiles dans vos applications et vous pouvez omettre ceux dont vous n'avez pas besoin :

ON MENU	pour réagir à la sélection d'un menu.
ON DIALOG	pour gérer l'interaction de l'utilisateur avec les fenêtres et les boutons entre autres choses.
ON EDIT	pour traiter l'enfoncement des touches du clavier lorsqu'un un champ d'édition (une zone de saisie de texte) est actif.
ON MOUSE	pour gérer les actions avec la souris.
ON TIMER	pour les routines à exécuter de manière répétitive en fonction de l'horloge.
ON STOP	pour exécuter une routine juste avant que le programme ne prenne fin.
ON BREAK	pour gérer l'appui de l'utilisateur sur les touches Commande + point.
ON APPLEEVENTS	pour réagir aux AppleEvents (événements, dits de haut niveau, envoyés par d'autres applications).
ON EVENT	pour intercepter les événements bruts dans la file d'attente avant que le Runtime n'aie une chance de les traiter.
ON FINDERINFO	pour réagir à la demande d'ouverture ou d'impression de fichiers depuis le Finder.
ON LPRINT	pour appeler régulièrement une routine durant une impression.
ON OVERFLOWS	pour réagir aux dépassements de capacité lors d'opérations arithmétiques comme une division par 0.
ON ERROR	pour réagir aux erreurs d'entrée/sortie lors de la lecture ou l'écriture des fichiers sur le disque.

Le but n'étant pas de dupliquer les informations contenues dans les manuels de FutureBASIC, notre tour d'horizon s'achève ici. Nous avons vu quelles sont les entités que nous pouvions manipuler (constantes, variables) et ce qu'elles représentent, nous avons vu comment diriger le flux du programme avec les structures conditionnelles (WHILE/WEND, DO/UNTIL, FOR/NEXT, LONG IF/END IF) et les branchements (GOTO, GOSUB, FN, ON vecteur), nous avons vu les fonctions locales (LOCAL FN) et le potentiel qu'elles recèlent, vous êtes fin prêt à aborder les choses sérieuses.

Il n'est pas raisonnable de croire que l'on puisse assimiler toutes ces connaissances à la première lecture si l'on n'a jamais programmé auparavant, soyez assuré que la pratique vous apportera un savoir plus solide. Il y a encore beaucoup de choses à découvrir au sujet de FutureBASIC, mais aussi et surtout sur le fonctionnement du Macintosh et de sa Toolbox. La route est longue certes, mais FutureBASIC est le compagnon idéal pour vous y accompagner jusqu'au bout.

[Precédent] [Table des Matières] [Suivant]

{Note}



© 2000 Pix&Mix Tous droits réservés	INFO \| ACQUÉRIR \| PLAN \| RESSOURCES	Charte Vie Privée Infos Légales

FutureBASIC est une marque déposée appartenant à Staz Software, Inc et utilisée avec permission.