Obligement - L'Amiga au maximum

Lundi 24 juillet 2017 - 18:40  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

 · Accueil
 · A Propos
 · Articles
 · Galeries
 · Glossaire
 · Hit Parade
 · Liens
 · Liste jeux Amiga
 · Quizz
 · Téléchargements
 · Trucs et astuces


Articles

 · Actualité (récente)
 · Actualité (archive)
 · Comparatifs
 · Dossiers
 · Entrevues
 · Matériel (tests)
 · Matériel (bidouilles)
 · Points de vue
 · En pratique
 · Programmation
 · Reportages
 · Tests de jeux
 · Tests de logiciels
 · Tests de compilations
 · Articles divers

 · Articles in english
 · Articles in other languages


Twitter

Suivez-nous sur Twitter




Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Moteurs de recherche
 · Pages de liens
 · Constructeurs matériels
 · Matériel
 · Autres sites de matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Développeurs logiciels
 · Logiciels
 · Développeurs de jeux
 · Jeux
 · Autres sites de jeux
 · Scène démo
 · Divers
 · Informatique générale


Jeux Amiga

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Trucs et astuces

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Glossaire

0, A, B, C, D, E, F,
G, H, I, J, K, L, M,
N, O, P, Q, R, S, T,
U, V, W, X, Y, Z


Partenaires

Annuaire Amiga

Amedia Computer

Relec

Hit Parade


Contact

David Brunet

Courriel

 


Programmation : ARexx et RxMUI
(Article écrit par Jean-Yves Auger - février 2004)


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é.
Si vous comprenez ce principe, vous avez tout compris du principe de l'ARexx : c'est en fait un chef d'orchestre qui va faire exécuter des tâches à des logiciels et rien d'autre car l'ARexx sait à peine faire autre chose qu'une addition !

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.
Le but ici est de numériser une image, la passer en 256 couleurs pour la transformer dans Personal Paint. La raison de cet exemple est que le logiciel de scanner n'est pas ARexx et Personal Paint est très lent à convertir une image issue de scanner (en 24 bits), ADPro est meilleur et plus rapide.

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).
Mélangez tout ça et vous avez la plus formidable collection d'outils jamais vue ! Mais ce langage n'existe en fait qu'avec la présence des autres logiciels qu'il commande. Aussi, il a été ajouté des modules liés à MUI pour lui donner un autre aspect (une interface graphique) et beaucoup plus de possibilités : c'est RXMui.

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.
Ça s'écrit :
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).
Pixload 4.2 a été fait comme ça, je n'ai pas changé le début de la structure, j'ai juste ajouté des boutons et défini les actions si on appuie sur les boutons.

É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.


[Retour en haut] / [Retour aux articles]