Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : 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.
|