Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 14:46  

Translate

En De Nl Nl
Es Pt It Nl


Rubriques

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

 · Articles in english


Twitter

Suivez-nous sur Twitter




Liste des 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,
ALL


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


Galeries

 · Menu des galeries

 · BD d'Amiga Spécial
 · Caricatures Dudai
 · Caricatures Jet d'ail
 · Diagrammes de Jay Miner
 · Images insolites
 · Fin de jeux (de A à E)
 · Fin de Jeux (de F à O)
 · Fin de jeux (de P à Z)
 · Galerie de Mike Dafunk
 · Logos d'Obligement
 · Pubs pour matériels
 · Systèmes d'exploitation
 · Trombinoscope Alchimie 7
 · Vidéos


Téléchargement

 · Documents
 · Jeux
 · Logiciels
 · Magazines
 · Divers


Liens

 · Sites de téléchargements
 · Associations
 · Pages Personnelles
 · Matériel
 · Réparateurs
 · Revendeurs
 · Presse et médias
 · Programmation
 · Logiciels
 · Jeux
 · Scène démo
 · Divers


Partenaires

Annuaire Amiga

Amedia Computer

Relec


A Propos

A propos d'Obligement

A Propos


Contact

David Brunet

Courriel

 


Programmation : Amiga C Manual - Les graphismes
(Article écrit par Anders Bjerin et extrait d'Amiga C Manual - mars 1990)


Note : traduction par Serge Hammouche.

3.0 Graphismes

3.1 Introduction

Nous avons vu comment ouvrir différents types d'écrans, et de fenêtres liées à ces écrans, etc. C'est très bien, mais que serait Intuition sans graphismes à afficher dans les écrans et fenêtres ?

Le principe d'Intuition est de rendre la communication entre le programme et l'utilisateur aussi fluide que possible. Les graphismes vous permettent d'afficher les résultats qu'a calculés l'ordinateur de façon intelligible (une image est plus parlante que des chiffres). Les graphismes simplifient aussi beaucoup l'utilisation du programme et peuvent prévenir l'utilisateur si quelque chose de dangereux risque d'arriver : il est facile de presser le mauvais bouton en réponse à une question comme "OK pour effacer la disquette ?" mais si elle avait été accompagnée par une image montrant une croix avec "RIP" écrit dessus, vous auriez sûrement pris plus de précautions.

Il y a deux façons de faire des graphismes : la programmation de bas et de haut niveau. L'approche de bas niveau (par les primitives graphiques) n'est pas décrite dans ce chapitre car sans rapport avec Intuition. Les routines graphiques de bas niveau sont très rapides mais si vous n'y faites pas attention, elles peuvent endommager les menus, etc. Nous nous pencherons ici sur l'approche de haut niveau qui est assurée par Intuition et permet de dessiner sans danger.

3.2 Lignes, texte, images

Intuition fournit trois méthodes différentes pour créer des graphismes :
  • Vous pouvez tracer des lignes (Borders).
  • Afficher du texte (IntuiText).
  • Ou vous pouvez afficher directement des images graphiques (Images).
3.3 Border

"Border" est un nom trompeur car vous n'êtes pas limité au dessin des bordures, vous pouvez dessiner toute forme polygonale. Une structure Border peut aussi être liée à d'autres structure Border, ainsi tout ce que l'on peut dessiner avec des lignes peut être dessiné avec les structures Border d'Intuition.

3.3.1 La structure Border

Quand vous voulez dessiner des lignes, vous devez déclarer et initialiser une structure Border qui ressemble à ceci :

struct Border
{
  SHORT LeftEdge, TopEdge;
  SHORT FrontPen, BackPen, DrawMode;
  SHORT Count;
  SHORT *XY;
  struct Border *NextBorder;
};
  • LeftEdge, TopEdge : position de départ des lignes.
  • FrontPen : registre couleur utilisé pour dessiner les lignes.
  • BackPen : cette variable n'est pas utilisée pour le moment.
  • DrawMode : doit être JAM1 ou XOR. Si le drapeau JAM1 est activé, la couleur spécifiée (FrontPen) sera utilisée pour dessiner les lignes indépendamment de la couleur du fond. Le drapeau XOR les fait dessiner avec le complément binaire de la couleur du fond.
  • Count : le nombre de points dans le tableau XY (voir ci-après pour plus d'informations).
  • XY : un pointeur sur un tableau contenant les coordonnées des points utilisés pour dessiner les lignes (voir ci-après pour plus d'informations).
  • NextBorder : un pointeur sur la prochaine structure Border s'il y en a une, NULL sinon.
3.3.2 Les coordonnées

Si vous voulez dessiner ceci :

(10,10)        (25,10)
   *--------------*
                  |      (35,12)
                  |         *
                  |         |
                  *---------*
               (25,14)   (35,14)


Le tableau des coordonnées ressemblera à ceci :

SHORT my_points[]=
{
  10,10, /* Départ à la position (10,10) */
  25,10, /* Dessiner une ligne jusqu'à la position (25,10)           */
  25,14, /* dessiner une ligne jusqu'à la position (25,14)           */
  35,14, /* dessiner une ligne jusqu'à la position (35,14)           */
  35,12  /* Fin du dessin en dessinant une ligne jusqu'à la position */
         /* (35,12)                                                  */
};

Le tableau contient cinq points, la variable Count doit être choisie en conséquence. La structure Border complète aura donc cet aspect :

struct Border my_border=
{
  0, 0,        /* LeftEdge, TopEdge, le coin supérieur gauche.     */
  3,           /* FrontPen, registre couleur 3.                    */
  0,           /* BackPen, non utilisé pour le moment.             */
  JAM1,        /* DrawMode, dessiner les lignes avec la couleur 3. */
  5,           /* Count, 5 couples de coordonnées dans le tableau. */
  my_points,   /* XY, pointeur sur le tableau des coordonnées.     */
               /* (Attention : my_points == &my_points[0])         */
  NULL         /* NextBorder, pas d'autre structure Border après   */
               /* celle-ci.                                        */
};

3.4 Comment utiliser la structure Border

La structure Border est utilisée pour dessiner des lignes dans un écran ou une fenêtre mais peut aussi l'être pour dessiner des lignes liées à un gadget, une requête ou un menu (voir les chapitres 4, 5 et 7 pour plus d'informations sur les gadgets, requêtes et menus).

Pour lier une structure Border à un gadget, etc., il suffit d'initialiser la structure Gadget avec un pointeur sur la structure Border et Intuition dessinera les lignes pour vous. Ceci sera expliqué plus tard.

Pour dessiner les lignes dans un écran ou une fenêtre, vous devez indiquer à Intuition que vous voulez qu'il utilise la structure pour tracer des lignes. Faites-le en appelant la fonction DrawBorder() :
  • Synopsis : DrawBorder( rast_port, border, x, y );
  • rast_port : (struct RastPort *). Pointeur sur un RastPort. Si les lignes doivent être dessinées dans une fenêtre et que my_window est un pointeur sur cette fenêtre, écrivez : my_window->RPort. Si les lignes doivent être dessinées dans un écran et que my_screen est un pointeur sur cet écran, écrivez : my_screen->RastPort.
  • border : (struct Border *). Pointeur sur une structure Border qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés à la coordonnée en x.
  • y : (long). Nombre de lignes ajoutées à la coordonnée en y.
Un appel pour dessiner des lignes avec la structure my_border ressemblera à ceci :

DrawBorder( my_window->RPort, &my_border, 0, 0 );

Si vous avez créé une structure Border qui, par exemple, dessine un rectangle, vous pouvez dessiner plusieurs rectangles à différents endroits juste en modifiant les champs LeftEdge et RightEdge de la structure Border, ou en modifiant les champs x, y dans l'appel de la fonction. Ceci prouve la souplesse du dessin de haut niveau avec Intuition.

3.4 Le texte

L'affichage du texte est assuré par la structure IntuiText. Elle est assez semblable à la structure Border et s'effectue de la même façon. La seule différence est que vous devez indiquer à Intuition quelle police de caractères vous voulez utiliser et quel texte afficher.

3.4.1 La structure IntuiText

Pour afficher du texte, vous devez déclarer et initialiser une structure IntuiText qui ressemble à ceci :

struct IntuiText
{
  UBYTE FrontPen, BackPen;
  UBYTE DrawMode;
  SHORT LeftEdge;
  SHORT TopEdge;
  struct TextAttr *ITextFont;
  UBYTE *IText;
  struct IntuiText *NextText;
};
  • FrontPen : registre couleur utilisé pour dessiner le texte.
  • BackPen : registre couleur utilisé pour dessiner le fond du texte.
  • DrawMode : il y a trois modes d'affichage pour du texte :
    • JAM1 : la couleur spécifiée (FrontPen) sera utilisée pour dessiner le texte, le fond n'est pas modifié.
    • JAM2 : la couleur FrontPen sera utilisée pour dessiner le texte, le fond est dessiné avec la couleur BackPen.
    • XOR : le texte est dessiné avec le complément binaire du fond.
  • LeftEdge, TopEdge : position de départ du texte.
  • ITextFont : un pointeur sur une structure TextAttr qui indique à Intuition quelle police, taille, style, etc. sont utilisés pour afficher le texte. Mettez NULL si vous voulez utiliser la police par défaut (voir plus loin pour plus d'informations).
  • IText : un pointeur sur la chaîne terminée par NULL qui doit être affichée.
  • NextText : un pointeur sur la prochaine structure IntuiText s'il y en a une, NULL sinon.
3.4.2 Les polices de caractères

Vous pouvez demander à Intuition d'afficher le texte avec une police ou un style donné. Il vous suffit de déclarer et d'initialiser une structure TextAttr et de fournir à votre structure IntuiText un pointeur sur la structure TextAttr.

La structure TextAttr ressemble à ceci :

struct TextAttr
{
  STRPTR ta_Name;
  UWORD ta_YSize;
  UBYTE ta_Style
  UBYTE ta_Flags;
};

Nous ne parlerons pour le moment que des ROM-fonts (les polices qui sont toujours disponibles en ROM) et nous attendrons pour les Disk-fonts (les polices sur disquette auxquelles peut accéder votre programme).

Il n'y a qu'une ROM-font actuellement et elle s'appelle Topaz. Elle existe en deux tailles, 64/32 et 80/40 (haute/basse résolution) caractères par ligne et peut être affichée en cinq styles différents : normal, gras, italique, souligné et étendu, qui peuvent être combinés selon vos souhaits.
  • ta_Name : nom de la police. Mettez "topaz.font" pour le moment.
  • ta_YSize : hauteur de la police. Soit TOPAZ_SIXTY (64/32) soit TOPAZ_EIGHTY (80/40).
  • ta_Style : style (normal, gras, souligné, italique et étendu). Activez les drapeaux nécessaires :
    • FS_NORMAL : pas de style particulier.
    • FSF_EXTENDED : police étendue, plus large que la normale.
    • FSF_ITALIC : italique, penchée de 1:2 vers la droite.
    • FSF_BOLD : gras, plus épais que la normale.
    • FSF_UNDERLINED : souligné, ligne sous la ligne de base.
  • ta_Flags : préferences. Doit être mis à FPF_ROMFONT pour le moment.
Voici un exemple pour afficher du texte en caractères soulignés italiques :

struct TextAttr my_font=
{
  "topaz.font",                 /* Police Topaz.                    */
  TOPAZ_EIGHTY,                 /* 80/40 caractères par ligne.     */
  FSF_ITALIC | FSF_UNDERLINED,  /* Caractères soulignés italiques. */
  FPF_ROMFONT                   /* Existe en ROM.                  */
};

UBYTE my_text[]="C'est le texte qui va être affiché!";

struct IntuiText my_intui_text=
{
  2,         /* FrontPen, registre couleur 2.                          */
  3,         /* BackPen, registre couleur 3.                           */
  JAM2,      /* DrawMode, dessiner les caractères avec la couleur 2,   */
             /* sur un fond en couleur 3.                              */
  0, 0,      /* LeftEdge, TopEdge.                                     */
  &my_font,  /* ITextFont, utiliser my_font.                           */
  my_text,   /* IText, le texte qui va être affiché.                   */
             /* (Attention my_text = &my_text[0].)                     */
  NULL       /* NextText, aucune autre structure IntuiText n'est liée. */
};

3.4.3 Comment utiliser la structure IntuiText

La structure IntuiText est utilisée pour afficher du texte dans un écran ou une fenêtre, mais peut aussi être utilisée pour afficher un texte lié à un gadget, menu ou requête. Comme pour le dessin des lignes avec la structure Border.

Pour afficher du texte dans une fenêtre/écran, il suffit d'appeler la fonction PrintIText() :
  • Synopsis : PrintIText( rast_port, intui_text, x, y );
  • rast_port : (struct RastPort *). Pointeur sur un RastPort. Si le texte doit être affiché dans une fenêtre et que my_window est un pointeur sur cette fenêtre, écrivez : my_window->RPort. Si le texte doit être affiché dans un écran et que my_screen est un pointeur sur cet écran, écrivez : my_screen->RastPort.
  • intui_text : (struct IntuiText *). Pointeur sur une structure IntuiText qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés à la position en x des caractères.
  • y : (long). Nombre de lignes ajoutées à la position en x des caractères.
Un appel pour afficher du texte avec la structure my_intui_text ressemblera à ceci :

PrintIText( my_window->RPort, &my_intui_text, 0, 0 );

3.5 Les images

Nous avons déjà vu comment afficher du texte et dessiner des lignes. Nous allons finir par l'affichage direct d'une image. La procédure peut être divisée en trois étapes :
  1. Déclarer et initialiser les données à dessiner.
  2. Déclarer et initialiser une structure Image.
  3. Appelez la fonction DrawImage() pour dessiner l'image.
3.5.1 Les données Image

Intuition exige des données Image structurées en blocs de mots de 16 bits (UWORD), organisés en zones rectangulaires (bitplanes, alias plans de bits)). Vous pouvez avoir jusqu'à six plans de bits (quatre si vous affichez l'image dans un écran haute résolution). La couleur de chaque pixel est déterminée par le nombre binaire formé par les plans de bits. Par exemple, pour avoir un pixel de la couleur 6 dans un écran de profondeur (depth) 4, les plans de bits zéro et trois doivent être à 0 et les plans de bits un et deux doivent être à 1, car le nombre binaire 0110 vaut 6 en décimal.

Une petite flèche peut par exemple ressembler à ceci (un plan de bits = deux couleurs) :

 Image       Mots de 16 bits      Représentation hexadécimale
-------------------------------------------------------------

0001000    0001 0000 0000 0000             1 0 0 0
0011100    0011 1000 0000 0000             3 8 0 0
0111110    0111 1100 0000 0000             7 C 0 0
1111111    1111 1110 0000 0000             F E 0 0
0001000    0001 0000 0000 0000             1 0 0 0
0001000    0001 0000 0000 0000             1 0 0 0
0001000    0001 0000 0000 0000             1 0 0 0
0001000    0001 0000 0000 0000             1 0 0 0

Bien que l'image n'ait que sept pixels de large, les données Image doivent avoir une largeur de 16 (bits) pixels, puisqu'Intuition exige des données ordonnées en mots de 16 bits (bien sur, quand vous l'afficherez, vous pourrez indiquer à Intuition que l'image ne doit avoir que sept pixels de large).

Chaque groupe de quatre pixels est transformé en chiffre hexadécimal. Voir la table :

Binaire => Hexadécimal
-------------------------------------------------------------------

0000 =>  0         0100 =>  4         1000 =>  8         1100 =>  C
0001 =>  1         0101 =>  5         1001 =>  9         1101 =>  D
0010 =>  2         0110 =>  6         1010 =>  A         1110 =>  E
0011 =>  3         0111 =>  7         1011 =>  B         1111 =>  F

La déclaration et l'initialisation des données pour la flèche auront donc cette allure :

UWORD chip my_image_data[]=
{
  0x1000, /* Plan de bits 0 */
  0x3800,
  0x7C00,
  0xFE00,
  0x1000,
  0x1000,
  0x1000,
  0x1000
};

Comme les données image ne sont composées que d'un plan de bits, la flèche sera dessinée en couleur 1 et le fond aura la couleur 0.

Si l'image fait plus de 16 pixels de large, il vous faut plus d'un mot par ligne. Voici une image de 20 pixels de large et qui nécessitera donc deux mots par ligne :

       Image                   Mots de 16 bits (deux mots)
---------------------------------------------------------------

11111111111111111111   1111 1111 1111 1111  1111 0000 0000 0000
00111110000001111100   0011 1110 0000 0111  1100 0000 0000 0000
00001111100111110000   0000 1111 1001 1111  0000 0000 0000 0000
00111110000001111100   0011 1110 0000 0111  1100 0000 0000 0000
11111111111111111111   1111 1111 1111 1111  1111 0000 0000 0000

Vous traduisez les nombres binaires en hexadécimal et vous obtenez :

UWORD chip my_image_data[]=
{
  0xFFFF, 0xF000, /* Plan de bits 0 */
  0x3E07, 0xC000,
  0x0F9F, 0x0000,
  0x3E07, 0xC000,
  0xFFFF, 0xF000
};

Si vous voulez plus de deux couleurs, il vous faut plus d'un plan de bits. Un visage en quatre couleurs peut ressembler à ceci :

003333300000     0: Bleu    (couleurs normales du Workbench)
033333330000     1: Blanc
332232233000     2: Noir
323333323000     3: Orange
331131133000
331131133000
331232133000
331232133000
333333333000
332333233000
033222330000
033333330000
003333300000

Vous transformez en mots de 16 bits, organisés en deux plans de bits (deux plans de bits = quatre couleurs) :

Couleur  Plan de bits 1  Plan de bits 0         CAR
-------------------------------------------------------
   0          0               0          00 (b) = 0 (d)
   1          0               1          01 (b) = 1 (d)
   2          1               0          10 (b) = 2 (d)
   3          1               1          11 (b) = 3 (d)


         Plan de bits 1          Plan de bits 0
      -------------------------------------------

      0011 1110 0000 0000     0011 1110 0000 0000
      0111 1111 0000 0000     0111 1111 0000 0000
      1111 1111 1000 0000     1100 1001 1000 0000
      1111 1111 1000 0000     1011 1110 1000 0000
      1100 1001 1000 0000     1111 1111 1000 0000
      1100 1001 1000 0000     1111 1111 1000 0000
      1101 1101 1000 0000     1110 1011 1000 0000
      1101 1101 1000 0000     1110 1011 1000 0000
      1111 1111 1000 0000     1111 1111 1000 0000
      1111 1111 1000 0000     1101 1101 1000 0000
      0111 1111 0000 0000     0110 0011 0000 0000
      0111 1111 0000 0000     0111 1111 0000 0000
      0011 1110 0000 0000     0011 1110 0000 0000

Chaque groupe de quatre pixels est alors transformé en chiffre hexadécimal :

Plan de bits 1     Plan de bits 0
-----------------------------------

  3 E 0 0           3 E 0 0
  7 F 0 0           7 F 0 0
  F F 8 0           C 9 8 0
  F F 8 0           B E 8 0
  C 9 8 0           F F 8 0
  C 9 8 0           F F 8 0
  D D 8 0           E B 8 0
  D D 8 0           E B 8 0
  F F 8 0           F F 8 0
  F F 8 0           D D 8 0
  7 F 0 0           6 3 0 0
  7 F 0 0           7 F 0 0
  3 E 0 0           3 E 0 0

La déclaration et l'initialisation de l'image de visage auront cette allure :

USHORT chip my_image_data[]=
{
  0x3E00, /* Plan de bits 0 */
  0x7F00,
  0xC980,
  0xBE80,
  0xFF80,
  0xFF80,
  0xEB80,
  0xEB80,
  0xFF80,
  0xDD80,
  0x6300,
  0x7F00,
  0x3E00,

  0x3E00, /* Plan de bits 1 */
  0x7F00,
  0xFF80,
  0xFF80,
  0xC980,
  0xC980,
  0xDD80,
  0xDD80,
  0xFF80,
  0xFF80,
  0x7F00,
  0x7F00,
  0x3E00
};

Attention : toutes les données Image doivent être en mémoire Chip !

3.5.2 La structure Image

La structure Image ressemble à ceci :

struct Image
{
  SHORT LeftEdge, TopEdge;
  SHORT Width, Height, Depth;
  SHORT *ImageData;
  UBYTE PlanePick, PlaneOnOff;
  struct Image *NextImage;
};
  • LeftEdge : position en x de l'image.
  • TopEdge : position en y de l'image.
  • Width : la largeur réelle de l'image.
  • Height : la hauteur de l'image.
  • Depth : le nombre de plans de bits utilisées pour l'image.
  • ImageData : un pointeur sur les donnés image.
  • PlanePick : quels plans de bits de l'élément d'affichage doivent être modifiés/affectés par l'image (voir ci-dessous pour plus d'informations).
  • PlaneOnOff : ce qui doit advenir des plans de bits de l'élément d'affichage qui n'ont pas été affectés. Doivent-ils être remplis de uns ou de zéros (voir ci-dessous pour plus d'informations).
  • NextImage : un pointeur sur la prochaine structure Image si elle existe, NULL sinon.
3.5.3 PlanePick

Les avantages des champs PlanePick/PlaneOnOff sont que vous pouvez afficher l'image dans un support de n'importe quelle profondeur, afficher la même image en différentes couleurs et éliminer les gaspillages de mémoire inutiles quand vous affichez des images en couleurs.

PlanePick indique à Intuition quels plans de bits de l'affichage doivent être affecté à l'image. Pour chaque plan sélectionné, le prochain plan de bits de l'image y est affiché. Par exemple si vous mettez PlanePick à 1, le plan de bits 0 sera affecté. Si vous affichez alors l'image de la flèche, la flèche sera dessinée dans la couleur 1 sur un fond de couleur 0.

Si au contraire vous aviez mis PlanePick à 2, le plan de bits 1 aurait été affecté, ce qui aurait donné une flèche dans la couleur 2, sur un fond de couleur 0 encore une fois.

Si votre image est constituée de plusieurs plans de bits, le plan sélectionné le plus bas est affecté au plus bas plan de bits et ainsi de suite. Si on prend l'exemple de notre image de visage et que vous voulez la dessiner avec les couleurs 3, 2, 1 et 0, vous devez affecter les plans de bits 0 et 1 de l'affichage. Vous mettrez alors PlanePick à 3, voir la table :

Plan de bits à affecter   PlanePick
--------------------------------

Aucun                     0000 = 0
Plan 0                    0001 = 1
Plan 1                    0010 = 2
Plan 1 et 0               0011 = 3
Plan 2                    0100 = 4
Plan 2 et 0               0101 = 5
Plan 2 et 1               0110 = 6
Plan 2, 1 et 0            0111 = 7
Plan 3                    1000 = 8
Plan 3 et 0               1001 = 9
Plan 3 et 1               1010 = A
et ainsi de suite...

Si vous voulez le dessiner avec les couleurs 5, 4, 1 et 0, vous devez affecter les plans de bits 2 et 0 :

(000=couleur 0, 001=couleur 1, 100=couleur 4, 101=couleur 5)
 ^^^            ^^^            ^^^            ^^^
 210            210            210            210 (plans de bits)

Vous mettriez donc PlanePick à 5 (0101).

3.5.4 PlaneOnOff

PlaneOnOff décide de ce qui doit advenir des plans de bits de l'élément d'affichage qui n'ont pas été affectés par PlanePick. Ces plans de bits doivent-ils être remplis de zéros ou de uns ?

Par exemple, si vous voulez afficher la petite flèche en couleur 5 sur un de couleur 1, les pixels doivent avoir les valeurs 0001 (couleur 1) et 0101 (couleur 5). Vous voulez que l'image affecte le plan de bits 2, PlanePick est donc mis à 4 (0100), mais vous voulez aussi que le plan de bits 0 soit rempli de 1, PlaneOnOff est donc mis à 1 (0001).

A l'aide de PlanePick et PlaneOnOff, vous pouvez même afficher des rectangles pleins sans aucune donnée Image. Il vous suffit d'initialiser Width et Height selon vos besoins, puis de mettre Depth à 0 (pas de plan de bits), PlanePick à 0000 (aucun plan de bits ne doit être utilisé) et PlaneOnOff à la couleur que vous voulez.

3.5.5 Commment utiliser la structure Image

La structure Image est utilisée pour afficher des images dans un écran ou une fenêtre, mais peut aussi servir à afficher des images liées à des Gadget, Menu ou Requête. Tout comme les autres structures graphiques d'Intuition.

Pour afficher une image dans une fenêtre ou un écran, il vous suffit d'appeler la fonction DrawImage() :
  • Synopsis : DrawImage( rast_port, image, x, y );
  • rast_port : (struct RastPort *). Pointeur sur le RastPort. Si les images doivent être dessinées dans une fenêtre et que my_window est le pointeur sur cette fenêtre, écrivez : my_window->RastPort. Si les images doivent être dessinées dans un écran et que my_screen est le pointeur sur cet écran, écrivez : my_screen->RastPort.
  • image : (struct Image *). Pointeur sur la structure Image qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés à la position en x de l'image.
  • y : (long). Nombre de lignes ajoutées à la position en y de l'image.
Un appel pour afficher une image avec la structure my_image ressemblera à ceci :

  DrawImage( my_window->RPort, &my_image, 0, 0 );

3.6 Les fonctions

Voici les trois fonctions que vous utilisez quand vous voulez afficher des lignes/caractères/images dans un RastPort (écran/fenêtre) :

DrawBorder()

Cette fonction dessine les bordures spécifiées dans un RastPort (écran/fenêtre).
  • Synopsis : DrawBorder( rast_port, border, x, y );
  • rast_port : (struct RastPort *). Pointeur sur le RastPort. Si les lignes doivent être dessinées dans une fenêtre et que my_window est le pointeur sur cette fenêtre, écrivez : my_window->RastPort. Si les lignes doivent être dessinées dans un écran et que my_screen est le pointeur sur cet écran, écrivez : my_screen->RastPort.
  • border : (struct Border *). Pointeur sur la structure Border qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés aux coordonnées en x.
  • y : (long). Nombre de lignes ajoutées aux coordonnées en y.
PrintIText()

Cette fonction écrit du texte dans un RastPort (écran/fenêtre).
  • Synopsis : PrintIText( rast_port, intui_text, x, y );
  • rast_port : (struct RastPort *). Pointeur sur le RastPort. Si le texte doit être écrit dans une fenêtre et que my_window est le pointeur sur cette fenêtre, écrivez : my_window->RastPort. Si le texte doit être écrit dans un écran et que my_screen est le pointeur sur cet écran, écrivez : my_screen->RastPort.
  • intui_text : (struct IntuiText *). Pointeur sur la structure IntuiText qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés à la position en x des caractères.
  • y : (long). Nombre de lignes ajoutées à la position en y des caractères.
DrawImage()

Cette fonction dessine les images spécifiées dans un RastPort (écran/fenêtre).
  • Synopsis : DrawImage( rast_port, image, x, y );
  • rast_port : (struct RastPort *). Pointeur sur le RastPort. Si les images doivent être dessinées dans une fenêtre et que my_window est le pointeur sur cette fenêtre, écrivez : my_window->RastPort. Si les images doivent être dessinées dans un écran et que my_screen est le pointeur sur cet écran, écrivez : my_screen->RastPort.
  • image : (struct Image *). Pointeur sur la structure Image qui a été initialisée selon vos besoins.
  • x : (long). Nombre de pixels ajoutés à la position en x de l'image.
  • y : (long). Nombre de lignes ajoutées à la position en y de l'image.
3.7 Exemples

Voici des exemples (dans le répertoire "Amiga_C_Manual/3.Graphismes") de dessin de lignes (Border), d'affichage de texte (IntuiText) et d'images (Image) :

Exemple 1

Ce programme ouvre une fenêtre normale liée à l'écran Workbench. Il dessine alors une ligne bizarre à l'aide de la structure Border d'Intuition.

Exemple 2

Ce programme ouvre une fenêtre normale liée à l'écran Workbench. Il dessine alors deux rectangles avec des couleurs différentes. Ceci vous montre comment lier des structures Border les unes aux autres pour obtenir l'effet souhaité.

Exemple 3

Ce programme ouvre une fenêtre normale liée à l'écran Workbench. Il affiche alors une chaîne de texte à l'aide de la structure IntuiText d'Intuition.

Exemple 4

Comme l'exemple 3 mais le texte est affiché en caractères italiques soulignés.

Exemple 5

Ce programme ouvre une fenêtre normale liée à l'écran Workbench. Il y dessine alors la jolie petite flèche dont nous avons tant parlé.

Exemple 6

Comme l'exemple 5 mais la flèche est dessinée plusieurs fois en différentes couleurs. Ceci montre comment PlanePick/PlaneOnOff fonctionnent.

Exemple 7

Ce programme ouvre une fenêtre normale liée à l'écran Workbench. Il dessine alors le joli visage en quatre couleurs décrit dans le paragraphe "3.5 Les images".

Exemple 8

Ce programme ouvre une fenêtre normale liée à un écran personnalisé (Custom Screen) en 16 couleurs. Dans cette fenêtre sera alors dessiné le fameux logo Amiga.


[Retour en haut] / [Retour aux articles] [Chapitre précédent : les fenêtres] / [Chapitre suivant : les gadgets]