Obligement - L'Amiga au maximum

Dimanche 26 septembre 2021 - 15:06  

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


Note : traduction par Serge Hammouche.

9. Divers

9.1 Introduction

Ceci est le dernier chapitre au sujet d'Intuition, nous allons donc conclure en parlant de certaines caractéristiques spéciales.

9.2 La mémoire

Si vous écrivez des programmes en C, vous aurez souvent besoin d'allouer de la mémoire. Ce procédé est normalement appelé "allocation dynamique de mémoire" et est utilisé à chaque fois que votre programme à besoin de plus de mémoire pendant son exécution.

Quand vous allouez de la mémoire, vous devez préciser combien il vous en faut et de quel type (Fast ou Chip). Exec essaie alors d'allouer la mémoire et retourne un pointeur sur cette mémoire, ou NULL s'il n'a pas pu trouver un bloc de mémoire assez grand.

Une fois que vous avez alloué la mémoire, vous pouvez en utiliser autant que vous voulez. Vous devez seulement vous souvenir qu'avant que le programme prenne fin, il doit libérer toute la mémoire allouée. Si vous oubliez de libérer la mémoire avant la fin, elle sera perdue et le seul moyen de la récupérer est de redémarrer le système.

9.2.1 Allouer de la mémoire

On utilise habituellement la fonction AllocMem() pour allouer de la mémoire. Il vous suffit de préciser combien de mémoire vous voulez et de quel type (Chip ou Fast) et AllocMem() retourne un pointeur sur la mémoire allouée, ou NULL s'il n'a pas pu en allouer.
  • Synopsis : memory = AllocMem( size, type );
  • memory : (void *). Pointeur sur la mémoire nouvellement allouée ou NULL si aucune mémoire ne peut l'être. Attention : n'utilisez jamais de la mémoire qui n'a pas été correctement allouée.
  • size : (long). La taille (en octets) de la mémoire demandée. AllocMem() alloue toujours la mémoire par multiples de huit octets. Ainsi, si vous ne demandez que neuf octets, Exec vous en donnera en fait 16 (2*8).
  • type : (long). Vous devez choisir un des trois types de mémoire suivants (voir le chapitre 0 - Introduction pour plus d'informations sur les mémoires Chip et Fast) :
    • MEMF_CHIP : mémoire Chip. Cette mémoire est accessible aussi bien au microprocesseur qu'aux puces spécialisées. Les données graphiques/sonores doivent par conséquent être placées en mémoire Chip. Si le type de mémoire obtenu ne vous importe pas, vous devez essayer d'allouer de la mémoire Fast en priorité sur la mémoire Chip. La mémoire Chip est plus précieuse et limitée que la mémoire Fast.
    • MEMF_FAST : mémoire Fast. Cette mémoire n'est accessible qu'au microprocesseur. Les données graphiques/sonores ne peuvent pas être placées en mémoire Fast, utilisez la mémoire Chip. Cette mémoire est normalement un peu plus rapide que la mémoire Chip car seul le microprocesseur y a accès et n'est donc pas gêné par les puces spécialisées.
    • MEMF_PUBLIC : si le type de mémoire obtenue ne vous importe pas (pas d'utilisation de la mémoire pour des données graphiques/sonores), vous devez utiliser la mémoire Fast. Cependant, tous les Amiga n'ont pas de mémoire Fast, il faut acheter une extension de mémoire pour en disposer. Pour dire à Exec que vous voulez utiliser la mémoire Fast s'il y en a, et la mémoire Chip sinon, spécifiez MEMF_PUBLIC.

      Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.
Pour allouer 150 octets de mémoire Chip, vous écririez :

/* Déclarer un pointeur sur la mémoire que vous allez allouer :    */
CPTR memory; /* CPTR signifie pointeur de mémoire, déclaré dans le */
             /* fichier entête "exec/types.h". "exec/types.h" est  */
             /* automatiquement inclus quand vous vous incluez le  */
             /* fichier entête "intuition/intuition.h".            */

/* Allouer 150 octets de mémoire Chip : */
memory = (CPTR) AllocMem( 150, MEMF_CHIP );

/* L'allocation a-t-elle réussie ? */
if( memory == NULL )
  /* ERREUR ! Aucune mémoire n'a été allouée ! */

9.2.2 Libérer la mémoire

Toute la mémoire qui a été allouée doit être libérée avant la fin de votre programme. Si vous oubliez de libérer de la mémoire que vous avez allouée, elle est irrémédiablement perdue. La seule façon de récupérer cette mémoire est alors de redémarrer le système (ce qui n'est pas à conseiller. Nous ne sommes pas des programmeurs de démos, n'est-ce pas ?). La mémoire allouée se libère en appelant la fonction FreeMem() :
  • Synopsis : FreeMem( memory, size );
  • memory : (void *). Pointeur sur de la mémoire qui a été auparavant allouée. Attention : n'utilisez jamais la mémoire qui a été libérée.
  • size : (long). La taille (en octets) de la mémoire que vous voulez libérer.
Pour libérer les 150 octets de mémoire Chip que nous avons précédemment alloués, nous écrivons :

/* Libérer 150 octets de mémoire : */
FreeMem( memory, 150 );

9.2.3 La mémoire Remember

Si vous allouez de la mémoire à plusieurs reprises et en différentes quantités, il peut s'avérer très difficile de se rappeler de libérer toute la mémoire correctement. Néanmoins, ne désespérez pas. Intuition a la solution à vos problèmes. Vous pouvez utiliser la fonction AllocRemember() qui appelle la fonction AllocMem(), mais qui alloue aussi de la mémoire pour une structure Remember qui est automatiquement initialisée pour vous. Chaque fois que vous allouez de la mémoire avec la fonction AllocRemember(), les structures Remember sont liées les unes aux autres, et les informations sur la mémoire (taille et position) sont conservées. Quand vous voulez libérer la mémoire, il vous suffit d'appeler la fonction FreeRemember() et toute la mémoire est libérée automatiquement pour vous.

La structure Remember ressemble à ceci :

struct Remember
{
  struct Remember *NextRemember;
  ULONG RememberSize;
  UBYTE *Memory;
};

La fonction AllocRemember() s'appelles comme suit, elle est très proche de la fonction AllocMem() :
  • Synopsis : memory = AllocRemember( remember, size, type );
  • memory : (char *). Pointeur sur la mémoire nouvellement allouée, ou NULL si aucune mémoire ne peut l'être. Attention : n'utilisez jamais de la mémoire qui n'a pas été correctement allouée.
  • remember : (struct Remember **) adresse du pointeur sur la structure Remember. Avant d'appeler la fonction AllocRemember() pour la première fois, vous devez initialiser ce pointeur à NULL (remarquez que c'est un pointeur sur un pointeur !).
  • size : (long). La taille (en octets) de la mémoire demandée. AllocMem() alloue toujours la mémoire par multiples de huit octets. Ainsi, si vous ne demandez que neuf octets, Exec vous en donnera en fait 16 (2*8).
  • type : (long). Vous devez choisir un des trois types de mémoire suivants (voir le chapitre 0 - Introduction pour plus d'informations sur les mémoires Chip et Fast :
    • MEMF_CHIP : mémoire Chip. Cette mémoire est accessible aussi bien au microprocesseur qu'aux puces spécialisées. Les données graphiques/sonores doivent par conséquent être placées en mémoire Chip. Si le type de mémoire obtenu ne vous importe pas, vous devez essayer d'allouer de la mémoire Fast en priorité sur la mémoire Chip. La mémoire Chip est plus précieuse et limitée que la mémoire Fast.
    • MEMF_FAST : mémoire Fast. Cette mémoire n'est accessible qu'au microprocesseur. Les données graphiques/sonores ne peuvent pas être placées en mémoire Fast, utilisez la mémoire Chip. Cette mémoire est normalement un peu plus rapide que la mémoire Chip, car seul le microprocesseur y a accès et n'est donc pas gêné par les puces spécialisées.
    • MEMF_PUBLIC : si le type de mémoire obtenue ne vous importe pas (pas d'utilisation de la mémoire pour des données graphiques/sonores), vous devez utiliser la mémoire Fast. Cependant, tous les Amiga n'ont pas de mémoire Fast, il faut acheter une extension de mémoire pour en disposer. Pour dire à Exec que vous voulez utiliser la mémoire Fast s'il y en a, et la mémoire Chip sinon, spécifiez MEMF_PUBLIC.

      Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.
Quand vous voulez libérer la mémoire, il vous suffit d'appeler la fonction FreeRemember(). Vous pouvez, si vous le voulez, ne libérer que les structures Remember et vous occuper vous-même de libérer le reste, mais soyez prudent. La fonction FreeRemember() s'appelle comme suit :
  • Synopsis : FreeRemember( remember, everything );
  • remember : (struct Remember **). Adresse du pointeur sur la première structure Remember (initialisée par la fonction AllocRemember()). Remarquez que c'est un pointeur sur un pointeur !
  • everything : (long). Booléen. Si everything est égal à TRUE, toute la mémoire (la mémoire allouée et la structure Remember) est libérée. Toutefois, si everything est égal à FALSE, seule la structure Remember est libérée et vous devez libérer la mémoire vous-même.
Voici un court exemple qui montre comment utiliser les fonctions AllocRemember() et FreeRemember() :

struct Remember *remember = NULL;
CPTR memory1, memory2, memory3;

/* Alloue 350 octets de mémoire Chip, qui est effacée : */
memory1 = AllocRemember( &remember, 350, MEMF_CHIP|MEMF_CLEAR );

if( memory1 == NULL )
  Remettre tout en ordre et sortir;

/* Alloue 900 octets de mémoire (n'importe quel type, Fast si possible) : */
memory2 = AllocRemember( &remember, 900, MEMF_PUBLIC );

if( memory2 == NULL )
  Remettre tout en ordre et sortir;

/* Alloue 100 octets de mémoire Chip : */
memory3 = AllocRemember( &remember, 100, MEMF_CHIP );

if( memory3 == NULL )
  Remettre tout en ordre et sortir;

...

/* Libère toute mémoire en un seul appel: */
FreeRemember( &remember, TRUE );

Si nous l'avions voulu, nous aurions pu libérer toutes les structures Remember, puis libérer nous-même la mémoire grâce à la fonction FreeMem() normale :

/* Ne libère que les structures Remember : */
FreeRemember( &remember, FALSE );
FreeMem( memory1, 350 );
FreeMem( memory2, 900 );
FreeMem( memory3, 100 );

9.3 Les préférences

Quand le sytème démarre, Intuition est initialisé avec des valeurs par défaut. Néanmoins, il y a un fichier appelé "system-configuration" dans le répertoire "devs" du disque système, qui est utilisé pour initialiser les valeurs du système, au lieu des valeurs par défaut.

L'utilisateur peut, au moyen du programme Preferences, modifier les valeurs du système et/ou le fichier system-configuration. Si l'utilisateur choisit le bouton "Use", seules les valeurs du système sont modifiées, tandis que s'il choisit le bouton "Save", les valeurs du système et le fichier system-configuration sont tous deux mis à jour.

Votre programme peut obtenir une copie des valeurs du système en appelant la fonction GetPrefs(). Si vous voulez obtenir une copie des valeurs par défaut, utilisez la fonction GetDefPrefs(). Quand vous faites une copie des données de Preferences, vous pouvez décider de la quantité de données à copier. Vous pouvez par conséquent ne copier, si vous le voulez, copier que partiellement la structure et n'avez pas besoin d'allouer de la mémoire pour la structure complète. Les valeurs les plus importantes sont à cet effet placées au début de la structure. La structure Preferences se présente comme suit :

struct Preferences
{
  BYTE FontHeight;
  UBYTE PrinterPort;
  USHORT BaudRate;
  struct timeval KeyRptSpeed;
  struct timeval KeyRptDelay;
  struct timeval DoubleClick;
  USHORT PointerMatrix[POINTERSIZE];
  BYTE XOffset;
  BYTE YOffset;
  USHORT color17;
  USHORT color18;
  USHORT color19;
  USHORT PointerTicks;
  USHORT color0;
  USHORT color1;
  USHORT color2;
  USHORT color3;
  BYTE ViewXOffset;
  BYTE ViewYOffset;
  WORD ViewInitX, ViewInitY;
  BOOL EnableCLI;
  USHORT PrinterType;
  UBYTE PrinterFilename[FILENAME_SIZE];
  USHORT PrintPitch;
  USHORT PrintQuality;
  USHORT PrintSpacing;
  UWORD PrintLeftMargin;
  UWORD PrintRightMargin;
  USHORT PrintImage;
  USHORT PrintAspect;
  USHORT PrintShade;
  WORD PrintThreshold;
  USHORT PaperSize;
  UWORD PaperLength;
  USHORT PaperType;
  UBYTE SerRWBits;
  UBYTE SerStopBuf;
  UBYTE SerParShk;
  UBYTE LaceWB;
  UBYTE WorkName[FILENAME_SIZE];
  BYTE RowSizeChange;
  BYTE ColumnSizeChange;
  UWORD PrintFlags;
  UWORD PrintMaxWidth;
  UWORD PrintMaxHeight;
  UBYTE PrintDensity;
  UBYTE PrintXOffset;
  UWORD wb_Width;
  UWORD wb_Height;
  UBYTE wb_Depth;
  UBYTE ext_size;
};

(voir le fichier "preference.h de Commodore pour plus d'informations)

Vous appelez la fonction GetPrefs() comme suit :
  • Synopsis : pref = GetPrefs( buffer, size );
  • pref : (struct Preferences *). Pointeur sur vos préférences. Identique à votre pointeur mémoire (buffer), mais il est retourné, ainsi vous pouvez vérifier si vous avez une copie ou non. Si la copie des préférences a échouée, la fonction retourne NULL.
  • buffer : (struct Preferences *). Pointeur sur le tampon mémoire qui doit être utilisé pour stocker la copie des préférences.
  • size : (long). Le nombre d'octets que vous voulez copier dans le tampon. Attention, le tampon doit être au moins aussi grand que le nombre d'octets que vous voulez copier.
Vous appelez la fonction GetDefPrefs() comme suit :
  • Synopsis : pref = GetDefPrefs( buffer, size );
  • pref : (struct Preferences *).Pointeur sur les préférences par défaut. Si la fonction ne peut pas faire la copie des préférences, elle retourne NULL.
  • buffer : (struct Preferences *). Pointeur sur le tampon mémoire qui doit être utilisé pour stocker la copie des préférences par défaut.
  • size : (long). Le nombre d'octets que vous voulez copier dans le tampon. Attention, le tampon doit être au moins aussi grand que le nombre d'octets que vous voulez copier.
Voici un exemple pour obtenir les préférences courantes :

/* Déclare une structure Preferences : */
struct Preferences pref;

/* Essaie d'obtenir une copie des préférences courantes : */
if( GetPrefs( &pref, sizeof(pref) ) == NULL )
/* On n'a pas pu obtenir de copie des préférences ! */

Une fois que vous avez une copie des préférences courantes/par défaut, vous pouvez commencer à vérifier les réglages.

Vous pouvez, si vous le voulez, modifier des valeurs puis les sauvegarder comme nouvelles préférences. Attention : vous ne devez jamais bidouiller les réglages car ce sont les préférences de l'utilisateur, elles ne doivent pas être changées à moins que l'utilisateur ne veuille vraiment les modifier.

Vous donnez de nouvelles préférences en appelant la fonction SetPrefs() :
  • Synopsis : SetPrefs( pref, size, doit );
  • pref : (struct Preferences *). Pointeur sur votre structure Preferences modifiée.
  • size : (long). Le nombre d'octets que vous voulez changer.
  • doit : (long). Booléen qui, s'il est FALSE, change les préférences, mais n'envoie pas de message NEWPREFS. Si doit est égal à TRUE, les réglages sont changés et un message NEWPREFS est envoyé. Tant que l'utilisateur modifie les valeurs, doit être FALSE, mais quand l'utilisateur a fini, mettez le à TRUE et tous les programmes recevront un message NEWPREFS.
9.4 Les avertissements

Il y a trois niveaux d'avertissements que vous pouvez donner à l'utilisateur quand quelque chose ne va pas :

Premier avertissement

Si vous voulez juste attirer l'attention de l'utilisateur sur quelque chose mais que rien de vraiment dangereux ne s'est passé, vous pouvez appeler la fonction DisplayBeep(). Elle provoque un clignotement avec les couleurs de l'écran.
  • Synopsis : DisplayBeep( screen );
  • screen : (struct Screen *). Pointeur sur l'écran dont vous voulez faire clignoter les couleurs. Si vous n'avez pas ouvert vous-même un écran (utilisation de l'écran du Workbench), vous pouvez trouver le pointeur sur cet écran dans la structure Window :

    DisplayBeep( my_window->WScreen );
    

    (my_window est un pointeur sur une fenêtre ouverte)
Deuxième avertissement

Si quelque chose d'important s'est passé ou si vous voulez que l'utilisateur fasse une action (sélectionner quelque chose, etc.) ouvrez une requête (Voir le chapitre 5 - Les requêtes pour plus d'informations).

Troisième avertissement

Si quelque chose de terrible est advenu, que le système s'écroule, ouvrez une alerte (voir le chapitre 6 - Les alertes pour plus d'informations).

9.5 Le double-clic

Il y a cinq actions différentes possibles avec la souris :
  • Presser un bouton : l'utilisateur peut appuyer sur un bouton.
  • Relâcher un bouton : l'utilisateur peut relâcher le bouton précédemment pressé.
  • Cliquer sur un bouton : presser et relâcher rapidement le bouton.
  • Double-cliquer sur un bouton : presser et relâcher rapidement le bouton deux fois de suite.
  • Déplacer la souris : garder un bouton pressé pendant qu'on déplace la souris.
Utilisez les drapeaux IDCMP SELECTDOWN, SELECTUP, MENUDOWN et MENUUP pour recevoir les évènements des boutons de la souris (Voir le chapitre 8 - IDCMP pour plus d'informations).

Si vous voulez vérifier que l'utilisateur a double-cliqué sur l'un des boutons de la souris, vous pouvez utiliser la fonction DoubleClick(). Vous donnez à la fonction l'heure courante et celle du clic précédent du bouton, et elle vérifie avec les préférences et retourne TRUE si les deux pressions sur le bouton sont intervenues dans la limite de temps (l'utilisateur peut changer la limite de temps pour les double-clics).
  • Synopsis : double = DoubleClick( sec1, mic1, sec2, mic2 );
  • double : (long). Si les deux pressions ont eu lieu dans la limite de temps courante, la fonction retournera TRUE, sinon elle retournera FALSE.
  • sec1 : (long). Moment (secondes) où le bouton a été pressé pour la première fois.
  • mic1 : (long). Moment (microsecondes) où le bouton a été pressé pour la première fois.
  • sec2 : (long). Moment courant (secondes).
  • mic2 : (long). Moment courant (microsecondes).
Voici un bref exemple de vérification de double-clic :

struct IntuiMessage *message;
ULONG sec1, mic1, sec2, mic2; 

... ... ...

if( message->Class == MOUSEBUTTONS )
{
  /* Un bouton de la souris a été pressé/relâché. */
  if( message->Code == SELECTDOWN )
  {
    /* Le bouton de gauche a été pressé. */

    /* Sauvegarder l'ancienne heure : */
    sec2 = sec1;
    mic2 = mic1;
    
    /* Prendre la nouvelle heure : */
    sec1 = message->Seconds;
    mic1 = message->Micros;
    
    /* Vérifier s'il y a eu double-clic ou non : */
    if( DoubleClick( sec2, mic2, sec1, mic1 ) )
    {
      printf("Double-Clic!\n");
      /* Réinitialiser les valeurs : */
      sec1 = 0;
      mic1 = 0;
    }
  }
}

9.6 L'heure

Vous pouvez obtenir l'heure courante en appelant la fonction CurrentTime() :
  • Synopsis : CurrentTime( seconds, micros );
  • seconds : (long *). Pointeur sur une variable ULONG qui sera initialisée au nombre de secondes courant.
  • micros : (long *). Pointeur sur une variable ULONG qui sera initialisée au nombre de microsecondes courant.
Voici un court exemple :

ULONG seconds, micros;
CurrentTime( &seconds, µs );

9.7 Le style

Comme Intuition est l'interface entre l'ordinateur et l'utlisateur, il est important qu'il y ait des standards pour les gadgets, requêtes, menus, souris, etc. Si des programmes similaires utilisent le même type de style, l'utilisateur apprendra beaucoup plus rapidement à s'en servir. Vous, en temps que programmeur, devez donc vous assurer que votre programme est facilement compréhensible et tout à fait sûr. Rendez votre programme facile à apprendre et agréable à utiliser !

9.7.1 Les gadgets

Pensez à faire des gadgets facilement identifiables et compréhensibles. Mettez des mots courts comme "Annuler", "Ok" dans les gadgets ou utilisez des symboles graphiques. Pensez à désactiver (mode fantôme) un gadget quand il cesse d'être fonctionnel.

9.7.2 Les requêtes

Les requêtes ont deux fonctions principales : elles peuvent informer l'utilisateur, et/ou lui demander de faire quelque chose. Il est donc important que l'utilisateur comprenne facilement ce qui s'est ou va se passer et ce qu'il doit faire. Utilisez des graphismes colorés si nécessaire et rappelez-vous quand vous demandez à l'utilisateur d'effectuer une action de toujours lui donner un moyen de s'en sortir sans rien changer (bouton "Annuler").

Une requête inutile doit être supprimée. Utilisez les fonctions EndRequest(), ClearDMRequest().

Placez le gadget Ok/Oui/Vrai (s'il y en a un) dans le coin inférieur gauche et le gadget Annuler/Non/Faux dans le coin inférieur droit. Il doit toujours y avoir un gadget de sortie (Annuler) dans une requête !

---------------------------------------
| D'accord pour effacer le fichier ?  |
|                                     |
| -----------            -----------  |
| | Effacer |            | Annuler |  |  
| -----------            -----------  |
---------------------------------------

9.7.3 Les menus

Les items/sous-items des menus qui ne sont pas fonctionnels doivent être désactivés (mode fantôme). Utilisez la fonction OffMenu().

Il y a deux menus, les menus Project (document) et Edit (édition), qu'utilisent de nombreux programmes et qui doivent par conséquent ressembler à ceci :

Menu Project
  • New : crée un nouveau document.
  • Open : ouvre un ancien document.
  • Save : sauvegarde le document courant.
  • Save as : sauvegarde le document courant sous un nouveau nom.
  • Print : imprime tout le document.
  • Print as : imprime une partie du document, et/ou avec de nouveau réglages.
  • Quit : quitte. Pensez à demander à l'utilisateur s'il veut vraiment quitter et s'il veut sauvegarder le document.
Menu Edit
  • Undo : défaire la dernière opération.
  • Cut : découper une partie et la stocker dans le presse-papiers (clipboard).
  • Copy : copie une partie du document dans le presse-papiers.
  • Paste : colle une copie du presse-papiers dans le document.
  • Erase : détruit une partie du document sans la mettre dans le presse-papiers.
Pensez à mettre des raccourcis pour les fonctions de menu d'usage fréquent. Voici des styles de touches de commande standard :
  • N : new (nouveau).
  • O : open (ouvrir).
  • S : save (sauver).
  • Q : quit (quitter).
  • U : undo (défaire).
  • X : cut (couper).
  • C : copy (copier).
  • P : paste (coller).
9.7.4 La souris

Le bouton gauche de la souris est utilisé pour la sélection, tandis que celui de droite sert au transfert d'informations. Le bouton de gauche est donc utilisé pour la sélection des gadgets, etc, alors que les fonctions des menus et les requêtes à double-menu, etc, utilisent celui de droite.

9.8 Les fonctions

AllocMem()

Cette fonction alloue de la mémoire. Vous spécifiez le type et la quantité que vous voulez et elle retourne un pointeur sur la mémoire allouée, ou NULL s'il n'y a pas assez de mémoire.
  • Synopsis : memory = AllocMem( size, type );
  • memory : (void *). Pointeur sur la mémoire nouvellement allouée, ou NULL si aucune mémoire ne peut l'être. Attention : n'utilisez jamais de la mémoire qui n'a pas été correctement allouée.
  • size : (long). La taille (en octets) de la mémoire demandée. AllocMem() alloue toujours la mémoire par multiples de huit octets. Ainsi, si vous ne demandez que neuf octets, Exec vous en donnera en fait 16 (2*8)).
  • type : (long). Vous devez choisir un des trois types de mémoire suivants (voir le chapitre 0 - Introduction pour plus d'informations sur les mémoires Chip et Fast) :
    • MEMF_CHIP : mémoire Chip. Cette mémoire est accessible aussi bien au microprocesseur qu'aux puces spécialisées. Les données graphiques/sonores doivent par conséquent être placées en mémoire Chip. Si le type de mémoire obtenu ne vous importe pas, vous devez essayer d'allouer de la mémoire Fast en priorité sur la mémoire Chip. La mémoire Chip est plus précieuse et limitée que la mémoire Fast.
    • MEMF_FAST : mémoire Fast. Cette mémoire n'est accessible qu'au microprocesseur. Les données graphiques/sonores ne peuvent pas être placées en mémoire Fast, utilisez la mémoire Chip. Cette mémoire est normalement un peu plus rapide que la mémoire Chip, car seul le microprocesseur y a accès et n'est donc pas gêné par les puces spécialisées.
    • MEMF_PUBLIC : si le type de mémoire obtenue ne vous importe pas (pas d'utilisation de la mémoire pour des données graphiques/sonores), vous devez utiliser la mémoire Fast. Cependant, tous les Amiga n'ont pas de mémoire Fast, il faut acheter une extension de mémoire pour en disposer. Pour dire à Exec que vous voulez utiliser la mémoire Fast s'il y en a, et la mémoire Chip sinon, spécifiez MEMF_PUBLIC. Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.
Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.

FreeMem()

Cette fonction libère la mémoire précédemment allouée. Rappelez vous que vous devez libérer toute la mémoire vous avez allouée et de ne jamais libérer la mémoire que vous n'avez pas allouée.
  • Synopsis : FreeMem( memory, size );
  • memory : (void *). Pointeur sur de la mémoire qui a été auparavant allouée. Attention : n'utilisée jamais la mémoire qui a été libérée.
  • size : (long). La taille (en octets) de la mémoire que vous voulez libérer.
AllocRemember()

Cette fonction alloue de la mémoire Chip ou Fast (comme AllocMem), mais alloue aussi la place pour une structure Remember qui est initialisée avec la taille de la mémoire allouée, et un pointeur sur cette mémoire. A chaque allocation de mémoire du programme avec cette fonction, les structures Remember sont liées les unes aux autres.

Comme les structures Remember contiennent toutes les informations nécessaires sur la mémoire et lui sont liées, toute mémoire peut être libérée avec un unique appel de fonction (FreeRemember()).
  • Synopsis : memory = AllocRemember( remember, size, type );
  • memory : (char *). Pointeur sur la mémoire nouvellement allouée, ou NULL si aucune mémoire ne peut l'être. Attention : n'utilisez jamais de la mémoire qui n'a pas été correctement allouée.
  • remember : (struct Remember **). Adresse du pointeur sur la structure Remember. Avant d'appeler la fonction AllocRemember() pour la première fois, vous devez initialiser ce pointeur à NULL (remarquez que c'est un pointeur sur un pointeur !).
  • size : (long). La taille (en octets) de la mémoire demandée. AllocMem() alloue toujours la mémoire par multiples de huit octets. Ainsi, si vous ne demandez que neuf octets, Exec vous en donnera en fait 16 (2*8)).
  • type : (long). Vous devez choisir un des trois types de mémoire suivants (voir le chapitre 0 - Introduction pour plus d'informations sur les mémoires Chip et Fast :
    • MEMF_CHIP : mémoire Chip. Cette mémoire est accessible aussi bien au microprocesseur qu'aux puces spécialisées. Les données graphiques/sonores doivent par conséquent être placées en mémoire Chip. Si le type de mémoire obtenu ne vous importe pas, vous devez essayer d'allouer de la mémoire Fast en priorité sur la mémoire Chip. La mémoire Chip est plus précieuse et limitée que la mémoire Fast.
    • MEMF_FAST : mémoire Fast. Cette mémoire n'est accessible qu'au microprocesseur. Les données graphiques/sonores ne peuvent pas être placées en mémoire Fast, utilisez la mémoire Chip. Cette mémoire est normalement un peu plus rapide que la mémoire Chip, car seul le microprocesseur y a accès et n'est donc pas gêné par les puces spécialisées.
    • MEMF_PUBLIC : si le type de mémoire obtenue ne vous importe pas (pas d'utilisation de la mémoire pour des données graphiques/sonores), vous devez utiliser la mémoire Fast. Cependant, tous les Amiga n'ont pas de mémoire Fast, il faut acheter une extension de mémoire pour en disposer. Pour dire à Exec que vous voulez utiliser la mémoire Fast s'il y en a, et la mémoire Chip sinon, spécifiez MEMF_PUBLIC. Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.
Si vous voulez que la mémoire allouée soit effacée (remplie de zéros), utilisez le commutateur MEMF_CLEAR.

FreeRemember()

Cette fonction libère toute la mémoire qui a été allouée par la fonction AllocRemember(). Notez que vous pouvez désallouer seulement la structure Remember et libérer la mémoire vous-même si vous voulez.
  • Synopsis : FreeRemember( remember, everything );
  • remember : (struct Remember **). Adresse du pointeur sur la première structure Remember (initialisée par la fonction AllocRemember()). Remarquez que c'est un pointeur sur un pointeur !).
  • everything : (long). Booléen. Si "everything" est égal à TRUE, toute la mémoire (la mémoire allouée et la structure Remember) est libérée. Toutefois, si "everything" est égal à FALSE, seule la structure Remember est libérée et vous devez libérer la mémoire vous-même.
GetPrefs()

Cette fonction fait une copie de la structure Preferences.
  • Synopsis : pref = GetPrefs( buffer, size );
  • pref : (struct Preferences *). Pointeur sur vos préférences. Identique à votre pointeur mémoire (buffer), mais il est retourné, ainsi vous pouvez vérifier si vous avez une copie ou non. Si la copie des préférences a échoué, la fonction retourne NULL.
  • buffer : (struct Preferences *). Pointeur sur le tampon mémoire qui doit être utilisé pour stocker la copie des préférences.
  • size : (long). Le nombre d'octets que vous voulez copier dans le tampon. Attention, le tampon doit être au moins aussi grand que le nombre d'octets que vous voulez copier.
GetDefPrefs()

Cette fonction fait une copie de la structure Preferences par défaut.
  • Synopsis : pref = GetDefPrefs( buffer, size );
  • pref : (struct Preferences *). Pointeur sur les préférences par défaut. Si la fonction ne peut pas faire la copie des préférences, elle retourne NULL.
  • buffer : (struct Preferences *). Pointeur sur le tampon mémoire qui doit être utilisé pour stocker la copie des préférences par défaut.
  • size : (long). Le nombre d'octets que vous voulez copier dans le tampon. Attention, le tampon doit être au moins aussi grand que le nombre d'octets que vous voulez copier.
SetPrefs()

Cette fonction sauvegarde une structure Preferences modifiée. Ne changez pas les préférences à moins que l'utilisateur ne le veuille vraiment !
  • Synopsis : SetPrefs( pref, size, doit );
  • pref : (struct Preferences *). Pointeur sur votre structure Preferences modifiée.
  • size : (long). Le nombre d'octets que vous voulez changer.
  • doit : (long). Booléen qui, s'il est FALSE, change les préférences, mais n'envoie pas de message NEWPREFS. Si doit est égal à TRUE, les réglages sont changés et un message NEWPREFS est envoyé. Tant que l'utilisateur modifie les valeurs, doit être FALSE, mais quand l'utilisateur a fini, mettez-le à TRUE et tous les programmes recevront un message NEWPREFS.
DisplayBeep()

Cette fonction provoque un clignotement avec les couleurs d'écran. Elle peut servir à chaque fois que vous voulez attirer l'attention de l'utilisateur.
  • Synopsis : DisplayBeep( screen );
  • screen : (struct Screen *). Pointeur sur l'écran dont vous voulez faire clignoter les couleurs. Si vous n'avez pas ouvert vous-même un écran (utilisation de l'écran du Workbench), vous pouvez trouver le pointeur sur cet écran dans la structure Window :

    DisplayBeep( my_window->WScreen );
    

    (my_window est un pointeur sur une fenêtre ouverte)
DoubleClick()

Cette fonction contrôle si l'utilisateur a double-cliqué sur un des boutons de la souris. Vous donnez à la fonction le moment courant et le moment précédent où le bouton a été pressé et elle contrôle les préférences pour retourner TRUE si les deux pressions ont eu lieu dans la limite de temps.
  • Synopsis : double = DoubleClick( sec1, mic1, sec2, mic2 );
  • double : (long). Si les deux pressions ont eu lieu dans la limite de temps courante, la fonction retournera TRUE, sinon elle retournera FALSE.
  • sec1 : (long). Moment (secondes) où le bouton a été pressé pour la première fois.
  • mic1 : (long). Moment (microsecondes) où le bouton a été pressé pour la première fois.
  • sec2 : (long). Moment courant (secondes).
  • mic2 : (long). Moment courant (microsecondes).
CurrentTime()

Cette fonction donne l'heure courante.
  • Synopsis : CurrentTime( seconds, micros );
  • seconds : (long *). Pointeur sur une variable ULONG qui sera initialisée au nombre de secondes courant.
  • micros : (long *). Pointeur sur une variable ULONG qui sera initialisée au nombre de microsecondes courant
9.9 Exemples

Voici des exemples (dans le répertoire "Amiga_C_Manual/9.Miscellaneous") montrant diverses fonctions :

Exemple 1

Cet exemple montre comment allouer et libérer de la mémoire.

Exemple 2

Cet exemple montre comment allouer et libérer de la mémoire à l'aide des fonctions AllocRemember() et FreeRemember().

Exemple 3

Cet exemple montre comment obtenir une copie des préférences.

Exemple 4

Cet exemple montre comment gérer les double-clics sur les boutons de la souris.

Exemple 5

Cet exemple affiche l'heure courante.


[Retour en haut] / [Retour aux articles] [Chapitre précédent : IDCMP] / [Chapitre suivant : les sprites]