 |
Samedi 31 mai 2025 - 16:45 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Rappel
L'ARexx est un langage génial qui a été implémenté dans AmigaOS pour permettre à divers programmes de dialoguer entre eux. Concrètement, vous venez de faire un joli dessin mais il vous manque une fonction dans votre logiciel préféré, or vous savez qu'un autre logiciel (une daube malheureusement) a cette fonction. La première solution est de sauver votre dessin, de le recharger dans l'autre logiciel, d'y appliquer l'effet désiré, le resauver et enfin de continuer dans votre logiciel favori : ça fait beaucoup de manipulations pour si peu.
Mais supposons que ces deux logiciels soient ARexx : c'est-à-dire qu'ils ont l'équivalent en langage ARexx de la plupart des actions que vous faites avec la souris. Exemple : charge une image = LOADFILE...
L'idée est alors de créer un programme ARexx (c'est très simple) qui va :
- Charger le logiciel de dessin qui va appliquer l'effet (dans l'exemple, la daube).
- Charger le dessin.
- Appliquer l'effet.
- Sauver le dessin ainsi modifié.
- Faire apparaître votre logiciel favori.
- Recharger le dessin modifié.
Le langage
C'est un langage interprété (pas de compilation), toutes les commandes sont lues une à une et exécutées tout doucement. Comme la plupart des programmes ARexx sont courts, la faible vitesse n'est pas un handicap. Le programme se tape dans un éditeur de texte et se lance par la commande : RX nom_du_programme_AREXX.
Ce langage est donc un ensemble de commandes issues des logiciels "ARexx" ainsi, dans tel logiciel, charger un fichier se dira : LOADFILE, dans un autre, LOAD, etc. ce qui va compliquer un peu la tâche avec toutes ces commandes qui se ressemblent un peu trop.
Il va se structurer ainsi :
/******** ligne obligatoire pour tous les programmes ARexx *********/
- Nom du port ARexx du programme appelé : généralement c'est le nom du programme avec ".1".
Pour Miami, ce sera par exemple : MIAMI.1.
- Commandes ARexx du programme cité au-dessus.
Exemple avec Miami : GETONLINE, ISCONNECT, etc.
C'est tout...
Si un deuxième programme doit être utilisé, c'est le même principe, on ajoute juste en dessous de ces premières lignes le nom du programme (port ARexx) et ses commandes ARexx ainsi chacun a ses commandes et rien ne se mélange !
Voici un exemple très concret :
Les ingrédients :
- Le logiciel de scanner d'ADPro.
- Le logiciel Personal Paint.
- Le logiciel ADPro.
Les étapes :
1) Le langage ARexx permet de lancer n'importe quoi, même si ce n'est pas ARexx. c'est la raison pour laquelle le programme du scanner sera lancé et son fichier sera sauvé en RAM: sous un nom quelconque.
2) Appel d'ADPro (lancement en fait) et chargement en ARexx du fichier en RAM:.
3) En ARexx, on passe le fichier en 256 couleurs avec tramage, etc. et on le sauve en RAM:.
4) Appel de Personal Paint et chargement en ARexx du fichier transformé et sauvé par ADPro.
5) C'est fini !
Ce qui donne :
|
/********** ligne obligatoire **********************/ OPTIONS RESULTS <---- cette ligne est souvent à mettre en début de programme mais pas obligatoire if ~ show('L', "rexxsupport.libray") then do addlib('rexxsupport.library',0,-30,0) <------- truc à vérifier end if ~show('L','rexxmathlib.library') then do addlib('rexxmathlib.library',0,-30,0) <-------- truc à vérifier end pragma('directory','Ram:') ram = showdir('Ram:','f') <-------- on mettra le fichier en RAM: LES LIGNES AU-DESSUS NE SONT PAS INDISPENSABLES ----------------------------------------------- address command 'hd1:arts/adpro-2/Epson_To_Disk' <------ lancement du scanner ram2 = showdir('Ram:','f') fichier = delstr(ram2,length(ram2)-length(ram)) fichier = insert('Ram:',fichier) <------- on met le tout en RAM: address command 'Assign FREDSCRIPTS: hd1:arts/adpro-2/Fredscripts >nil:' address command 'Assign ADPROSCRIPTS: hd1:arts/adpro-2/commands2 >nil:' address command 'Assign ADP_FRED: hd1:arts/adpro-2 >nil: ' address command 'Assign ADPRO: hd1:arts/adpro-2 >nil:' ADDRESS COMMAND 'Run >NIL: hd1:arts/adpro-2/adpro minimized behind' <-- on lance ADPro IF ~SHOW('PORTS',ADPro) then ADDRESS COMMAND 'Wait >NIL: 1 SEC' ADDRESS 'ADPro' <----------- on appel ADPro LFORMAT 'IFF' Load fichier <-------- on charge le dessin depuis la RAM: DITHER 1 RENDER_TYPE 256 <--------- transformation en 256 couleurs SCREEN_TYPE 7 EXECUTE SFORMAT 'IFF' Save fichier image <------ on sauve le fichier modifié en 256 couleurs Adpro_Exit ADDRESS 'PPAINT' <-------- appel de personal paint LoadImage '"'fichier'" FORCE ' <------- on charge le fichier issu d'ADPro ADDress command 'delete >NIL: 'fichier EXIT <--------- c'est fini ! /**************************************/ |
Tout ceci paraît un peu tordu et compliqué mais heureusement il y a de la documentation à tous les niveaux :
- Le livre ARexx (de Commodore) donné avec les A4000 de l'époque : il y a toutes les commandes ARexx du langage de base, presque rien en fait mais la syntaxe est tellement spéciale que cet ouvrage est recommandé.
- La documentation du/des logiciels que vous appelez (ADPro, Final Writer, TVPaint, Miami, etc.) soit en AmigaGuide ou sur papier (une bonne raison de ne pas pirater les logiciels pour avoir la documentation).
- Les logiciels du DP qui sont pour la plupart ARexx aussi.
- Les multiples exemples que l'on trouve dans ces mêmes logiciels (ADPro en a beaucoup).
RXMui
Là, ça devient un peu plus complexe car c'est de l'ARexx avec du MUI et la notion d'objet.
- L'ARexx ne change pas dans son principe, il donne des ordres à exécuter.
- MUI est une vaste collection d'objet que l'on manipule.
- Un objet est en fait un outil avec des caractéristiques que l'on appelle. Exemple : pour afficher un dessin, j'appelle un objet de type DTPIC et j'utilise la caractéristique FILE de ce type d'objet pour lui dire : je prends le dessin "DH0:Images/dessin.iff" que je mets dans la caractéristique FILE du type d'objet DTPIC.
exemple.0.CLASS="DTPIC"
exemple.0.FILE="DH0:Images/dessin.iff" (le chiffre 0 exprime le premier objet !)
Afin d'être plus simple à comprendre, voici un exemple :
Notre but ici est de faire apparaître une fenêtre sur le Workbench avec un bouton et si l'on clique sur ce bouton, cela affiche un mot.
Nous allons déclarer tous les objets (outils) nécessaires (une grande fenêtre et un bouton) et mettre en place tout ça mais des exemples aident à placer la structure de base.
|
/******** ligne obligatoire car c'est de l'ARexx *********/ l="rmh.library" if ~show("L",l) then if ~addlib(l,0,-30) then exit if AddLibrary("rxmui.library")~=0 then exit call CreateApp call HandleApp /* never reached */ /*********************/ HandleApp: procedure ctrl_c=2**12 do forever call NewHandle("app","h",ctrl_c) if and(h.signals,ctrl_c)>0 then exit select when h.event="QUIT" then exit otherwise interpret h.event end end /* never reached */ /********* Toutes les lignes ci-dessus sont obligatoires ************/ CreateApp: procedure app.SubWindow="WIN" <------------ ma grande fenêtre s'appellera : WIN WIN.class="bwin" <----- c'est un objet (un outil de type BWIN pour afficher une fenêtre) WIN.contents="GROS_BOUTON" <------- on crée un gros bouton dans la fenêtre de type BWIN GROS_BOUTON.CLASS"DTPIC" <--- c'est un objet (un outil de type DTPIC, pour afficher une image) GROS_BOUTON.transparent=1 GROS_BOUTON.inputmode="relverify" <------- c'est le bouton (mon objet devient un bouton) GROS_BOUTON.FILE="DH0:Images/dessin.iff" <---- l'image dans le bouton if NewObj("Application","app")>0 then exit call Notify("GROS_BOUTON.0","pressed",1,"app","Return","call AFFICHER") <---- appuyer sur le bouton = exécute AFFICHER call Notify("win","CloseRequest",1,"app","ReturnID","quit") <--------- si je ferme la fenêtre call set("WIN","open",1) <-------- ça ouvre la grande fenêtre WIN Return /************************/ AFFICHER: procedure say "CA MARCHE" <--------- ça affiche le mot "CA MARCHE" return /************************/ |
Pour tester, on tape "rxs nom_du_programme_AREXX" ou "rx nom_du_programme_AREXX", car c'est vraiment de l'ARexx mais avec MUI !
Ce n'est pas si compliqué en fait, car c'est toujours la même structure :
- Les bibliothèques à vérifier.
- Le truc en dessous qui boucle en permanence.
- La déclaration des objets en commençant par 0 (c'est ça que vous changez).
- Les actions si on appuie sur un bouton (ça aussi, c'est vous qui le faites).
Étant donné que c'est de l'ARexx, les actions sont infinies car en reprenant l'exemple plus haut il suffit d'appeler un programme pour lui faire faire une action et encore un autre logiciel ARexx lui aussi au lieu de lui faire afficher un mot.
Pour ceux qui veulent s'y mettre, il faut : MUI 3.8, RxMUI 40 (digilander.libero.it/asoft/) et de la patience mais pas trop, on fait vite son petit programme sans trop de mal.
|
