Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 15:14  

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 gadgets
(Article écrit par Anders Bjerin et extrait d'Amiga C Manual - mars 1990)


Note : traduction par Serge Hammouche.

4. Les gadgets

4.1 Introduction

Dans ce chapitre, nous verrons comment l'utilisateur peut communiquer avec l'application. Tous les programmes qui utilisent Intuition devraient - si possible - être contrôlés par la souris, du moment que celle-ci est le périphérique d'entrée qu'on utilise généralement. Ici, les gadgets d'Intuition auront un grand rôle à jouer.

Un gadget peut être un "bouton" sur lequel l'utilisateur pourra cliquer mais cela peut être aussi un petit poussoir qu'on pourra tirer (comme la tirette du volume sur un poste de radio). Un gadget peut aussi être une boîte où l'utilisateur pourra entrer une chaîne de texte ou un nombre. L'avantage d'employer les gadgets est presque incalculable. Ceux-ci sont très bien gérés par Intuition, ce qui signifie que non seulement votre programme n'a presque rien à faire mais qu'il a en plus une interface utilisateur externe à la fois facile à comprendre et à utiliser.

4.2 Les différents types de gadgets

Il existe deux sortes de gadgets : les gadgets système, dont nous avons déjà parlés dans le chapitre 2.3 Les gadgets système et les gadgets utilisateur. Dans chaque fenêtre, les gadgets du Système se ressemblent et sont toujours placés aux mêmes endroits. Les gadgets utilisateur, par contre, peuvent être placés là où vous le souhaitez et c'est vous qui décidez de leur aspect.

4.3 Les gadgets utilisateur

Il existe quatre types différents de gadgets utilisateur :
  • Gadgets booléens : bouton allumé/éteint (vrai/faux).
  • Gadgets proportionnels : un petit poussoir que l'on peut déplacer à l'intérieur d'un cadre donné.
  • Gadgets de chaîne : un gadget qui permet à l'utilisateur d'entrer une chaîne de caractères.
  • Gadgets entiers : même chose que les gadgets de chaîne si l'on excepte que l'utilisateur pourra entrer seulement un chiffre entier.
4.3.1 Les graphismes pour les gadgets utilisateur

Vous pouvez représenter le gadget par l'intermédiaire des utilitaires graphiques de haut niveau qui sont gérés par Intuition (Cf. pour plus d'informations le chapitre 3, Les graphismes). Vous pouvez représenter le gadget par l'intermédiaire de la structure Render ou de la structure Image. Vous pouvez même avoir une représentation différente, en surbrillance, quand le gadget est activé.

Naturellement, il est possible de créer des gadgets qui n'ont aucune représentation. Le gadget Drag (gadget système) en est un excellent exemple.

4.3.2 Le positionnement

A l'affichage, vous pouvez positionner le gadget où vous voudrez. Habituellement, on positionne le gadget est par rapport au coin supérieur gauche de l'élément où il est affiché (fenêtre, requête, etc.). Si vous le souhaitez, vous pourrez positionner le gadget par rapport à d'autres côtés, au lieu du coin supérieur gauche.

Si vous voulez positionner le gadget à 10 et 20 pixels à partir du coin supérieur gauche, vous devrez fixer LeftEdge à 10 et TopEdge à 20 (LeftEdge, etc. sont des éléments de la structure Gadget qui sera décrite ultérieurement dans ce chapitre).

D'autre part, si vous souhaitez que le gadget soit toujours positionné 20 pixels au-dessus du bord inférieur de la fenêtre et 10 pixels à gauche du bord droit de la fenêtre, vous fixerez LeftEdge à -10 et TopEdge à -20, en même temps que vous mettrez à 1 les drapeaux GRELRIGHT et GRELBOTTOM (nous en dirons un peu plus à ce sujet, ultérieurement dans ce chapitre).

4.3.3 La taille

C'est vous qui décidez de la largeur et de la hauteur du gadget (la boîte de sélection du gadget), en fixant comme vous le souhaitez les variables Width et Height.

Si vous fixez Height à 25, la hauteur du gadget sera de 25 pixels.

D'autre part, si vous fixez Height à -25 et mettez à 1 le drapeau GRELHEIGHT, le gadget aura toujours 50 pixels de moins que le cadre qui l'entoure.

4.4 Initialisation d'un gadget utilisateur

Si vous souhaitez utiliser un gadget utilisateur, vous devrez déclarer et initialiser une structure Gadget qui ressemble à ceci :

struct Gadget
{
  struct Gadget *NextGadget;
  SHORT LeftEdge, TopEdge, Width, Height;
  USHORT Flags;
  USHORT Activation;
  USHORT GadgetType;
  APTR GadgetRender;
  APTR SelectRender;
  struct IntuiText *GadgetText;
  LONG MutualExclude;
  APTR SpecialInfo;
  USHORT GadgetID;
  APTR UserData;
}
  • NextGadget : pointeur sur le prochain gadget dans la liste, s'il y en a une, autrement NULL.
  • LeftEdge, TopEdge : position de la boîte de sélection du gadget par rapport à l'élément où elle est affichée.
  • Width, Height : vous devrez mettre à 1 l'un des quatre drapeaux (flags) de surbrillance (le gadget est en surbrillance quand il est sélectionné) :

    • GADGHCOMP : inverse les couleurs de tous les pixels dans la boîte de sélection du gadget.
    • GADGHBOX : trace un cadre autour de la boîte de sélection du gadget.
    • GADGHIMAGE : affiche une autre image ou une autre bordure.
    • GADGHNONE : pas de surbrillance.

      Si le gadget doit être représenté en tant qu'image, mettez à 1 le drapeau GADGHIMAGE, autrement mettez ce drapeau à 0 (le représenter ou ne pas le représenter avec une structure Border).

      Si vous souhaitez que le positionnement et/ou la taille du gadget soient relatives à la taille de l'élément d'affichage, mettez à 1 les drapeaux nécessaires :

    • GRELBOTTOM : TopEdge est utilisé comme une position relative à la partie inférieure de l'élément d'affichage, au lieu d'être une position relative à la partie supérieure de l'élément d'affichage.
    • GRELRIGHT : LeftEdge est utilisé comme une position relative au bord droit de l'élément d'affichage, au lieu d'être une position relative au bord gauche de l'élément d'affichage.
    • GRELWIDTH : la largeur précise une incrémentation par rapport à la largeur de l'élément d'affichage, au lieu de préciser la largeur absolue du gadget.
    • GRELHEIGHT : la hauteur précise une incrémentation par rapport à la hauteur de l'élément d'affichage, au lieu de préciser la hauteur absolue du gadget.

      Si le gadget est un gadget d'inversion d'état (Cf. les drapeaux de sélection), vous pourrez mettre à 1 le drapeau SELECTED, et le gadget sera activé et apparaîtra en surbrillance lorsqu'il est affiché. Si ce drapeau n'est pas mis à 1, le gadget ne sera pas activé et n'apparaîtra pas en surbrillance. Vous pouvez aussi regarder ce champ pour voir si le drapeau de SELECTED est ou n'est pas mis à 1. S'il est à 1, le gadget est activé, autrement il ne l'est pas.

      Si vous voulez que le gadget soit désactivé lorsqu'il est affiché, vous mettrez à 1 le drapeau GADGDISABLED. Plus tard, votre programme pourra charger cet état en faisant appel aux fonctions OnGadget() (active le gadget) et OffGadget() (désactive le gadget).

  • Activation : mettre les drapeaux à 1 selon l'effet souhaité (nous en dirons un peu plus à ce sujet plus loin dans ce chapitre...) :

    • GADGIMMEDIATE : si vous souhaitez que le programme sache immédiatement si l'utilisateur a activé un gadget, vous mettrez ce drapeau à 1.
    • RELVERIFY : si vous souhaitez que le programme reçoive un message lorsque l'utilisateur relâche le gadget et que le pointeur est encore à l'intérieur de la boîte de sélection, vous mettrez ce drapeau à 1.
    • FOLLOWMOUSE : mettez ce drapeau à 1 si vous souhaitez que le programme reçoive la position de la souris chaque fois que l'utilisateur déplace la souris, pendant que le gadget est activé.
    • TOGGLESELECT : chaque fois que l'utilisateur active un gadget, son état (allumé/éteint), ainsi que son image, sont commutés. Plus tard, le programme pourra vérifier dans quel état se trouve le gadget, en regardant l'attribut SELECTED dans le champ Flags.
    • BOOLEXTEND : mettez ce drapeau à 1 si vous avez rattaché une structure BoolInfo au gadget.

      Si votre gadget est relié à une fenêtre, vous pouvez utiliser les drapeaux suivants pour changer la taille des bords de la fenêtre (à ce moment vous pourrez y placer le gadget) :

    • RIGHTBORDER : la largeur du bord droit de la fenêtre est calculée par l'intermédiaire de la position et de la largeur du gadget.
    • LEFTBORDER : la hauteur du bord gauche de la fenêtre est calculée par l'intermédiaire de la position et de la hauteur du gadget.
    • TOPBORDER : la hauteur du bord supérieur de la fenêtre est calculée par l'intermédiaire de la position et de la hauteur du gadget.
    • BOTTOMBORDER : la hauteur du bord inférieur de la fenêtre est calculée par l'intermédiaire de la position et de la hauteur du gadget.

      Si le gadget est relié à une requête, vous pouvez mettre à 1 le drapeau ENDGADGET. La requête disparaîtra seulement si on active un gadget dont le drapeau ENDGADGET a été mis (Cf. le chapitre 5 - Les requêtes pour plus d'informations sur les gadgets reliés aux requêtes).

      Si l'on a affaire à un gadget de chaîne ou entier, Intuition s'occupera seulement des drapeaux suivants :

    • STRINGRIGHT : mettez ce drapeau à 1 si vous souhaitez que les caractères de la chaîne soient justifiés à droite (par défaut, ils sont justifiés à gauche).
    • LONGINT : mettez ce drapeau à 1 si vous souhaitez que l'utilisateur puisse entrer une valeur entière sur 32 bits signée.
    • ALTKEYMAP : mettez ce drapeau à 1 si vous souhaitez utiliser une autre table de clavier. Souvenez-vous de fixer le pointeur AltKeyMap dans la structure StringInfo comme pointeur sur la table de clavier.

  • GadgetType : vous devrez mettre à 1 l'un des trois drapeaux suivants :

    • BOOLGADGET : mettez ce drapeau à 1 si vous souhaitez avoir un gadget booléen.
    • STRGADGET : mettez ce drapeau à 1 si vous souhaitez avoir un gadget de chaîne/entier. Si vous souhaitez un gadget entier, vous devrez aussi mettre à 1 le drapeau LONGINT du mot Activation.
    • PROPGADGET : mettez ce drapeau à 1 si vous souhaitez avoir un gadget proportionnel.

      Les deux drapeaux suivants sont indispensables seulement pour les gadgets reliés aux fenêtres Gimmezerozero et aux requêtes.

    • GZZGADGET : si le gadget est relié à une fenêtre Gimmezerozero et vous avez mis ce drapeau à 1, le gadget sera placé à l'extérieur de la fenêtre et ne détruira pas d'éventuels dessins, etc. à l'intérieur de la fenêtre.
    • REQGADGET : mettez ce drapeau à 1 si le gadget est relié à une requête.

  • GadgetRender : un pointeur sur une structure Image ou Render (Cf. le chapitre 3 - Les graphismes, pour plus d'informations), qui sera employé pour la représentation du gadget (si vous prévoyez un pointeur pour une structure Image, vous devrez fixer la variable des drapeaux dans GADGHIMAGE). Fixez-le à NULL si vous ne souhaitez pas mettre des graphismes dans le gadget.
  • SelectRender : un pointeur sur une autre structure Image ou Border, qui sera employée lorsque le gadget sera mis en surbrillance. Souvenez-vous qu'il faudra mettre à 1 l'attribut de la variable de drapeaux si vous souhaitez utiliser une autre Image ou un autre Border (GadgetRender et SelectRender devront pointer sur des données du même type. Si vous avez précisé que vous voulez employer une Image pour GadgetRender (GADGHIMAGE), SelectRender devra aussi pointer sur une structure d'Image).
  • GadgetText : un pointeur sur une structure IntuiText (Cf. le chapitre 3 - Les graphismes, pour plus d'informations) qui est utilisé pour "imprimer" un texte dans un gadget. Mettez NULL si vous ne voulez pas relier un texte au gadget.
  • MutualExclude : ce champ représente le premier des 32 gadgets de la liste. Si vous sélectionnez ce gadget, tous les gadgets spécifiés dans le champ MutualExclude sont automatiquement désactivés. Par exemple si vous voulez que les gadgets numéros 0, 2, 5 et 8 soient désactivés (mutuellement exclus), lorsque vous sélectionnez ce gadget, il faudra fixer le champ MutualExclude à 293 (293 (décimal) == 100100101 (binaire)). Souvenez-vous que cette exclusion mutuelle fonctionne seulement avec les gadgets d'inversion d'état.
  • SpecialInfo : si le gadget est de type proportionnel, vous devrez mettre ici, pour Intuition, un pointeur sur une structure PropInfo, ou si le gadget est de type chaîne de caractères (entier), vous devrez mettre, pour Intuition, un pointeur sur une structure StringInfo. Et si le gadget est de type booléen, vous pourrez le relier à une structure BoolInfo, qui créera un masque pour la boîte de sélection du gadget (Cf. ci-dessous pour plus d'informations).
  • GadgetID : cette variable est pour votre usage personnel. Intuition ignore ce champ.
  • UserData : un pointeur sur une quelconque structure que vous voudriez relier au gadget. Intuition ignore ce champ.
4.5 Les gadgets booléens

Si vous souhaitez utiliser un gadget booléen, vous devrez déclarer et initialiser une structure Gadget qui ressemblera à ceci :

struct my_gadget=
{
  NULL,          /* NextGadget, pas d'autre gadget dans la liste. */
  40,            /* LeftEdge, position X égale à 40 pixels. */
  20,            /* TopEdge, position Y égale à 20 pixels. */
  60,            /* Width, largeur 60 pixels. */
  20,            /* Height, hauteur 20 pixels. */
  GADGHCOMP,     /* Flags, si le gadget est en surbrillance, */
                 /* il sera représenté avec les couleurs     */
                 /* complémentaires suivantes:               */
                 /* (La couleur 0 (00)  deviendra     3 (11) */
                 /* (La couleur 1 (01)    - " -       2 (10) */
                 /* (la couleur 2 (10)    - " -       1 (01) */
                 /* (La couleur 3 (11)    - " -       0 (00) */
  GADGIMMEDIATE| /* Activation, notre programme recevra un   */
  RELVERIFY,     /* message si l'utilisateur sélectionne ce */
                 /* gadget et s'il le relâche.               */
  BOOLGADGET,    /* GadgetType, gadget de type booléen.  */
  &my_border,    /* GadgetRender, un pointeur sur notre  */
                 /* structure Border.                    */
  NULL,          /* SelectRender, NULL étant donné que    */
                 /* nous n'avons pas prévu d'autre image  */
                 /* pour ce gadget (par contre nous avons */
                 /* prévu des couleurs complémentaires.   */
  &my_text,      /* GadgetText, un pointeur sur notre     */
                 /* structure IntuiText.                  */
  NULL,          /* MutualExclude, pas d'exclusion mutuelle. */
  NULL,          /* SpecialInfo, pas de BoolInfo reliée au gadget. */
  0,             /* GadgetID, pas de numéro d'identification. */
  NULL           /* UserData, pas de données utilisateur reliées */
                 /* à ce gadget. */
};

Il est possible de relier un masque à un gadget booléen. Dans ce cas, le gadget sera sélectionné seulement quand l'utilisateur clique à l'intérieur de la surface sélectionnée (masquée) et seule cette surface sera mise en surbrillance. Si vous souhaitez relier un masque à un gadget booléen, vous devrez, en même temps, déclarer et initialiser une structure BoolInfo avec son masque.

La structure BoolInfo ressemble à ceci :

struct BoolInfo
{
 USHORT Flags;
 UWORD *Mask;
 ULONG Reserved;
};
  • Flags : pour l'instant il n'y a qu'un drapeau : BOOLMASK.
  • Mask : pointeur sur un masque binaire (la largeur et la hauteur du masque devront être égales à la largeur et à la hauteur de la boîte de sélection).
  • Reserved : ce champ est réservé et devra être mis à 0.
Un masque binaire est bâti comme un plan d'images. Seules les parties sélectionnées (les 1) du masque seront sensibles et seront mises en surbrillance.

Le masque d'un gadget d'une largeur de 16 pixels et d'une hauteur de 8 pixels pourrait ressembler à ceci (seule la partie interne de la boîte de sélection sera sensible et sera mise en surbrillance) :

Masque              Mots de 16 bits en memoire     Hexad&cimal
--------------------------------------------------------------

0000001111000000    0000 0011 1100 0000            03C0
0000111111110000    0000 1111 1111 0000            0FF0
0011111111111100    0011 1111 1111 1100            3FFC
1111111111111111    1111 1111 1111 1111            FFFF
1111111111111111    1111 1111 1111 1111            FFFF
0011111111111100    0011 1111 1111 1100            3FFC
0000111111110000    0000 1111 1111 0000            0FF0
0000001111000000    0000 0011 1100 0000            03C0


Dans ce cas, le masque sera déclaré et initialisé comme ceci :

UWORD my_mask[]=
{
  0x03C0,
  0x0FF0,
  0x3FFC,
  0xFFFF,
  0xFFFF,
  0x3FFC,
  0x0FF0,
  0x03C0
};

Cf. l'exemple 6 pour plus d'informations sur la structure BoolInfo.

4.6 Les gadgets de chaîne/entiers

. La déclaration des gadgets de chaîne et entiers est un peu plus compliquée car vous devrez prévoir une structure Gadget avec une structure StringInfo. Cependant, les gadgets de chaîne et entiers permettent à l'utilisateur d'entrer des chaînes de caractères ou un nombre entier sans que vous ayez trop d'efforts à fournir. Intuition prend en charge la plupart du travail et vous aurez presque seulement à décider de la longueur et de l'emplacement du gadget de chaîne.

4.6.1 La structure StringInfo

La structure StringInfo ressemble à ceci :

struct StringInfo
{
  UBYTE *Buffer;
  UBYTE *UndoBuffer;
  SHORT BufferPosition;
  SHORT MaxChars;
  SHORT DispPos;
  SHORT UndoPos;
  SHORT NumChars;
  SHORT DispCount;
  SHORT CLeft, CTop;
  struct Layer *LayerPtr;
  LONG LongInt;
  struct KeyMap *AltKeyMap;
};
  • Buffer : i un pointeur sur un texte qui se termine par NULL.
  • UndoBuffer : Intuition utilise un pointeur sur un texte qui se termine par NULL pour retrouver un ancien texte. Au minimum, la longueur de ce texte devra être égale à celle du texte qui se trouve dans le tampon. Quand l'utilisateur sélectionne ce gadget, Intuition fait une copie du texte qui se trouve dans le Tampon, texte qui sera recopié si l'utilisateur appuie sur Amiga droite + A. Du moment que seuls une chaîne ou un entier peuvent être actifs en même temps, différents gadgets de chaîne/entiers pourront utiliser la même chaîne pour retrouver l'état antérieur de la chaîne.
  • MaxChars : nombre maximal de caractères qu'on peut entrer (nombre de caractères dans le tampon plus le caractère NULL '\0').
  • BufferPos : position du curseur dans la chaîne qui se trouve dans le tampon.
  • DispPos : position du premier caractère qui est affiché.
Les variables suivantes sont initialisées et gérées par Intuition :
  • UndoPos : position du curseur dans l'ancien texte.
  • NumChars : nombre actuel de caractères qui sont dans le tampon.
  • DispCount : nombre actuel de caractères visibles dans le conteneur.
  • CLeft, CTop : décalalge horizontal et vertical du conteneur.
  • LongInt : s'il s'agit d'un gadget entier, c'est ici que vous pourrez examiner la valeur entrée par l'utilisateur.
  • AltKeyMap : un pointeur sur une autre table de clavier (ne pas oublier de mettre à 1 le drapeau ALTKEYMAP dans le champ Activation).
4.6.2 Initialisation d'un gadget de chaîne/entier

Voici un exemple de la manière dont on peut initialiser un gadget de chaîne :

UBYTE my_buffer[50];
UBYTE my_undo_buffer[50];

struct StringInfo my_string_info=
{
  my_buffer,       /* Tampon, pointeur sur texte qui se termine par NULL  */
  my_undo_buffer,  /* UndoBuffer, pointeur sur un texte qui se termine    */
                   /* par NULL (ne pas oublier que la longueur de         */
                   /* my_buffer doit être égale à celle de &my_buffer[0]) */
  0,               /* BufferPos, position initiale du curseur. */
  50,              /* MaxChars, 49 caractères plus NULL-signe. */
  0,               /* DispPos, le premier caractère de la chaîne doit */
                   /* être le premier caractère lors de l'affichage.  */

  /* Intuition initialise et gère les variables suivantes : */

  0,               /* UndoPos */
  0,               /* NumChars */
  0,               /* DispCount */
  0, 0,            /* CLeft, CTop */
  NULL,            /* LayerPtr */
  NULL,            /* LongInt */
  NULL,            /* AltKeyMap */
};

struct Gadget my_gadget=
{
  NULL,           /* NextGadget, pas d'autre gadget dans la liste.        */
  68,             /* LeftEdge, 68 pixels dans le sens des X.              */
  30,             /* TopEdge, 30 pixels dans le sens des Y.               */
  198,            /* Width, largeur 198 pixels.                           */
  8,              /* Height, hauteur 8 pixels.                            */
  GADGHCOMP,      /* Flags, dessine la boîte de sélection dans la couleur */
                  /* complémentaire.  Note : actuellement c'est seulement */
                  /* le curseur qui est dessiné dans la couleur           */
                  /* complémentaire (jaune). Si vous mettez à 1 le        */
                  /* drapeau GADGHNONE, le curseur ne sera pas mis en     */
                  /* surbrillance et, par conséquent, l'utilisateur ne    */
                  /* pourra pas le voir.                                  */
  GADGIMMEDIATE|  /* Activation, notre programme recevra un               */
  RELVERIFY,      /* message quand l'utilisateur aura sélectionné         */
                  /* ce gadget et quand il l'aura relâché.                */
  STRGADGET,      /* GadgetType, un gadget de type chaîne.                */
  &my_border,     /* GadgetRender, un pointeur sur notre                  */
                  /* structure Border.                                    */
  NULL,           /* SelectRender, NULL car nous n'employons pas          */
                  /* un gadget avec une autre image.                      */
  &my_text,       /* GadgetText, un pointeur sur notre                    */
                  /* structure IntuiText.                                 */
  NULL,           /* MutualExclude, pas d'exclusion mutuelle.             */
  &my_string_info,/* SpecialInfo, un pointeur sur une                     */
                  /* structure StringInfo.                                */
  0,              /* GadgetID, pas de numéro d'identification.            */
  NULL            /* UserData, pas de données personnelles                */
                  /* reliées à ce gadget.                                 */
};

Lors de la déclaration et de l'initialisation, la seule différence existante entre un gadget de chaîne et un gadget entier est que, dans le deuxième cas, vous devrez aussi :
  1. Mettre à 1 le drapeau LONGINT dans le champ Activation.
  2. Copier une chaîne entière dans le texte du tampon. Exemple : strcpy( my_buffer, "0" );
4.6.3 Utilisation d'un gadget de chaîne/entier

Une fois que vous aurez déclaré et initialisé les structures appropriées, Intuition s'occupe de tout. Lors de l'entrée d'un texte l'utilisateur pourra même se servir de certaines touches spéciales :
  • <- : déplace le curseur vers la gauche.
  • -> : déplace le curseur vers la droite.
  • Shift + <- : déplace le curseur au début du texte.
  • Shift + -> : déplace le curseur à la fin du texte.
  • Retour arrière : efface les caractères à gauche du curseur.
  • Suppr : efface les caractères sous le curseur.
  • Amiga droite + A : rétablit le texte antérieur.
  • Amiga droite + X : efface le contenu du tampon.
  • Entrée : met fin à l'entrée du texte. Si nous avons mis à 1 le drapeau RELVERIFY dans le champ Activation, nous recevrons un message qui nous dira que l'utilisateur a fini d'entrer son texte.
4.7 Les gadgets proportionnels

De manière sommaire, un gadget proportionnel est un poussoir qu'on pourra déplacer horizontalement, verticalement ou des deux manières à la fois, à l'intérieur d'un conteneur. Il peut ressembler au bouton de réglage du volume d'un poste de radio ou il peut être employé pour montrer à l'utilisateur combien de données existent dans un fichier, etc.

4.7.1 La structure PropInfo

La structure PropInfo ressemble à ceci :

struct PropInfo
{
  USHORT Flags;
  USHORT HorizPot;
  USHORT VertPot;
  USHORT HorizBody;
  USHORT VertBody;
  USHORT CWidth;
  USHORT CHeight;
  USHORT HPotRes, VPotRes;
  USHORT LeftBorder;
  USHORT TopBorder;
};
  • Flags : normalement vous mettrez à 1 l'un ou l'autre des deux attributs suivants :
    • FREEHORIZ : mettez cet attribut à 1 si vous souhaitez que l'utilisateur puisse déplacer le poussoir horizontalement.
    • FREEVERT : mettez cet attribut à 1 si vous souhaitez que l'utilisateur puisse déplacer le poussoir verticalement.
    • AUTOKNOB : mettez cet attribut à 1 si vous souhaitez que la taille du poussoir soit contrôlée par Intuition (HorizBody et VertBody affectent la taille d'Autoknob). Si vous voulez utiliser l'Autoknob d'Intuition, vous devrez fournir dans GadgetRender un pointeur sur une structure Image (vous n'aurez pas à initialiser la structure Image car Intuition s'en charge). D'un autre côté, si vous préférez employer un poussoir ayant un aspect personnalisé, vous devrez mettre dans GadgetRender un pointeur sur votre structure Image, que vous devrez à son tour initialiser.
    • PROPBORDERLESS : mettez cet attribut à 1 si vous ne voulez pas de bord autour du conteneur.
    • KNOBHIT : ce drapeau est mis à 1 par Intuition si le gadget est sélectionné.
  • HorizPot : cette variable contient la valeur proportionnelle courante (position horizontale) du poussoir. Si l'utilisateur a déplacé le poussoir de 25% sur la droite, HorizPot sera égal à 25% de MAXPOT (0xFFFF) (0xFFFF * 0,25 = 0x3FFF).
  • VertPot : même chose que pour HorizPot mais il s'agit ici de la valeur proportionnelle courante (position verticale) du poussoir.
  • HorizBody : indique de combien variera HorizPot, chaque fois que l'utilisateur clique à l'intérieur du conteneur. Si l'intensité d'une mélodie se situait entre 0 et 63 (64 pas), HorizPot varierait à chaque fois d'1/64. Cependant, on devra initialiser HorizBody à 1/64 * MAXBODY (0xFFFF) == 3FF. HorizBody indique aussi combien de données pourra voir/utiliser intégralement l'utilisateur. Par exemple, si vous avez une liste de 32 noms de fichiers et que l'utilisateur ne peut en voir que 8 à la fois (25%), le poussoir (AUTOKNOB) devra remplir 25% du conteneur. Dans ce cas, on initialisera HorizBody à MAXBODY * 8 / 32 (25% de 0xFFFF) == 3FFFF.
  • VertBody : même chose que pour HorizBody mais ce paramètre affecte VertPot et la taille verticale du poussoir (AUTOKNOB).
Les variables suivantes sont initialisées et gérées par Intuition :
  • CWidth : largeur du conteneur.
  • CHeight : hauteur du conteneur.
  • HPotRes, VPotRes : le pas absolu : horizontal et vertical.
  • LeftBorder : limite du bord gauche du conteneur.
  • TopBorder : limite du bord supérieur du conteneur.
4.7.2 L'initialisation d'un gadget proportionnel

Voici un exemple de la manière dont vous pourrez initialiser un gadget proportionnel, qu'on pourra utiliser, par exemple, pour faire varier le volume d'une mélodie (64 pas) :

/* Pour le poussoir, nous devrons déclarer une structure d'image    */
/* mais du moment qu'Intuition s'occupe de la taille, etc. du        */
/* poussoir nous ne devrons pas initialiser la structure d'image :   */

struct Image my_image;

struct PropInfo my_prop_info=
{
  FREEHORIZ|      /* Flags, on devra pouvoir déplacer le poussoir    */
  AUTOKNOB,       /* horizontalement et Intuition prendra en         */
                  /* charge l'image du poussoir.                     */
  0,              /* HorizPot, position du poussoir au démarrage.    */
  0,              /* VertPot, 0 étant donné que nous ne déplacerons  */
                  /* pas le poussoir verticalement.                  */
  MAXBODY * 1/64, /* HorizBody, 64 pas.                              */
  0,              /* VertBody, 0 étant donné que nous ne déplacerons */
                  /* pas le poussoir verticalement.                  */

  /* Les variables ci-dessous sont initialisées                      */
  /* et gérées par Intuition :                                       */

  0,              /* CWidth */
  0,              /* CHeight */
  0, 0,           /* HPotRes, VPotRes */
  0,              /* LeftBorder */
  0               /* TopBorder */
};

struct Gadget my_gadget=
{
  NULL,            /* NextGadget, pas d'autre gadget.                */
  80,              /* LeftEdge, 80 pixels dans le sens des X.        */
  30,              /* TopEdge, 30 pixels dans le sens des Y.         */
  200,             /* Width, largeur 200 pixels.                     */
  12,              /* Height, hauteur 12 pixels.                     */
  GADGHCOMP,       /* Flags, pas de surbrillance.                    */
  GADGIMMEDIATE|   /* Activation, notre programme recevra un         */
  RELVERIFY,       /* message quand l'utilisateur aura sélectionné   */
                   /* ce gadget et quand il l'aura relâché.          */
  PROPGADGET,      /* GadgetType, gadget de type proportionnel.      */
  &my_image,       /* GadgetRender, un pointeur sur notre structure  */
                   /* d'image (Intuition prendra en charge l'image   */
                   /* du poussoir. Cf. chapitre 3, Les graphismes,   */
                   /* pour plus d'informations sur les images).      */
  NULL,            /* SelectRender, NULL étant donné que             */
                   /* nous ne dotons pas le gadget d'une autre       */
                   /* image.                                         */
  &my_text,        /* GadgetText, pointeur sur une structure         */
                   /* IntuiText.                                     */
  NULL,            /* MutualExclude, pas d'exclusion mutuelle.       */
  &my_prop_info,   /* SpecialInfo, pointeur sur une structure        */
                   /* PropInfo                                       */
  0,               /* GadgetID, pas de numéro d'identification.      */
  NULL             /* UserData, pas de données utilisateur reliées   */
                   /* à ce gadget.                                   */
};

4.8 Le contrôle des gadgets

Dès que vous aurez choisi les gadgets dont vous allez vous servir et leur forme, il sera temps de décider du type d'information qu'ils devront faire parvenir au programme. Vous devrez décider s'ils doivent envoyer un message lorsque l'utilisateur les sélectionne ou lorsqu'il les déselectionne, etc. Tout ce travail de manipulation des entrées peut être facilement réalisé par l'intermédiaire du système IDCMP d'Intuition. IDCMP signifie système des ports de message de communications directes d'Intuition. Le nom est difficile, mais l'usage du système est très simple.

Le système IDCMP est expliqué aussi, plus en détail, au chapitre 8 - IDCMP.

Si vous voulez utiliser le système IDCMP, vous n'aurez qu'à suivre les étapes suivantes :
  1. Choisissez les événements que votre gadget devra prendre en compte. Vous pourrez le faire en mettant à 1 les drapeaux appropriés dans le champ Activation de la structure Gadget :
    • GADGIMMEDIATE : mettez ce drapeau à 1 si vous souhaitez que votre programme reçoive immédiatement un message dès que l'utilisateur sélectionne le gadget.
    • RELVERIFY : mettez ce drapeau à 1 si vous souhaitez que votre programme reçoive un message dès que l'utilisateur relâche le gadget (pendant qu'il continue à le pointer). Si l'utilisateur relâche le gadget après avoir sorti le pointeur de la boîte de sélection, le programme ne recevra aucun message.
    • FOLLOWMOUSE : mettez ce drapeau à 1 si vous souhaitez que votre programme reçoive un message à chaque fois qu'on déplace la souris pendant que le gadget est sélectionné.
  2. Si les gadgets sont reliés à une fenêtre, vous devrez informer Intuition sur les messages qui doivent lui parvenir. Vous pourrez le faire en mettant à 1 les drapeaux appropriés dans le champ IDCMPFlags de la structure NewWindow :
    • GADGETDOWN : si un gadget relié à une fenêtre a le drapeau GADGIMMEDIATE mis à 1, vous devrez mettre à 1 le drapeau GADGETDOWN.
    • GADGETUP : si un gadget relié à une fenêtre a le drapeau RELVERIFY mis à 1, vous devrez mettre à 1 le drapeau GADGETUP.
    • MOUSEMOUVE : si un gadget relié à une fenêtre a le drapeau FOLLOWMOUSE mis à 1, vous devrez mettre à 1 le drapeau MOUSEMOUVE.
    • CLOSEWINDOW : si vous avez relié à votre fenêtre le gadget de fermeture (gadget système), vous pourrez mettre à 1 cet attribut et votre programme recevra un message quand l'utilisateur aura sélectionné ce gadget. N'oubliez pas qu'Intuition ne ferme pas automatiquement une fenêtre quand l'utilisateur clique sur le gadget de fermeture de la fenêtre. C'est votre programme qui devra décider ce qu'il faut faire quand vous recevez un évènement du type CLOSEWINDOW (Cf. l'exemple 1).
  3. Dès que le programme tourne, il est temps de collecter et d'analyser les messages que nous envoie Intuition. L'une des manières habituelles pour se faire est celle de mettre le programme en attente [Wait()] et de le faire réagir dès réception d'un message. Alors nous essaierons de le réceptionner [GetMsg()] et ensuite (si nous y arrivons) nous tenterons de l'analyser. Dès que nous en aurons fini, nous le renverrons [ReplyMsg()], en sorte qu'Intuition puisse nous envoyer un autre message, s'il y en a un. A ce moment, nous pourrons à nouveau mettre notre programme en attente et ainsi de suite.
Quand nous recevons un message par l'intermédiaire de la fonction GetMsg(), nous recevons en réalité un pointeur sur une structure IntuiMessage ou NULL, s'il n'y a pas de message. La structure IntuiMessage ressemble à ceci :

struct IntuiMessage
{
  struct Message ExecMessage;
  ULONG Class;
  USHORT Code;
  USHORT Qualifier;
  APTR IAddress;
  SHORT MouseX, MouseY;
  ULONG Seconds, Micros;
  struct Window *IDCMPWindow;
  struct IntuiMessage *SpecialLink;
};

Cette structure sera expliquée en détail au chapitre 8 - IDCMP, donc pour l'instant vous n'avez pas besoin de vous en inquiéter outre mesure. Cependant, dans la structure, il y a deux variables qu'il nous faut comprendre. Ce sont :
  • Class : quand un message est envoyé, ce champ contient la raison pour laquelle il est envoyé. Il contient un drapeau IDCMP qui nous dit ce qui est arrivé. Par exemple, si l'utilisateur a sélectionné un gadget dont on avait mis à 1 le drapeau GADGIMMEDIATE, cette variable sera égale à GADGETDOWN.
  • IAddress : c'est un pointeur sur le gadget (ou sur quelque chose de semblable) envoyé par le message. Par exemple, si un programme reçoit un message qui nous dit qu'un gadget a été sélectionné, nous avons besoin de savoir de quel gadget il s'agit car il pourrait y avoir plusieurs gadgets reliés à la même fenêtre. Ce pointeur pointe sur le gadget sélectionné.
Voici un exemple de la manière dont un programme réceptionne les messages IDCMP :

main()
{
  /* Déclaration d'une variable où nous sauverons le */
  /* drapeau IDCMP: */
  ULONG class;
  
  /* Déclaration d'un pointeur où nous sauverons l'adresse */
  /* de l'objet (ici le gadget) qui nous envoie le message: */
  APTR address;

  /* Déclaration d'un pointeur sur une structure IntuiMessage: */
  struct IntuiMessage *my_message;

  /* ... */

  /* (Ici commence une boucle sans fin) */
  while( TRUE )
  {
    /* 1. Met notre programme en attente, pour le faire réagir en  */
    /*    premier, dès réception du message. Ne vous préoccupez    */
    /*    pas pour l'instant de toutes ces jolies choses que nous  */
    /*    mettons à l'intérieur de la fonction Wait ().            */
    /*    J'en parlerai par la suite.                              */
    
    /* Attendre tant que nous n'avons pas de message: */
    Wait( 1 << my_window->UserPort->mp_SigBit );


    /* 2. Maintenant nous avons reçu un message et donc nous  */
    /*    essaierons de le réceptionner. Si nous y arrivons,  */
    /*    la fonction GetMsg() nous retournera un pointeur    */
    /*    sur une structure IntuiMessage IntuiMessage,        */
    /*    autrement elle nous retournera NULL.                */
   
    /* Réceptionne le message: */
    my_message = GetMsg( my_window->UserPort );


    /* 3. Si nous avons réussi à réceptionner un message, nous */
    /*    sauverons certaines valeurs importantes que nous     */
    /*    pourrons utiliser par la suite.                      */
    
    if( my_message )
    {
      /* Sauve le code de la variable : */
      class = my_message->Class;
      
      /* Sauve l'adresse du gadget : */
      address = my_message->IAddress;


      /* 4. Après avoir sauvé toutes les valeurs importantes,   */
      /*    nous répondons le plus rapidement possible. Dès que */
      /*    nous avons répondu, nous ne pouvons plus utiliser   */
      /*    la structure IntuiMessage !                         */
      
      ReplyMsg( my_message );

  
      /* 5. Maintenant nous pouvons vérifier le message qui */
      /*    nous a été envoyé.                              */

      /* Vérifie quel drapeau IDCMP a été envoyé : */
      switch( class )
      {
        case GADGETDOWN: /* L'utilisateur a sélectionné un gadget : */
               
            /* Si nous voulons savoir quel gadget envoie le */
            /* message, nous devrons simplement vérifier le */
            /* pointeur d'adresse :                         */
            
            if( address == &my_first_gadget)
              /* Le gadget "my_first_gadget" a été sélectionné. */
              /* Faites-en ce que vous voudrez... */

             if( address == &my_second_gadget)
              /* Le gadget "my_second_gadget" a été sélectionné. */
              /* Faites-en ce que vous voudrez... */

            break;

        case GADGETUP: /* L'utilisateur a relâché un gadget : */
               /* Faites-en ce que vous voudrez... */
            break;

        case MOUSEMOVE: /* L'utilisateur a bougé la souris         */
                        /* pendant qu'un gadget était sélectionné. */
               /* Faites-en ce que vous voudrez... */
               break;

        case CLOSEWINDOW: /* L'utilisateur a sélectionné le gadget de */
                          /* fermeture de la fenêtre. Un temps pour   */
                          /* quitter.                                 */
               /* Faites-en ce que vous voudrez... */
               break;
      }
    }
  }

  
  /* ... */
}

4.9 Les fonctions

Voici certaines fonctions habituellement employées :

RefreshGadgets()

Cette fonction redessine tous les gadgets de la liste en commençant par le gadget indiqué. Par exemple, si vous avez ajouté ou effacé un gadget, vous devrez appeler cette fonction pour vérifier les changements apportés. D'autre part, si vous avez changé l'aspect extérieur d'un gadget ou si pour une raison quelconque l'image du gadget a disparu, vous pouvez aussi appeler cette fonction pour restaurer l'affichage.
  • Synopsis : RefreshGadgets( gadget, window, requester);
  • gadget : (struct Gadget *). Pointeur sur le gadget qu'il faut redessiner. Ce gadget, ainsi que les gadgets suivants de la liste, seront redessinés.
  • window : (struct Window *). Pointeur sur la fenêtre à laquelle sont reliés les gadgets.
  • requester : (struct Requester *). Si le gadget est relié à une requête, fixez ce pointeur pour qu'il pointe sur cette requête, autrement mettez NULL. Si ce gadget est relié à une requête, il devra s'afficher en lançant cette commande ! (Cf. le chapitre 5 - Les requêtes pour plus d'informations sur les requêtes).
AddGadget()

Cette fonction ajoute un gadget dans la liste des gadgets.
  • Synopsis : résultat = AddGadget( window, gadget, position);
  • résultat : (mot long). Position réelle du gadget, lorsqu'il est ajouté.
  • window : (struct Window *). Pointeur sur la fenêtre où le gadget devra être ajouté.
  • gadget : (struct Gadget *). Pointeur sur le gadget qui devra être ajouté.
  • position : (mot long). Position dans la liste des gadgets (cela commence à zéro). Par exemple : 0 -> Devant tous les autres gadgets. 1 -> Après le premier gadget mais devant le second. Si l'on donne une valeur trop élevée (ou -1), le gadget sera placé en fin de liste.
Important : après avoir ajouté les gadgets dont vous avez besoin dans votre programme, il vous faudra appeler la fonction RefreshGadgets() pour contrôler les changements effectués. Vous pouvez ajouter (ou enlever) plusieurs gadgets mais vous devrez appeler cette fonction dès que vous aurez terminé.

RemoveGadget()

Cette fonction enlève un gadget de la liste :
  • Synopsis : résultat = RemoveGadget(window, gadget );
  • résultat : (mot long). La position du gadget qu'on a retiré ou -1, si quelque chose ne fonctionne pas.
  • window : (struct Window *). Pointeur sur la fenêtre à laquelle le gadget est relié.
  • gadget : (struct Gadget *). Pointeur sur le gadget qui sera enlevé.
Important : après avoir retiré les gadgets nécessaires, il vous faudra appeler la fonction RefreshGadgets() pour voir les changements effectués. Vous pouvez ajouter (ou enlever) plusieurs gadgets mais vous devrez appeler cette fonction dès que vous aurez terminé.

OnGadget()

Cette fonction active un gadget (met à 0 le bit GADGDISABLED, dans le champ Flags de la structure gadget) :
  • Synopsis : OnGadget( gadget, window, requester );
  • gadget : (struct Gadget *). Pointeur sur le gadget qui sera activé.
  • window : (struct Window *). Pointeur sur la fenêtre à laquelle est relié le gadget.
  • requester : (struct Requester *). Si le gadget est relié à une requête, fixez ce pointeur pour qu'il pointe sur la requête, autrement mettez NULL. Important: si ce gadget est relié à une requête, il devra s'afficher lorsque vous impartirez cette commande !
N'oubliez pas que tant qu'un gadget est désactivé, l'utilisateur ne pourra pas le sélectionner et que ce gadget n'enverra aucun message. Un gadget désactivé se dessine comme les autres mais il s'affiche de manière "estompée".

OffGadget()

Cette fonction désactive un gadget (met à 1 le bit GADGDISABLED, dans le champ Flags de la structure gadget) :
  • Synopsis : OffGadget( gadget, window, requester );
  • gadget : (struct Gadget *). Pointeur sur le gadget qui sera désactivé.
  • window : (struct Window *). Pointeur sur la fenêtre à laquelle est relié le gadget.
  • requester : (struct Requester *). Si le gadget est relié à une requête, fixez ce pointeur pour qu'il pointe sur la requête, autrement mettez NULL. Important : si ce gadget est relié à une requête, il devra s'afficher lorsque vous impartirez cette commande !
ModifyProp()

Cette fonction modifie les valeurs d'un gadget proportionnel et le poussoir. Par exemple, si votre programme est en train de lire des fichiers à partir d'une disquette, au départ VertBody était peut-être égal à 0xFFFF (MAXBODY) mais comme vous chargez plusieurs fichiers à partir de la disquette, vous voudrez peut-être changer la taille du poussoir, etc. Dans ce cas, vous appelerez tout simplement cette fonction qui changera les valeurs et, en même temps, redessinera le gadget.
  • Synopsis : ModifyProp( gadget, window, requester, flags, horiz_pot, vert_pot, horiz_body, vert_body);
  • gadget : (struct Gadget *). Pointeur sur un gadget proportionnel qui doit être changé et redessiné.
  • window : (struct Window *). Pointeur sur la fenêtre à laquelle est relié le gadget proportionnel.
  • requester : (struct Requester *). Si le gadget est relié à une requête, fixez ce pointeur pour qu'il pointe sur la requête, autrement mettez NULL. Important : si ce gadget est relié à une requête, il devra s'afficher lorsque vous impartirez cette commande !
  • flags : (mot long) Voici la liste de tous les drapeaux que vous pouvez employer :
    • FREEHORIZ : mettez cet attribut à 1 si vous souhaitez que l'utilisateur puisse déplacer le poussoir horizontalement.
    • FREEVERT : mettez cet attribut à 1 si vous souhaitez que l'utilisateur puisse déplacer le poussoir verticalement.
    • AUTOKNOB : mettez cet attribut à 1 si vous souhaitez que la taille du poussoir soit sous le contrôle d'Intuition (HorizBody et VertBody affectent la taille d'Autoknob). Si vous souhaitez utiliser l'Autoknob d'Intuition, vous devrez donner dans GadgetRender un pointeur sur une structure Image (vous n'aurez pas à initialiser la structure Image du moment qu'Intuition s'en charge). D'un autre côté, si vous préférez employer un poussoir ayant un aspect personnalisé, vous devrez mettre dans GadgetRender un pointeur sur votre structure Image que vous devrez à son tour initialiser.
    • PROPBORDERLESS : mettez cet attribut à 1 si vous ne voulez pas de bord autour du conteneur. (Cf. le chapitre 4.7 pour plus d'informations).
  • horiz_pot : (mot long) cette variable contient la valeur proportionnelle courante (position horizontale) du poussoir. Si l'utilisateur a déplacé le poussoir de 25% sur la droite, HorizPot sera égal à 25% de MAXPOT (0xFFFF) (0xFFFF * 0,25 = 0x3FFF).
  • vert_pot : (mot long) même chose que pour HorizPot mais il s'agit ici de la valeur proportionnelle courante (position verticale) du poussoir.
  • horiz_body : (mot long) indique de combien variera HorizPot chaque fois que l'utilisateur clique à l'intérieur du conteneur. Si l'intensité d'une mélodie se situait entre 0 et 63 (64 pas), HorizPot varierait à chaque fois d'1/64. Cependant, on devra initialiser HorizBody à 1/64 * MAXBODY (0xFFFF) == 3FF. HorizBody indique aussi combien de données pourra voir/utiliser intégralement l'utilisateur. Par exemple, si vous avez une liste de 32 noms de fichiers et que l'utilisateur ne peut en voir que 8 à la fois (25%), le poussoir (AUTOKNOB) devra remplir 25% du conteneur. Dans ce cas, on initialisera HorizBody à MAXBODY * 8 / 32 (25% de 0xFFFF) == 3FFFF.
  • vert_body : même chose que pour HorizBody mais ce paramètre affecte VertPot et la taille verticale du poussoir (AUTOKNOB).
4.10 Exemples

Voici des exemples (dans le répertoire "Amiga_C_Manual/4.Gadgets") avec des gadgets :

Exemple 1

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre (même chose que dans l'exemple 3 du chapitre 2, Les Fenêtres, mais ici nous avons ajouté une vérification du port IDCMP sur le gadget système de fermeture de la fenêtre).

Exemple 2

Même chose que dans l'exemple 1 mais nous avons ajouté ici un gadget booléen avec le texte "PRESS ME".

Exemple 3

Même chose que dans l'exemple 2 mais ici l'état allumé/éteint du gadget est commuté à chaque fois que l'utilisateur active le gadget.

Exemple 4

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre nous avons mis deux gadgets booléens avec les textes "GADGET 1" ET "GADGET 2".

Exemple 5

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre nous avons mis un gadget booléen et nous lui avons relié deux structures Image. A chaque fois que l'utilisateur clique sur le gadget, celui-ci change d'aspect : lampe allumée/lampe éteinte.

Exemple 6

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre, nous avons mis un gadget booléen et nous lui avons relié un masque. Le gadget sera mis en surbrillance seulement quand l'utilisateur le sélectionnera en pointant à l'intérieur d'une zone déterminée (masquée).

Exemple 7

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre nous avons mis un gadget de chaîne.

Exemple 8

Même chose que dans l'exemple 7 mais ici nous avons mis un gadget entier.

Exemple 9

Même chose que dans l'exemple 7 mais ici nous avons mis un gadget proportionnel.

Exemple 10

Même chose que dans l'exemple 9 mais ici le gadget proportionnel se sert d'une image du poussoir créée par l'utilisateur.

Exemple 11

Ce programme ouvre une fenêtre normale qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre nous avons mis un gadget proportionnel où l'on peut déplacer le poussoir de manière horizontale ou verticale.

Exemple 12

Ce programme ouvre une fenêtre SuperBitmap qui est reliée à l'écran du Workbench. La fenêtre utilise tous les gadgets système et se fermera en premier dès que l'utilisateur aura cliqué sur le gadget système de fermeture de la fenêtre. Dans la fenêtre nous avons mis deux gadgets proportionnels, l'un sur le côté droit et l'un sur le bord inférieur. En s'aidant de ces deux gadgets, l'utilisateur pourra se déplacer dans le BitMap.

Nous avons mis cet exemple à l'intention exclusive des programmeurs expérimentés car il se sert de fonctions que nous n'avons pas présentées. Cependant, nous l'avons mis ici car c'est un bon exemple sur la manière de procéder pour utiliser les gadgets proportionnels avec les fenêtres SuperBitmap.


[Retour en haut] / [Retour aux articles] [Chapitre précédent : les graphismes] / [Chapitre suivant : les requêtes]