Obligement - L'Amiga au maximum

Dimanche 19 novembre 2017 - 05:45  

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 : 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 :

EC colortext

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 :

EC colortext_test

puis

colortext_test

Et là oh ! c'est bô !


[Retour en haut] / [Retour aux articles] [Article suivant]