 |
Vendredi 06 juin 2025 - 12:46 |
| Translate |
|
| Rubriques |
| Réseaux sociaux |
|
| Liste des jeux Amiga |
|
| Trucs et astuces |
|
| Glossaire |
|
| Galeries |
|
| Téléchargement |
|
| Liens |
|
| Partenaires |
|
| A Propos |
|
| Contact |
|
|
|
Un exemple pratique, un gadget d'iconification universel
Un concept souvent mal perçu en programmation est celui de programmation objet. Mais il existe des domaines où certaines des spécificités des objets sont fondamentales. Exec, le micronoyau de l'Amiga et Intuition, son interface fenêtrée sont conçus fondamentalement pour être extensibles. En fait, AmigaOS est entièrement objet, particulièrement, son interface graphique est extensible et adopte à cette fin le concept de BOOPSI (Système simple de programmation orientée objet pour Intuition). Ce dernier est une manière de programmer des briques logicielles, construisant chacune une portion de l'interface, comme autant de modules (plugins).
Intuition ne contient pas de gadget d'iconification en standard mais VisualPrefs, je suis sûr que vous connaissez ce correctif, fournit une nouvelle classe BOOPSI : Images/titlebar.image. Classe qui contient de quoi créer un gadget assez général pour la barre de titre d'une fenêtre, et d'agir dessus. Notez qu'il n'est pas nécessaire d'utiliser VisualPrefs, en effet, il suffit d'installer cette bibliothèque, qu'on peut trouver sur Aminet.
Le but de cet article est l'implémentation d'un module du générateur d'interfaces du E, EasyGUI, ayant pour fonction de créer et gérer le gadget d'iconification d'une application quelconque.
Rappel succinct sur les objets et méthodes du E
Ce chapitre illustre les fonctionnalités "objet" du E, bien entendu, et comme on dit toujours dans ces cas là, je vous conseille de lire les sources consacrées à ce concept (e:src/afc par exemple).
Un objet est initialisé (on dit instantialisé) lorsqu'on utilise la fonction NEW du E, cette fonction est nécessaire pour initialiser les méthodes. A ce titre, NEW est le "constructeur" des objets. Sa contrepartie est END, nécessaire en tant que "destructeur".
Soit "obj" un objet:
OBJECT obj adr pipo lulu ENDOBJECT |
Un objet est défini par ses attributs, ces attributs peuvent être de types :
CHAR, INT, LONG, <object>
PTR TO CHAR, INT, LONG, <object>
ARRAY OF CHAR, INT, LONG, <object>
Bien que le E soit non typé, il est nécessaire de typer les objets si tant est qu'on veuille rester compatible avec le modèle du système lorsqu'on passe du C au E.
Par exemple:
MODULE 'intuition/intuitiion'
OBJECT obj
adr:PTR TO LONG
num:INT
win:PTR TO window
ENDOBJECT
|
Avec n:=obj.num par exemple, on accède à l'attribut num.
Avec w:=obj.win on pointe vers cette fenêtre.
Un objet peut posséder des méthodes, ces méthodes sont des fonctions normales du E, sauf qu'elles se rapportent à l'usage de ces objets.
OBJECT obj
champ
ENDOBJECT
PROC init(arg=NIL) OF obj
DEF resultat
/* initialise ceci-cela */
ENDPROC resultat
PROC main() HANDLE
/* On déclenche la méthode par :
*/
DEF o:PTR TO obj
NEW o.init()
/* On tue l'objet avec :
*/
EXCEPT DO
IF o THEN END o
ENDPROC
|
Un objet peut contenir des champs cachés : en alternant les instructions EXPORT/PRIVATE on peut cacher certains des champs de nos objets, au sein de nos modules. Cela se nomme le data-hiding, l'objet est alors une "black-box", car une fois le module compilé, on n'a plus accès qu'aux champs publics. Par contre, les méthodes sont toujours toutes visibles.
Exemple:
OPT MODULE
MODULE 'intuition/intuition'
EXPORT OBJECT obj
adr:PTR TO LONG
PRIVATE
num:INT
win:PTR TO window
ENDOBJECT
PROC do_it() OF obj IS EMPTY -> Dans ce cas la méthode est "vide"
|
Un objet peut appeler ses propres méthodes et attributs, il lui suffit de les référer à la variable self :
OBJECT obj
adr
num
ENDOBJECT
PROC init() OF obj
DEF res
res:=self.num
-> Appelle obj.num
ENDPROC res
|
Un objet peut hériter d'objets déjà connus, étendant alors les attributs et méthodes fournis initialement avec cet objet.
OBJECT obj
adr
num
ENDOBJECT
OBJECT bbb OF obj
nouveau_champ
ENDOBJECT
|
bbb devient donc :
OBJECT bbb adr num nouveau_champ ENDOBJECT |
A présent concentrons-nous sur les spécifications objets de EasyGUI.
Les générateurs EasyGUI
EasyGUI est un module du E (emodules:tools/easygui) qui a pour fonction de simplifier la création d'interfaces :
MODULE 'tools/easygui'
PROC main() IS easyguiA('titre',[SBUTTON,0,' Yea! '],NIL)
|
Les gadgets peuvent être par exemple BUTTON, TEXT, NUM, etc.
Mais il existe un type PLUGIN extensible, vide par défaut, mais fourni avec quelques attributs utiles et une poignée de méthodes.
OBJECT plugin
x:INT
y:INT
xs:INT
ys:INT
gh:PTR TO guihandle
ENDOBJECT
|
Les méthodes de cet objet sont : (les types des variables de ces fonctions sont documentés dans e:src/tools/easygui/docs/easygui.doc)
- min_size(a,b)
- will_resize()
- message_test(a,b)
- message_action(a,b,c,d)
- clear_render(a)
- render(a,b,c,d,e,f)
- appmessage(a,b)
- gtrender(a,b,c,d,e,f,g,h)
Le truc, pour bien comprendre le fonctionnement, c'est de connaître l'ordre dans lequel sont scrutées ces méthodes par le générateur d'interface :
1) min_size (calcule la taille minimum).
2) will_resize (ces deux méthodes servent aussi aux initialisations).
3) render (dessine le composant graphique -s'il est graphique-).
4) message_test (boucle d'interception des actions sur le gadget (filtre)).
5) message_action (réaction du gadget).
6) clear_render (efface tout).
(se référer aux exemples du E: e:src/tools/easygui/plugins).
Notre module EasyGUI
Quel plaisir de créer des briques systèmes : en effet, celles-ci sont universelles et permettent une conception totalement modulaire. D'autre part, elles sont réutilisables et permettent aux développeurs d'éviter à avoir à réinventer la roue.
L'organisation de notre projet est :
| project |
.build |
| tbi_test.e |
|
| modules |
titelbar.m |
| images |
titlebar.e |
| plugins |
tbi.e |
Le module "titlebar.m" a été créé à partir du fichier titlebar_lib.fd trouvé dans l'archive titlebarimage.lha et généré avec :
fd2module titlebar
Après une traduction des constantes et des structures du C vers le E, on obtient le fichier images/titlebar.e, que je vous livre ici in extenso :
OPT OSVERSION=39
OPT PREPROCESS
OPT MODULE
OPT EXPORT
/************************************************************/
/* Public definitions for the "titlebar image"
BOOPSI class */
/************************************************************/
/* This macro can be used to compute the correct
position for a gadget */
/* to be placed into the titlebar. "tbi" is
a pointer to a "tbiclass" */
/* instance and "num" is the number of gadgets
(zoom, depth...) that */
/* will be at the right side of the new gadget.
For instance, if your */
/* window has both a zoom gadget and a depth
gadget, you can compute */
/* the position of a new titlebar gadget with
TBI_RELPOS(tbi,2). */
/* If there's instead only a depth gadget, you'll
use TBI_RELPOS(tbi,1). */
/* Note: the new gadget MUST have the GFLG_RELRIGHT
flag set. */
/* w := tbi.width
*/
#define TBI_RELPOS(w,n) (1-((1+n)*(w-1)))
/* necessary to define here, because parts of
modules/plugins/tbi.m */
/* have to be globally private, for library
bases safe. */
/* i.e. module must be OPT EXPORT to share macros
*/
#define DEFICON 'env:sys/def_tool'
#define TITLEBAR PLUGIN
MODULE 'utility/tagitem'
/* Attributes defined by the "tbiclass" image
class */
#define TBIA_DUMMY (TAG_USER + 0x0B0000)
#define TBIA_CONTENTSBOX (TBIA_DUMMY + 0x0001)
/* Get inner size (V40.12) */
/* Types of titlebar gadget
images available */
ENUM POPUPIMAGE =101,
MUIIMAGE ,
SNAPSHOTIMAGE ,
ICONIFYIMAGE ,
PADLOCKIMAGE ,
TBFRAMEIMAGE
|
Fichier qui est compilé avec :
Ec images/titlebar
D'où le code du plugin :
OPT PREPROCESS
OPT MODULE
OPT OSVERSION=39
->types OF sys:classes/images/titlebar.image
->POPUPIMAGE,
->MUIIMAGE,
->SNAPSHOTIMAGE,
->ICONIFYIMAGE,
->PADLOCKIMAGE,
->TBFRAMEIMAGE ->fallback
->#define DEBUG
#define NODEBUG
#ifdef DEBUG
MODULE 'tools/easygui_debug'
#endif
#ifdef NODEBUG
MODULE 'tools/easygui'
#endif
-> Remarquez les différents chemins, absolus et relatifs.
-> Le compilateur utilise le répertoire courant du fichier
source, et non pas le répertoire courant au lancement
de la commande
MODULE 'icon','*/titlebar',
'*/images/titlebar',
'intuition/gadgetclass','intuition/imageclass',
'intuition/intuition','intuition/screens',
'libraries/gadtools',
'wb',
'workbench/startup','workbench/workbench'
MODULE 'libraries/gadtools'
ENUM TB_NO_ERROR,
TB_ERROR_LIBRARY,
TB_ERROR_DRAWINFO,
TB_ERROR_NEWOBJECT,
TB_ERROR_ICON,
TB_ERROR_PORT
-> On redéfinit des bases locales privées
pour ces bibliothèques.
DEF iconbase,titlebarimagebase,workbenchbase
-> Voici notre objet, dont le type et les méthodes
sont partagés
EXPORT OBJECT tbi OF plugin
type
PRIVATE
dri:PTR TO drawinfo
scr:PTR TO screen
i :PTR TO image
gad:PTR TO gadget
icon
label
relpos
ENDOBJECT
-> L'objet n'est pas retaillable par l'utilisateur
PROC will_resize() OF tbi IS FALSE
-> L'objet ne représente pas un gadget
à l'intérieur de la
fenêtre, il ne participe donc
pas au calcul de la taille générale
|
Après compilation en tbi.m ceci entraîne la création d'un exemple.
L'exemple :
OPT PREPROCESS
OPT OSVERSION=39
MODULE 'tools/easygui',
'*modules/images/titlebar',
'*modules/plugins/tbi'
-> Par paresse, je n'est pas ajouté
de test automatique de l'identité du programme appelant l'objet.
-> Il faut donc respecter le nom du fichier
exécutable.
#define APP_NAME 'PROGDIR:tbi_test'
#define APP_ICON 'coucou'
PROC main() HANDLE
DEF t:PTR TO tbi,t2:PTR TO tbi
-> On utilise l'objet par défaut
à gauche, position 3
-> Puis celui d'icônification
en position 2, il reste en effet
-> le gadget de retaillage en position
1 à droite.
NEW t.tbi(),t2.tbi(ICONIFYIMAGE,2,APP_ICON,APP_NAME)
easyguiA('titre',[ROWS,
[TITLEBAR,{cloc},t],
[TITLEBAR,{cloc},t2],
[EQCOLS,
-> Ces gadgets ne sont là que pour
-> créer de l'espace
[SBUTTON,{clac},'
yep ! '],
[SBUTTON,{clac},'
yop ! ']
],
[SPACE],[BAR]
],NIL)
EXCEPT DO
IF t THEN END t
IF t2 THEN END t2
IF exception THEN WriteF('error : \\d,\\n',exception)
ENDPROC
PROC cloc(i) IS WriteF('cloc\\n')
PROC clac(i) IS WriteF('clac\\n')
|
Conclusion
C'est ainsi qu'à présent vous êtes pourvus d'un gadget d'iconification très pratique pour cacher vos fenêtres d'application, mais aussi lorsque l'on retouche le Workbench, et qu'il faut mettre à jour Intuition, ce gadget permettra de ne pas avoir à quitter votre application. Vous pouvez vous servir du patron fourni par e:src/tools/easygui/plugins/ticker.e pour faire vos propres gadgets. J'ai par exemple construit un objet qui sauve la position de la fenêtre automatiquement lorsqu'on la clôt.
Non seulement l'interface graphique (Intuition) est extensible au travers de BOOPSI (sys:classes/images) mais le générateur EasyGUI est aussi extensible, à l'aide des modules. Chaque nouveau module vient ajouter une fonctionnalité. Pour rester simple, il est nécessaire que peu de champs restent visibles (data-hiding), que les constantes aient des noms à rallonge, de manière à éviter les collisions...
Les méthodes, si vous en ajoutez de nouvelles, doivent être un minimum, pour rester rapide, lors de message_test(), tâchez de faire vite !
Ici, nous nous sommes simplement servis d'un objet existant. Pour ajouter une fonction au système lui-même, c'est une bibliothèque qu'il faut compiler. Mais bon, on fera ça une autre fois.
|
