Suivez-nous sur X
|
|
|
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,
ALL
|
|
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
|
|
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
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : E - Colortext
(Article écrit par Olivier Adam - juillet 1998)
|
|
Le E, langage des langages
Inventé par Wouter Van Oortmerssen, ce langage est en fait une compilation de tous les autres
(C, Pascal, Lisp, assembleur...) mais en gardant les bonnes idées et en jetant les prises de
tête ! Totalement Amiga, c'est un langage particulièrement adapté à la programmation système,
parce qu'il intègre les fonctions des quatre principales bibliothèques : Dos, Intuition, Exec et Graphics.
De même, on peut programmer en assembleur en ligne, sans passer par un éditeur de liens, la
compilation est très rapide et les besoins en ressources n'étant pas énormes, on peut
travailler sur un A500... Le code est en 68000, pour le Kickstart 2.0, mais on peut quand même
pondre du code pour 3.1. En bref, simple, lisible, code assez court, respectueux du système.
Exemple
PROC main()
WriteF('Hello World\n')
ENDPROC
|
Bon, ben, et alors ? me direz-vous, je ne vois pas où il y a du changement ? Z'aviez qu'à
demander !
Travaux pratiques
L'intérêt, par exemple, c'est une programmation objet enfin à la portée de tous. A l'aide
du découpage des programmes en petites unités indépendantes, des modules. Chaque nouvelle
bibliothèque en possède un, mais vos programmes peuvent eux aussi être découpés en de multiples
petits composants, chacun étant une partie d'un autre plus important... Pour bien saisir, il est
nécessaire de récupérer le E sur Aminet,
ou sur un des CD de Dream. Le langage est mature à partir de la 3 et les versions de démo suffisent
à faire des petites fonctions Dos.
Alors, on passe la seconde et voilà un exemple, c'est un nouveau module pour votre E, plus
précisément pour EasyGUI, le GUI-Builder du E (pour faire de belles interfaces facilement). Son
rôle est de colorer du texte mais en utilisant pour ça une fonction précise : ObtainBestPenA()
qui retourne le numéro de la couleur correspondant à la combinaison rouge-vert-bleu donnée
en argument, ce qui est très pratique, vu que je ne sais pas où se trouve votre rouge ou
votre jaune par exemple sur la palette que votre Workbench utilise. Ceci fonctionne en faisant la
moyenne des couleurs et en comparant avec un seuil de précision, donné lui aussi en argument,
l'idéal, si on ne trouve pas de couleur identique ou approchante, est de retourner à un texte
noir, vu qu'il sera toujours affiché sur un écran noir et blanc (bien que je n'ai jamais vu de
Workbench en N&B :-)).
Vu que c'est la première fois, je préfère vous écrire quelque chose de
complexe, parce que les magazines en général ne vous montrent que des
fonctions bateaux ou des trucs de Copper-Raster-Blitter incompréhensibles !
->ceci est un commentaire
/* ça aussi */
OPT OSVERSION=39 ->option de compil, kick>=3.0
OPT MODULE ->option de compil, ceci est un module
-> les variables et objets du système que l'on utilise se trouvent dans les modules ci-après
MODULE 'graphics/gfxbase','graphics/text','graphics/view'
MODULE 'intuition/intuition','intuition/screens'
MODULE 'tools/easygui'
-> tout ce qui est exporté sera visible de l'extérieur
-> on enumère de zéro à 2 (g=0, c=1, d=2)
EXPORT ENUM GAUCHE,CENTRE,DROITE
-> notre objet, colortext, issu de l'objet plugin (de EasyGUI),
-> sera exporté, sauf ce qui est après PRIVATE (logique)
EXPORT OBJECT colortext OF plugin
color -> Couleur trouvée
len -> Longueur calculée
state -> État GAUCHE,CENTRE,DROITE,PRIVATE
text -> Texte affiché
screen:PTR TO screen -> Notre écran
fontwidth -> Largeur de la police système
ENDOBJECT
-> Les méthodes de l'objet, il accepte celles de son père
-> le "plugin" de easygui, comme will_resize ou min_size,
-> que l'on peut redéfinir, et d'autres, de nouvelles,
-> comme init que l'on a inventé.
PROC init(t,r,g,b,etat=GAUCHE) OF colortext
-> méthode d'initialisation (t=Texte, r=couleur rouge, g=couleur verte, b=couleur bleue)
DEF gfx:PTR TO gfxbase -> Notre graphics.base
DEF pass:PTR TO colormap -> Passe notre colormap
gfx:=gfxbase -> Copie graphics.base
self.state:=etat -> Transfert de l'état dans colortext.state
self.fontwidth:=(gfx.defaultfont.xsize)
self.text:=t -> auto conçoit l'objet lui-même (colotext)
self.screen:=LockPubScreen(NIL) -> Verrouille cet écran
-> Cherche la couleur demandée
self.color:=ObtainBestPenA(pass:=self.screen.viewport.colormap,r,g,b,NIL)
-> Sinon, texte en noir (couleur 1)
IF self.color=0 THEN self.color:=1
ENDPROC pass -> Rend une copie de screen.viewport.colormap
PROC will_resize() OF colortext IS RESIZEX -> retaillable dans le sens des X
PROC min_size(ta:PTR TO textattr,fh) OF colortext -> taille minimum
self.len:=StrLen(self.text)*self.fontwidth
ENDPROC self.len , fh
-> Rend la longueur du texte et sa hauteur
PROC render(ta:PTR TO textattr,x,y,xs,ys,w:PTR TO window) OF colortext -> dessine le texte en couleur
DEF st
Colour(self.color,0)
st:=self.state
SELECT st
CASE GAUCHE ; TextF(self.x,self.y+ta.ysize-2,self.text)
CASE CENTRE ; TextF(self.x+(self.xs/2-(self.len/2)),self.y+ta.ysize-2,self.text)
CASE DROITE ; TextF(self.x+self.xs-self.len,self.y+ta.ysize-2,self.text)
ENDSELECT
ENDPROC
PROC kill(pass) OF colortext -> Tue l'objet en refermant tout
ReleasePen(pass,self.color)
UnlockPubScreen(NIL,self.screen)
ENDPROC
|
Ceci doit-être sauvé en colortext.e par exemple en RAM: puis compilé avec :
On obtient colortext.m (module) qui va être utilisé par ce petit source :
/*
**E-src
**Test easygui colortext plugin
**©Adam98
*/
OPT OSVERSION=39 -> toujours cette version 3.0...
-> on utilise : easygui, le module de construction d'interfaces
MODULE 'tools/easygui','*colortext' -> notre petit module
PROC main() -> procédure principale
DEF p:PTR TO colortext ,cm -> on veut des objets colortext
DEF p1:PTR TO colortext ,cm1
DEF p2:PTR TO colortext ,cm2
DEF p3:PTR TO colortext ,cm3
NEW p,p1,p2,p3 -> on les crée
-> initialisation
cm:=p.init('Mon Texte Rouge',$FF000000,$00000000,$00000000)
cm1:=p1.init('Mon Texte Jaune',$FF000000,$FF000000,$00000000,DROITE)
cm2:=p2.init('Mon Texte Vert',$00000000,$FF000000,$00000000,GAUCHE)
cm3:=p3.init('Mon Texte Bleu',$00000000,$00000000,$FF000000,CENTRE)
-> on crée l'interface (fenêtre), grâce à une fonction du module easygui
easyguiA('Titre',[ROWS, -> lignes
[NUM,p.color,'N° couleur rouge:',NIL,TRUE,4], -> gadget
numérique [BEVEL, -> en relief comme un bouton
[PLUGIN,0, p] -> notre plugin
],[PLUGIN,0, p1],[BEVELR, -> comme un bouton pressé
[PLUGIN,0, p2]],[BEVEL,[PLUGIN,0,p3]]],NIL)
p.kill(cm) -> on tue les objets
p1.kill(cm1)
p2.kill(cm2)
p3.kill(cm3)
END p,p1,p2,p3 -> même en mémoire
ENDPROC -> on se casse !
/* fin de la source*/
|
Si tout va bien, vous sauvez dans RAM:colortext_test.e, puis vous faites, dans un Shell :
puis
Et là oh ! c'est bô !
|
