 |
Mercredi 24 avril 2024 - 05:01 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Chose promise, chose due : ce mois-ci, nous entrons de plain-pied dans la symbiose ARexx-Amiga. Je vous ai présenté dans les deux précédents épisodes (1, 2) une approche quelque peu didactique d'ARexx afin de vous donner les bases nécessaires pour le langage. Le temps est venu d'examiner un peu plus en profondeur comment ARexx permet de piloter tous les aspects spécifiques à l'Amiga. J'ai nommé : Intuition.
Un peu d'histoire
A l'origine, ARexx n'était pas destiné à pouvoir utiliser les ressources graphiques de l'Amiga. Devant le succès quasi immédiat que le langage a rencontré, des personnes se sont mobilisées pour étendre le langage afin d'élargir ses compétences. Ces travaux ont donné naissance à quelques extensions sous la forme de bibliothèques. L'une d'entre elles s'est rapidement imposée comme standard de fait : il s'agit de la rexxarplib.library.
Cette bibliothèque a été mise au point au Stanford Linear Accelerator Center par Willy Langeveld. Cc nom semblera familier aux utilisateurs de VLT, l'émulateur de terminaux bien connu, car Willy en est l'auteur et il s'est beaucoup appuyé sur sa rexxarplib pour en peaufiner l'interface ARexx. Le SLAC utilise intensivement l'Amiga en guise de terminaux alphanumériques (émulation VT) et graphiques (émulation Tektronix) et c'est ce qui a donné naissance à VLT.
Initialement créée pour permettre à ARexx d'accéder à la arp.library (d'où son nom), la rexxarplib a rapidement évolué par la force des choses vers une fonctionnalité bien plus axée sur Intuition, qui est le nom générique regroupant tous les objets graphiques spécifiques à l'Amiga (fenêtres, écrans, gadgets, menus).
Et pourtant, un tel tour de force relevait initialement de la gageure car le pilotage d'Intuition passe inévitablement par les couches basses d'Exec (création de ports, envois et réception de messages, etc.). Mais c'était compter sans l'ingéniosité de Willy Langeveld. Je vais m'efforcer de vous faire comprendre la philosophie de sa solution dans les lignes qui suivent mais les débutants pourront sans regret sauter cette description et se contenter de recopier le code d'initialisation sans le comprendre.
ARexx et Exec
Intuition utilise intensivement la structure des messages d'Exec pour communiquer avec les applications. Le principe est simple : une application ouvre une fenêtre et annonce à Exec quels sont les événements qui l'intéressent (clic de souris, sélection d'un menu, insertion d'un disque, etc.).
Ensuite, cette application se met à l'écoute de son message port. Quand un événement se passe dans la fenêtre, Intuition détermine si celui-ci intéresse l'application et si c'est le cas fait deux actions : il lui notifie avec un signal qu'un message arrive et envoie effectivement ce message vers son message port, après l'avoir rempli avec toutes les informations nécessaires (coordonnées de la souris, temps écoulé, etc.).
Quand un message arrive, l'application se réveille (car elle s'était endormie et n'occupait donc presque aucun temps processeur. C'est ce qu'on appelle de l'attente passive) et en fonction du message reçu, prend les décisions nécessaires.
Une telle façon de procéder est impossible en ARexx parce que les fonctions de manipulation de messages sont très primitives. L'astuce qu'utilise Willy Langeveld est en réalité très simple : il utilise une fonction de bibliothèque qui crée un "host" chargé de gérer tout cet aspect bas niveau. Quand un message arrive, ce host transforme le message Intuition en un message ARexx et le fait suivre tel quel à l'application. Celle-ci peut alors utiliser la classique fonction "getpkt" ARexx (de la rexxsupport.library) pour réceptionner et analyser le message (qui est donc devenu un paquet).
Un paquet ARexx comporte seize emplacement ("slots"). Le slot 0 contient l'identificateur de message et les quinze autres contiennent des arguments éventuels. On accède à ces différents slots par la fonction getarg. Pour plus de détails, consultez l'exemple plus bas.
Programmation de la rexxarplib.library
Avant de pouvoir utiliser la rexxarplib, un minimum de pas d'initialisation doivent être exécutés. A la lumière de ce qui précède, vous pourrez très facilement en comprendre la signification. La première étape est naturellement d'avoir dans votre répertoire "Libs:" le fichier "rexxarplib.library". Si vous ne la possédez pas, il vous faudra vous procurer le logiciel VLT sur la disquette Fish 468.
1. Ouverture des bibliothèques nécessaires :
|
lib = addlib('rexxarplib.library',0,-30,0) lib = addlib('rexxsupport.library',0.-30,0) |
2. Création de l'hôte qui s'occupe des basses besognes :
| address AREXX "'x=createhost(EventsPort,EventsNotiy)'" |
Notez au passage la syntaxe particulière d'utilisation de la fonction "createhost". Elle est due au fait que cette fonction ne rend pas la main et que si vous la lancez telle quelle dans votre programme, celui-ci va bloquer sur cette instruction. Il faut donc lancer cette commande en la détachant du processus courant. Une façon de faire est celle que j'ai employée (envoyer un message à l'hôte ARexx) mais il est également possible d'utiliser "runwsh" et "rx".
Le premier argument est le port principal. C'est lui qu'il faudra passer en argument lors de la création des divers objets graphiques. Le deuxième est le port IDCMP sur lequel nous allons attendre nos paquets et agir en conséquence.
3. Ouvrir le port IDCMP :
| call openport(EventsNotiy) |
4. Créer les objets graphiques désirés.
5. Scruter notre port de notification et agir en conséquence.
L'exemple
Afin d'illustrer tout ce qui a été dit, je vous livre un exemple d'application rapide qui ouvre une fenêtre et attend que l'utilisateur la ferme en cliquant sur le gadget de fermeture ou appuie sur une touche. Dans un prochain article, je passerai en revue les diverses fonctions mises à notre disposition pour plier Intuition à tous nos désirs...
Bien qu'ARexx n'ait pas été prévu initialement pour gérer les couches système de l'Amiga (Exec), Willy Langeveld (l'auteur de la rexxarplib) a trouvé un moyen ingénieux de pallier cette lacune en créant une espèce d'interprète entre le monde ARexx et le monde Exec. Il s'agit tout simplement de la fonction createHost() qui crée un processus dont l'unique rôle est de surveiller le port donné en argument et de convertir les messages qui y arrivent (format Exec) en paquets (format ARexx). Du côté ARexx, la scrutation se fait par la classique fonction getPkt().
Bizarrement, le système de scrutation par paquets d'ARexx est plus souple et plus facile à relire que les routines Exec habituelles. La principale force d'ARexx dans ce domaine réside une fois de plus dans le fait que c'est un langage symbolique, c'est-à-dire qu'il fonctionne sur la base de chaînes. Vous pouvez donc vous-même décider du contenu des paquets que vous allez recevoir.
Les paquets en ARexx
Un premier exemple simple de cet envoi par paquet peut être illustré par l'utilisation de gadgets. Une fois que vous avez ouvert une fenêtre, vous pouvez ajouter des gadgets dans celle-ci grâce à la fonction addGadget(). Par exemple :
| call addGadget(EventsPort, x, y, 1," Sauver Fichier ","SAUVER") |
Deux gadgets peuvent être créés de cette façon : des gadgets de chaîne (dans lesquels l'utilisateur est supposé entrer un texte) et des gadgets booléens. L'appel ci-dessus crée un gadget booléen. Si vous ajoutez la taille horizontale après le dernier argument, c'est un gadget de chaîne qui sera créé. Si cet argument n'est pas présent, comme c'est le cas ici, la bibliothèque créera un gadget booléen et calculera automatiquement sa taille.
Le premier argument est le port que vous avez créé. x et y sont naturellement les coordonnées de ce gadget par rapport à la fenêtre. Vient ensuite le numéro d'identité du gadget, suivi par le texte que vous désirez y placer (notez le caractère " qui permet de passer à la ligne). Le dernier argument est le plus intéressant.
Il s'agit en effet de la chaîne que vous souhaitez recevoir quand un message concernant ce gadget arrivera sur votre port. Je vous rappelle qu'un paquet ARexx est composé de seize emplacements (slots). En l'occurrence, la chaîne ainsi définie vous arrivera dans le slot zéro. La boucle de scrutation pourra donc ressembler à ce qui suit :
Définition du paquet
C'est ce moyen qui vous permet de recevoir sur votre port des événements IDCMP. IDCMP (Intuition Direct Communication Message Port) est le nom donné à tous les messages envoyés par Intuition. On trouve par exemple RAWKEY (une touche), GADGETDOWN (l'utilisateur a appuyé sur un gadget), CLOSEWINDOW (gadget de fermeture), etc.
Quand un tel événement arrive, rexxarplib met dans le slot zéro la chaîne correspondante telle quelle, mais ce comportement est insuffisant dans certains cas. Par exemple, si nous désirons être informés chaque fois que la souris est déplacée et où celle-ci se trouve, nous recevrons un paquet qui ne contiendra que la chaîne MOUSEMOVE dans le slot zéro mais aucun renseignement sur les nouvelles coordonnées de celle-ci. Autre exemple : dans le cas d'une touche, tout ce que nous recevrons sera RAWKEY et rien de plus.
Fort heureusement, nous pouvons définir la façon dont le paquet sera constitué grâce à la fonction modifyHost(). Celle-ci a la syntaxe suivante :
| modifyHost(port, classe IDCMP, chaîne) |
C'est dans la chaîne que vous définissez le contenu du paquet. Voici quelques codes :
- %n : définit le contenu du slot "n" (0..15).
- %l : le nom de la classe.
- %c : le code (utilisé pour RAWKEY).
- %x,%y : coordonnées.
- %d : identité du gadget.
- %m %i %s : numéro du menu, de l'item et du sous-item.
| modifyHost(monPort,'RAWKEY','%l%1%c') |
(attention, il s'agit du caractère % suivi de la lettre L en minuscule, puis de % suivi du chiffre un et enfin % suivi de la lettre C afin de définir le contenu du slot 1).
Pour avoir les coordonnées de la souris dans les slots un et deux :
| modifyHost(monPort,'MOUSEMOVE','%l%1%x%2%y') |
Pour obtenir le numéro du gadget (pas forcément utile lecture de la chaîne suffit dans bien des cas) :
| modifyHost(monPort,'GADGETDOWN','%l%1%d') |
Analyse du paquet
Dans la boucle de scrutation, on récupère les différents contenus des slots par la fonction getArg() :
| p = getArg(pkt,2) /* lecture du slot 2 */ |
Création du menu
Impossible de parler d'Intuition sans évoquer les menus. Là encore, ARexx bénéficie d'une implémentation qui simplifie énormément la création de menus par rapport à celle utilisée quand on les programme en C ou en assembleur. Les fonctions liées aux créations de menus sont addMenu(), addItem(), addSubItem() et setItem().
Les trois fonctions "add" servent à créer les menus. Il vous suffit de les appeler dans l'ordre dans lequel vous désirez que ceux-ci apparaissent dans la barre de titre. Un coup d'oeil sur le programme d'exemple vous donnera quelques idées sur la syntaxe d'appel. La sélection dans la boucle de scrutation se fait grâce à la chaîne d'appel que vous spécifiez lors de la création de l'item. Rien de très différent par rapport aux gadgets, comme vous voyez...
La dernière fonction, setItem(), sert à rendre actif ou inactif un certain menu.
Autres fonctions
La rexxarplib vous autorise bien d'autres fantaisies que je citerai en vrac : dessins de régions (area...), de lignes (draw()), de cercles (drawEllipse()), remplissage (flood(), rectFill()), lecture d'image IFF (IFFImage()), changement de police (setFont()), écrire du texte (text(), windowText()), et bien d'autres encore... Voilà pour toutes les fonctions liées à Intuition.
Pour les fonctions plus évoluées que je n'ai pas évoquées en détails dans cette série d'articles : lecture d'un nom de fichier à l'aide d'une requête de fichiers (getFile()), correspondance de motif sur un répertoire (fileList()), ouverture d'écran (openScreen()), lecture des caractéristiques de l'écran (screenRows(), screenCols() et screenLace()), réarrangement des écrans (screenToFront(), screenToBack()), affichage d'une fenêtre de requêtes (request()), et bien d'autres.
En résumé
A quoi la rexxarplib peut-elle servir et quand est-il préférable de programmer en ARexx/rexxarplib plutôt qu'en C/assembleur ?
L'avantage indéniable d'ARexx dans ce domaine est l'énorme simplification apportée pour la création des objets Intuition. Quiconque a un jour implémenté une demi-douzaine de menus à la main saura de quoi je parle. En ARexx, il suffira d'autant de lignes que d'items. Idem pour les gadgets. Le fait que le langage soit interprété raccourcit encore davantage le temps mis pour obtenir une maquette graphique de votre application.
Une autre utilisation très intéressante peut être de rajouter des interfaces graphiques conviviales à certaines commandes Shell qui ne le sont pas (typiquement des archiveurs genre lha ou lz qui possèdent un nombre incalculable d'options). La facilité avec laquelle ARexx traite les chaînes et pilote les Shell rend cet exercice très facile.
apig.library
APIG = Arexx Programmers Intuition & Graphics Library. C'est donc une bibliothèque réservée aux programmeurs qui facilite grandement la programmation d'Intuition ainsi que celle de la graphics.library. La déclaration se fait par le classique :
| call addlib("apig.library",0,-30,0) |
...moyennant quoi toutes les facilités vous sont alors offertes. Je vais énumérer brièvement les plus importantes :
- Informations sur des objets Intuition. Par exemple, pour une fenêtre vous pouvez retirer un gadget précis, ses drapeaux IDCMP, etc.
- Chargement des images IFF (pic = loadiff("image", fenêtre)) et toute la gestion associée (taille, mode d'affichage, etc.).
- Ouverture de fenêtres et écrans.
- Remplissage de zones.
- Création et gestion de tout gadget (chaîne, proportionnel, etc.).
- Manipulation des "borders".
- Utilisation des menus.
- Structures plus internes : layers, rastports, etc.
- Création des boîtes de requêtes.
- Texte Intuition : structure IntuiText.
- Et beaucoup d'autres !
Conclusion
Vous en savez assez désormais pour vous y retrouver dans cette bibliothèque a priori compliquée mais qui est en fait imprégnée d'une philosophie très simple. La documentation vous donnera tous les détails que je n'ai pas évoqués dans cette série d'articles.
|
