Fxlib.h : Différence entre versions
m (Aah, les illusions sur Sleep(). Quel dommage.) |
|||
(17 révisions intermédiaires par 6 utilisateurs non affichées) | |||
Ligne 1 : | Ligne 1 : | ||
La librairie "fxlib.h" est la librairie qui contient toutes les fonctions de bases du kit de développement de Casio pour Graph 75/85/95 (SD). Il existe d'autres librairies communautaires bien plus simples et puissantes, mais certaines fonctions de "fxlib.h" sont nécessaires, et n'ont pas d'équivalent dans les librairies non-officielles. | La librairie "fxlib.h" est la librairie qui contient toutes les fonctions de bases du kit de développement de Casio pour Graph 75/85/95 (SD). Il existe d'autres librairies communautaires bien plus simples et puissantes, mais certaines fonctions de "fxlib.h" sont nécessaires, et n'ont pas d'équivalent dans les librairies non-officielles. | ||
− | Dans cette documentation vous découvrirez un aperçu des fonctions, comment les utiliser et leur utilité. Si il vous manque des informations, vous pouvez toujours venir vous informer sur les forums Casio comme [http://www.planet-casio.com/Fr/ | + | Dans cette documentation vous découvrirez un aperçu des fonctions, comment les utiliser et leur utilité. Si il vous manque des informations, vous pouvez toujours venir vous informer sur les forums Casio comme [http://www.planet-casio.com/Fr/ Planète-Casio] côté francophone. |
Ligne 8 : | Ligne 8 : | ||
=== Bdisp_PutDisp_DD === | === Bdisp_PutDisp_DD === | ||
− | prototype : | + | prototype : |
+ | <syntaxhighlight>void Bdisp_PutDisp_DD(void);</syntaxhighlight> | ||
Affiche à l'écran le contenu de la VRAM (buffer stockant le contenu de l'écran virtuel). Ne prend aucun argument et ne renvoie aucune valeur. | Affiche à l'écran le contenu de la VRAM (buffer stockant le contenu de l'écran virtuel). Ne prend aucun argument et ne renvoie aucune valeur. | ||
Ligne 16 : | Ligne 17 : | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_AllClr_DD(void);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_AllClr_VRAM(void);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_AllClr_DDVRAM(void);</syntaxhighlight> | |
− | |||
− | |||
Ne prend aucun argument et ne renvoie aucune valeur. | Ne prend aucun argument et ne renvoie aucune valeur. | ||
Ligne 32 : | Ligne 31 : | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_AreaClr_DD(const DISPBOX *pArea);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_AreaClr_VRAM(const DISPBOX *pArea);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_AreaClr_DDVRAM(const DISPBOX *pArea);</syntaxhighlight> | |
− | |||
− | |||
La fonction ne renvoie aucune valeur. | La fonction ne renvoie aucune valeur. | ||
Efface une partie de l'écran. L'argument à passer (par pointeur) à cette fonction est une structure de la forme : | Efface une partie de l'écran. L'argument à passer (par pointeur) à cette fonction est une structure de la forme : | ||
− | + | <syntaxhighlight> | |
− | + | typedef struct tag_DISPBOX{ // déclarée dans "dispbios.h" | |
− | + | int left; // 0~127 | |
− | + | int top; // 0~63 | |
− | + | int right; // 0~127 | |
− | + | int bottom; // 0~63 | |
− | + | } DISPBOX; | |
− | + | </syntaxhighlight> | |
− | |||
− | |||
− | |||
− | |||
− | |||
=== Bdisp_AreaReverseVRAM === | === Bdisp_AreaReverseVRAM === | ||
prototype : | prototype : | ||
− | + | <syntaxhighlight>void Bdisp_AreaReverseVRAM( | |
− | + | int x1, // coordonnée x à gauche | |
− | + | int y1, // coordonnée y en haut | |
− | + | int x2, // coordonnée x à droite | |
− | + | int y2 // coordonnée y en bas | |
− | + | );</syntaxhighlight> | |
− | La fonction ne renvoie aucune valeur. Inverse une zone de | + | La fonction ne renvoie aucune valeur. Inverse une zone de la VRAM (pixel éteint en allumé et allumé en éteint). |
Passez-lui en argument les coordonnées de la zone à inverser, comme indiqué ci-dessus). | Passez-lui en argument les coordonnées de la zone à inverser, comme indiqué ci-dessus). | ||
− | |||
=== Bdisp_GetDisp_DD/ Bdisp_GetDisp_VRAM === | === Bdisp_GetDisp_DD/ Bdisp_GetDisp_VRAM === | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_GetDisp_DD(unsigned char * pData);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_GetDisp_VRAM(unsigned char * pData);</syntaxhighlight> | |
La fonction ne renvoie aucune valeur. Elle permet de stocker dans un tableau le bitmap des écrans de la VRAM (écran virtuel) ou du DD (écran graphique). On lui passe en argument (par pointeur) le tableau où le bitmap sera stocké. | La fonction ne renvoie aucune valeur. Elle permet de stocker dans un tableau le bitmap des écrans de la VRAM (écran virtuel) ou du DD (écran graphique). On lui passe en argument (par pointeur) le tableau où le bitmap sera stocké. | ||
Ligne 87 : | Ligne 78 : | ||
=== Bdisp_PutDispArea_DD === | === Bdisp_PutDispArea_DD === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Bdisp_PutDispArea_DD(const DISPBOX *pArea);</syntaxhighlight> |
Une des plus belles erreurs de la documentation de Casio ! Dans la doc ils ont mis les explications d'une autre fonction... Cette fonction permet d'afficher à l'écran graphique une zone de l'écran virtuel. On peut tout de même deviner que cette fonction demande en argument une structure (passage par pointeur) de la forme : | Une des plus belles erreurs de la documentation de Casio ! Dans la doc ils ont mis les explications d'une autre fonction... Cette fonction permet d'afficher à l'écran graphique une zone de l'écran virtuel. On peut tout de même deviner que cette fonction demande en argument une structure (passage par pointeur) de la forme : | ||
− | + | <syntaxhighlight>typedef struct tag_DISPBOX{ // déclarée dans "dispbios.h" | |
− | + | int left; // 0~127 | |
− | + | int top; // 0~63 | |
− | + | int right; // 0~127 | |
− | + | int bottom; // 0~63 | |
− | + | } DISPBOX;</syntaxhighlight> | |
Ligne 107 : | Ligne 98 : | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_SetPoint_DD(int x,int y,unsigned char point);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_SetPoint_VRAM(int x,int y,unsigned char point);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_SetPoint_DDVRAM(int x,int y,unsigned char point);</syntaxhighlight> | |
Place ou supprime un pixel aux coordonnées x et y passées en argument. Ne renvoie aucune valeur. La troisième valeur passée en argument est le type de point : 1 pour mettre un pixel, 0 pour en enlever un. | Place ou supprime un pixel aux coordonnées x et y passées en argument. Ne renvoie aucune valeur. La troisième valeur passée en argument est le type de point : 1 pour mettre un pixel, 0 pour en enlever un. | ||
Ligne 118 : | Ligne 109 : | ||
=== Bdisp_GetPoint_VRAM === | === Bdisp_GetPoint_VRAM === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bdisp_GetPoint_VRAM(int x,int y);</syntaxhighlight> |
Retourne la couleur du pixel dont les coordonnées sont passées en argument (1 pour un pixel allumé, 0 pour un pixel éteint). | Retourne la couleur du pixel dont les coordonnées sont passées en argument (1 pour un pixel allumé, 0 pour un pixel éteint). | ||
Ligne 126 : | Ligne 117 : | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_WriteGraph_DD(const DISPGRAPH *WriteGraph);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_WriteGraph_VRAM(const DISPGRAPH *WriteGraph);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_WriteGraph_DDVRAM(const DISPGRAPH *WriteGraph);</syntaxhighlight> | |
Ligne 136 : | Ligne 127 : | ||
− | + | <syntaxhighlight>typedef struct tag_DISPGRAPH { // déclarée dans "dispbios.h" | |
− | + | int x; // coordonnée x à gauche | |
− | + | int y; // coordonnée y à gauche | |
− | + | GRAPHDATA GraphData; // pointeur sur la structure contenant les données du bitmap (voir en dessous) | |
− | + | WRITEMODIFY WriteModify; // type d'écriture du graphe (IMB_WRITEMODIFY_NORMAL : écriture normale et IMB_WRITEMODIFY_REVERSE : écriture inverse). | |
− | + | WRITEKIND WriteKind; // mode d'écriture | |
− | + | } DISPGRAPH;</syntaxhighlight> | |
Ligne 162 : | Ligne 153 : | ||
La structure contenant les données du bitmap prend cette forme : | La structure contenant les données du bitmap prend cette forme : | ||
− | + | <syntaxhighlight>typedef struct tag_GRAPHDATA{ // déclarée dans "dispbios.h" | |
− | + | int width; // largeur du bitmap | |
− | + | int height; // hauteur du bitmap | |
− | + | unsigned char *pBitmap; // pointeur sur les données du bitmap | |
− | + | } GRAPHDATA;</syntaxhighlight> | |
Le bitmap est codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). | Le bitmap est codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). | ||
Ligne 180 : | Ligne 171 : | ||
prototypes : | prototypes : | ||
− | + | <syntaxhighlight>void Bdisp_ReadArea_DD (const DISPBOX *ReadArea,unsigned char *ReadData);</syntaxhighlight> | |
− | + | <syntaxhighlight>void Bdisp_ReadArea_VRAM (const DISPBOX *ReadArea,unsigned char *ReadData);</syntaxhighlight> | |
Cette fonction permet de stocker une zone de l'écran graphique (DD) ou de l'écran virtuel (VRAM) sur un tableau, codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). | Cette fonction permet de stocker une zone de l'écran graphique (DD) ou de l'écran virtuel (VRAM) sur un tableau, codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). | ||
Ligne 187 : | Ligne 178 : | ||
− | + | <syntaxhighlight>typedef struct tag_DISPBOX { // déclarée dans "dispbios.h" | |
− | + | int left; // 0~127 | |
− | + | int top; // 0~63 | |
− | + | int right; // 0~127 | |
− | + | int bottom; // 0~63 | |
− | + | } DISPBOX;</syntaxhighlight> | |
Ligne 203 : | Ligne 194 : | ||
prototype : | prototype : | ||
− | + | <syntaxhighlight>void Bdisp_DrawLineVRAM(int x1,int y1,int x2,int y2);</syntaxhighlight> | |
La fonction trace une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). | La fonction trace une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). | ||
Ligne 212 : | Ligne 203 : | ||
prototype : | prototype : | ||
− | + | <syntaxhighlight>void Bdisp_ClearLineVRAM(int x1,int y1,int x2,int y2);</syntaxhighlight> | |
La fonction efface une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). | La fonction efface une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). | ||
Ligne 219 : | Ligne 210 : | ||
=== locate === | === locate === | ||
− | prototype : | + | prototype : <syntaxhighlight>void locate(int x,int y);</syntaxhighlight> |
La fonction déplace le curseur à la position spécifiée par les arguments x et y de la forme (1~21;1~8). | La fonction déplace le curseur à la position spécifiée par les arguments x et y de la forme (1~21;1~8). | ||
Ligne 227 : | Ligne 218 : | ||
=== Print === | === Print === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Print(const unsigned char *str)</syntaxhighlight> |
La fonction affiche à la position du curseur la chaîne de caractères passée en arguments. Elle ne renvoie rien. | La fonction affiche à la position du curseur la chaîne de caractères passée en arguments. Elle ne renvoie rien. | ||
Ligne 235 : | Ligne 226 : | ||
=== PrintRev === | === PrintRev === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintRev(const unsigned char *str);</syntaxhighlight> |
La fonction affiche à la position du curseur la chaîne de caractères passée en arguments en couleurs inversées : pixels éteints sur fond de pixels allumés. Elle ne renvoie rien. | La fonction affiche à la position du curseur la chaîne de caractères passée en arguments en couleurs inversées : pixels éteints sur fond de pixels allumés. Elle ne renvoie rien. | ||
Ligne 243 : | Ligne 234 : | ||
=== PrintC === | === PrintC === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintC(const unsigned char *c);</syntaxhighlight> |
Selon Casio cette fonction sert à afficher un unique caractère. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction Print() ? | Selon Casio cette fonction sert à afficher un unique caractère. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction Print() ? | ||
Ligne 249 : | Ligne 240 : | ||
=== PrintRevC === | === PrintRevC === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintRevC(const unsigned char *c);</syntaxhighlight> |
Cette fonction sert à afficher un caractère en couleurs inversées : pixels éteints sur fond de pixels allumés. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction PrintRev() ? | Cette fonction sert à afficher un caractère en couleurs inversées : pixels éteints sur fond de pixels allumés. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction PrintRev() ? | ||
Ligne 255 : | Ligne 246 : | ||
=== PrintLine === | === PrintLine === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintLine(const unsigned char *str,int max);</syntaxhighlight> |
Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument. | Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument. | ||
Ligne 261 : | Ligne 252 : | ||
=== PrintRLine === | === PrintRLine === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintRLine(const unsigned char *str,int max)</syntaxhighlight> |
Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche) en couleurs inversées (pixels éteints sur fond de pixels allumés), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument. | Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche) en couleurs inversées (pixels éteints sur fond de pixels allumés), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument. | ||
Ligne 267 : | Ligne 258 : | ||
=== PrintXY === | === PrintXY === | ||
− | prototype: | + | prototype: <syntaxhighlight>void PrintXY(int x,int y,const unsigned char *str,int type)</syntaxhighlight> |
− | Cette fonction est très importante : elle permet d'afficher un texte passé en troisième argument aux coordonnées x et y précisées EN PIXELS et non en cases, de la forme : (0~127;0~63). | + | Cette fonction est très importante : elle permet d'afficher un texte passé en troisième argument aux coordonnées x et y précisées EN PIXELS et non en cases, de la forme : (0~127;0~63). Les caractères mesurent 6*8 pixels. |
L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur. | L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur. | ||
− | |||
=== PrintMini === | === PrintMini === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PrintMini(int x,int y,const unsigned char *str,int type);</syntaxhighlight> |
Cette fonction permet d'afficher à l'écran un texte plus petit (4*6 contre 6*8) aux coordonnées x et y passées en argument précisées en pixels, de la forme : (0~127;0~63). | Cette fonction permet d'afficher à l'écran un texte plus petit (4*6 contre 6*8) aux coordonnées x et y passées en argument précisées en pixels, de la forme : (0~127;0~63). | ||
Ligne 283 : | Ligne 273 : | ||
=== SaveDisp === | === SaveDisp === | ||
− | prototype : | + | prototype : <syntaxhighlight>void SaveDisp(unsigned char num);</syntaxhighlight> |
Permet de stocker l'image affichée à l'écran dans la RAM (mémoire vive, donc détruite à la fin de l'exécution du programme). L'argument num spécifie sur quelle image on doit la stocker : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour ressortir l'image, voir RestoreDisp(). | Permet de stocker l'image affichée à l'écran dans la RAM (mémoire vive, donc détruite à la fin de l'exécution du programme). L'argument num spécifie sur quelle image on doit la stocker : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour ressortir l'image, voir RestoreDisp(). | ||
Ligne 289 : | Ligne 279 : | ||
=== RestoreDisp === | === RestoreDisp === | ||
− | prototype : | + | prototype : <syntaxhighlight>void RestoreDisp(unsigned char num);</syntaxhighlight> |
Permet de ressortir une image enregistrée à l'écran. L'argument num spécifie l'image source : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour stocker l'image, voir SaveDisp(). | Permet de ressortir une image enregistrée à l'écran. L'argument num spécifie l'image source : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour stocker l'image, voir SaveDisp(). | ||
− | |||
=== PopUpWin === | === PopUpWin === | ||
− | prototype : | + | prototype : <syntaxhighlight>void PopUpWin(int n);</syntaxhighlight> |
Cette fonction affiche une fenêtre système, comme celles affichées par la calto lors d'une erreur. Vous lui donnez en argument la taille, en lignes, de la fenêtre (de 1 à 5 lignes en théorie, mais j'ai déjà utilisé la fonction avec l'argument 7 sans erreur). La fonction ne retourne rien. | Cette fonction affiche une fenêtre système, comme celles affichées par la calto lors d'une erreur. Vous lui donnez en argument la taille, en lignes, de la fenêtre (de 1 à 5 lignes en théorie, mais j'ai déjà utilisé la fonction avec l'argument 7 sans erreur). La fonction ne retourne rien. | ||
− | |||
== Fonctions de manipulation des fichiers == | == Fonctions de manipulation des fichiers == | ||
Ligne 304 : | Ligne 292 : | ||
=== Bfile_OpenFile === | === Bfile_OpenFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_OpenFile(const FONTCHARACTER *filename,int mode);</syntaxhighlight> |
Ligne 328 : | Ligne 316 : | ||
=== Bfile_OpenMainMemory === | === Bfile_OpenMainMemory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_OpenMainMemory(const unsigned char *name);</syntaxhighlight> |
Ouvre un fichier dans la mémoire principale. Le nom de fichier est de la forme : | Ouvre un fichier dans la mémoire principale. Le nom de fichier est de la forme : | ||
− | + | <syntaxhighlight>unsigned char name[]={“filename”};</syntaxhighlight> | |
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | ||
Ligne 339 : | Ligne 327 : | ||
La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative. | La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative. | ||
− | |||
=== Bfile_ReadFile === | === Bfile_ReadFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_ReadFile(int HANDLE,void *buf,int size,int readpos);</syntaxhighlight> |
Le premier argument est le handle récupéré à l'ouverture du fichier. Le second est le buffer qui reçoit les données (passage par pointeur), c'est-à-dire un tableau dont vous aurez bien prévu la taille afin d'éviter que les données soient perdues dans la RAM. L'argument size est la longueur (en octets) à lire. Le dernier argument est la positon à laquelle va commencer la lecture. Si elle vaut -1, la lecture commencera à la position indiquée par le curseur du fichier, que l'on peut modifier grâce à la fonction Bfile_SeekFile(); sinon la lecture commence à la position indiquée en argument. | Le premier argument est le handle récupéré à l'ouverture du fichier. Le second est le buffer qui reçoit les données (passage par pointeur), c'est-à-dire un tableau dont vous aurez bien prévu la taille afin d'éviter que les données soient perdues dans la RAM. L'argument size est la longueur (en octets) à lire. Le dernier argument est la positon à laquelle va commencer la lecture. Si elle vaut -1, la lecture commencera à la position indiquée par le curseur du fichier, que l'on peut modifier grâce à la fonction Bfile_SeekFile(); sinon la lecture commence à la position indiquée en argument. | ||
Ligne 350 : | Ligne 337 : | ||
=== Bfile_WriteFile === | === Bfile_WriteFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_WriteFile(int HANDLE,const void *buf,int size);</syntaxhighlight> |
Cette fonction est compliquée à utiliser, puisqu'elle ne marche pas comme il le faudrait... La fonction prend en premier paramètre le handle du fichier ouvert, en second le buffer à écrire (un tableau sur lequel sont stockées les données à enregistrer) et enfin le nombre d'octets à écrire. | Cette fonction est compliquée à utiliser, puisqu'elle ne marche pas comme il le faudrait... La fonction prend en premier paramètre le handle du fichier ouvert, en second le buffer à écrire (un tableau sur lequel sont stockées les données à enregistrer) et enfin le nombre d'octets à écrire. | ||
Ligne 361 : | Ligne 348 : | ||
=== Bfile_SeekFile === | === Bfile_SeekFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_SeekFile(int HANDLE,int pos);</syntaxhighlight> |
Cette fonction positionne le curseur du fichier dont le handle d'ouverture est passé en premier argument à la position indiquée par le second argument. Encore une fois, méfiez-vous : cette fonction ne produit pas toujours les résultats attendus, il arrive qu'elle n'ait aucun effet ! | Cette fonction positionne le curseur du fichier dont le handle d'ouverture est passé en premier argument à la position indiquée par le second argument. Encore une fois, méfiez-vous : cette fonction ne produit pas toujours les résultats attendus, il arrive qu'elle n'ait aucun effet ! | ||
Ligne 369 : | Ligne 356 : | ||
=== Bfile_CloseFile === | === Bfile_CloseFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_CloseFile(int HANDLE);</syntaxhighlight> |
Cette fonction ferme le fichier dont le handle d'ouverture est passé en argument. | Cette fonction ferme le fichier dont le handle d'ouverture est passé en argument. | ||
Ligne 377 : | Ligne 364 : | ||
=== Bfile_GetMediaFree === | === Bfile_GetMediaFree === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_GetMediaFree(enum DEVICE_TYPE devicetype,int *freebytes);</syntaxhighlight> |
Cette fonction permet d'obtenir la place libre sur la carte SD, la mémoire principale ou la mémoire de stockage. Ceci est essentiel pour éviter les erreurs lorsque vous essayez d'enregistrer des fichiers. Le premier argument représente la mémoire étudiée (DEVICE_MAIN_MEMORY : méémoire principale, DEVICE_STORAGE : mémoire de stockage, DEVICE_SD_CARD : carte SD). Le second argument est l'adresse de la variable sur laquelle stocker l'espace libre (passage par pointeur). La fonction renvoie 0 si tout se passe bien et une valeur négative représentant un code d'erreur si elle échoue (pourquoi Casio n'a pas tout simplement fait une fonction qui renvoie l'espace libre, et qui éviterait de passer par les pointeurs ? Encore une logique étrange...). | Cette fonction permet d'obtenir la place libre sur la carte SD, la mémoire principale ou la mémoire de stockage. Ceci est essentiel pour éviter les erreurs lorsque vous essayez d'enregistrer des fichiers. Le premier argument représente la mémoire étudiée (DEVICE_MAIN_MEMORY : méémoire principale, DEVICE_STORAGE : mémoire de stockage, DEVICE_SD_CARD : carte SD). Le second argument est l'adresse de la variable sur laquelle stocker l'espace libre (passage par pointeur). La fonction renvoie 0 si tout se passe bien et une valeur négative représentant un code d'erreur si elle échoue (pourquoi Casio n'a pas tout simplement fait une fonction qui renvoie l'espace libre, et qui éviterait de passer par les pointeurs ? Encore une logique étrange...). | ||
Ligne 384 : | Ligne 371 : | ||
=== Bfile_GetFileSize === | === Bfile_GetFileSize === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_GetFileSize(int HANDLE);</syntaxhighlight> |
Cette fonction renvoie la taille du fichier dont le handle d'ouverture est passé en argument. Elle est très utile si vous créez des fichiers dont la taille varie à chaque enregistrement. Elle renvoie une valeur négative représentant un code d'erreur si elle échoue. | Cette fonction renvoie la taille du fichier dont le handle d'ouverture est passé en argument. Elle est très utile si vous créez des fichiers dont la taille varie à chaque enregistrement. Elle renvoie une valeur négative représentant un code d'erreur si elle échoue. | ||
Ligne 390 : | Ligne 377 : | ||
=== Bfile_CreateFile === | === Bfile_CreateFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_CreateFile(const FONTCHARACTER *filename,int size);</syntaxhighlight> |
Crée le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est : | Crée le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est : | ||
− | + | <syntaxhighlight>FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};</syntaxhighlight> | |
Si votre fichier se trouve dans la mémoire de stockage, choisissez comme répertoire "fls", pour la carte SD choisissez "crd". Le nom de fichier fait maximum 8 caractères, plus le point et votre extension (choisissez celle que vous voulez, cela ne change rien au codage du fichier). La chaîne est terminée par un 0. | Si votre fichier se trouve dans la mémoire de stockage, choisissez comme répertoire "fls", pour la carte SD choisissez "crd". Le nom de fichier fait maximum 8 caractères, plus le point et votre extension (choisissez celle que vous voulez, cela ne change rien au codage du fichier). La chaîne est terminée par un 0. | ||
Ligne 402 : | Ligne 389 : | ||
=== Bfile_CreateDirectory === | === Bfile_CreateDirectory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_CreateDirectory(const FONTCHARACTER *pathname);</syntaxhighlight> |
Crée un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est : | Crée un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est : | ||
− | + | <syntaxhighlight>FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','d','i','r','n','a','m','e',0};</syntaxhighlight> | |
Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0. | Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0. | ||
Ligne 413 : | Ligne 400 : | ||
=== Bfile_CreateMainMemory === | === Bfile_CreateMainMemory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_CreateMainMemory(const unsigned char *name);</syntaxhighlight> |
Crée un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme : | Crée un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme : | ||
− | + | <syntaxhighlight>unsigned char name[]={“filename”};</syntaxhighlight> | |
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | ||
Ligne 425 : | Ligne 412 : | ||
=== Bfile_RenameMainMemory === | === Bfile_RenameMainMemory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_RenameMainMemory(const unsigned char *oldname, unsigned char *newname);</syntaxhighlight> |
Renomme le fichier dont le nom est passé en premier argument avec le nom passé en second argument. Les noms sont de la forme : | Renomme le fichier dont le nom est passé en premier argument avec le nom passé en second argument. Les noms sont de la forme : | ||
− | + | <syntaxhighlight>unsigned char name[]={“filename”};</syntaxhighlight> | |
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | ||
Ligne 436 : | Ligne 423 : | ||
=== Bfile_DeleteFile === | === Bfile_DeleteFile === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_DeleteFile(const FONTCHARACTER *filename);</syntaxhighlight> |
Supprime le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est : | Supprime le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est : | ||
− | + | <syntaxhighlight>FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};</syntaxhighlight> | |
Cette fonction sert généralement lorsque vous voulez recréer le fichier (ou si ça vous amuse de casser définitivement l'enregistrement). La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec. | Cette fonction sert généralement lorsque vous voulez recréer le fichier (ou si ça vous amuse de casser définitivement l'enregistrement). La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec. | ||
Ligne 446 : | Ligne 433 : | ||
=== Bfile_DeleteDirectory === | === Bfile_DeleteDirectory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_DeleteDirectory(const FONTCHARACTER *pathname);</syntaxhighlight> |
Supprime un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est : | Supprime un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est : | ||
− | + | <syntaxhighlight>FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','d','i','r','n','a','m','e',0};</syntaxhighlight> | |
Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0. | Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0. | ||
Ligne 458 : | Ligne 445 : | ||
=== Bfile_DeleteMainMemory === | === Bfile_DeleteMainMemory === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_DeleteMainMemory(const unsigned char *name);</syntaxhighlight> |
Supprime un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme : | Supprime un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme : | ||
− | + | <syntaxhighlight>unsigned char name[]={“filename”};</syntaxhighlight> | |
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire. | ||
Ligne 470 : | Ligne 457 : | ||
=== Bfile_FindFirst === | === Bfile_FindFirst === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_FindFirst(const FONTCHARACTER *pathname,int *FindHandle,FONTCHARACTER *foundfile,FILE_INFO *fileinfo);</syntaxhighlight> |
Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension. | Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension. | ||
Ligne 476 : | Ligne 463 : | ||
Cette fonction permet de trouver le premier fichier (dans l'ordre alphabétique) correspondant au profil de recherche. Le premier argument est ce profil, de la forme : | Cette fonction permet de trouver le premier fichier (dans l'ordre alphabétique) correspondant au profil de recherche. Le premier argument est ce profil, de la forme : | ||
− | + | <syntaxhighlight>FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','*','.','e','x','t',0};</syntaxhighlight> | |
On précise bien "fls" pour la mémoire de stockage, "crd" pour la carte SD. L'extension doit bien être choisie, en fonction du type de fichiers que vous recherchez. | On précise bien "fls" pour la mémoire de stockage, "crd" pour la carte SD. L'extension doit bien être choisie, en fonction du type de fichiers que vous recherchez. | ||
Ligne 486 : | Ligne 473 : | ||
Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme : | Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme : | ||
− | + | <syntaxhighlight>typedef struct tag_FILE_INFO { // déclarée dans "filebios.h" | |
− | + | unsigned short id; // index du fichier | |
− | + | unsigned short type; // type de fichier | |
− | + | unsigned long fsize; // taille du fichier (en octets) | |
− | + | unsigned long dsize; // taille des données (le header du fichier non compté) | |
− | + | unsigned int property; // renseigne si le fichier est entièrement rempli (si oui, property=0) | |
− | + | unsigned long address; // adresse la plus haute des données | |
− | + | } FILE_INFO;</syntaxhighlight> | |
Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (''DT_DIRECTORY'' : répertoire, DT_FILE : fichier, ''DT_ADDIN_APP'' : add-in, ''DT_EACT'' : e-Activity, ''DT_LANGUAGE'' : langue, DT_BITMAP : bitmap, ''DT_MAINMEM'': donnée de la mémoire principale, ''DT_TEMP'' : fichier temporaire, ''DT_DOT'' : répertoire courant, ''DT_DOTDOT'' : répertoire parent, ''DT_VOLUME'' : libellé de volume). | Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (''DT_DIRECTORY'' : répertoire, DT_FILE : fichier, ''DT_ADDIN_APP'' : add-in, ''DT_EACT'' : e-Activity, ''DT_LANGUAGE'' : langue, DT_BITMAP : bitmap, ''DT_MAINMEM'': donnée de la mémoire principale, ''DT_TEMP'' : fichier temporaire, ''DT_DOT'' : répertoire courant, ''DT_DOTDOT'' : répertoire parent, ''DT_VOLUME'' : libellé de volume). | ||
Ligne 507 : | Ligne 494 : | ||
=== Bfile_FindNext === | === Bfile_FindNext === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_FindNext(int FindHandle, FONTCHARACTER *foundfile, FILE_INFO *fileinfo);</syntaxhighlight> |
Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension. | Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension. | ||
Ligne 517 : | Ligne 504 : | ||
Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme : | Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme : | ||
− | + | <syntaxhighlight>typedef struct tag_FILE_INFO { // déclarée dans "filebios.h" | |
− | + | unsigned short id; // index du fichier | |
− | + | unsigned short type; // type de fichier | |
− | + | unsigned long fsize; // taille du fichier (en octets) | |
− | + | unsigned long dsize; // taille des données (le header du fichier non compté) | |
− | + | unsigned int property; // renseigne si le fichier est entièrement rempli (si oui, property=0) | |
− | + | unsigned long address; // adresse la plus haute des données | |
− | + | } FILE_INFO;</syntaxhighlight> | |
Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (''DT_DIRECTORY'' : répertoire, ''DT_FILE'' : fichier, ''DT_ADDIN_APP'' : add-in, ''DT_EACT'' : e-Activity, ''DT_LANGUAGE'' : langue, ''DT_BITMAP'' : bitmap, ''DT_MAINMEM'': donnée de la mémoire principale, ''DT_TEMP'' : fichier temporaire, ''DT_DOT'' : répertoire courant, ''DT_DOTDOT'' : répertoire parent, ''DT_VOLUME'' : libellé de volume). | Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (''DT_DIRECTORY'' : répertoire, ''DT_FILE'' : fichier, ''DT_ADDIN_APP'' : add-in, ''DT_EACT'' : e-Activity, ''DT_LANGUAGE'' : langue, ''DT_BITMAP'' : bitmap, ''DT_MAINMEM'': donnée de la mémoire principale, ''DT_TEMP'' : fichier temporaire, ''DT_DOT'' : répertoire courant, ''DT_DOTDOT'' : répertoire parent, ''DT_VOLUME'' : libellé de volume). | ||
Ligne 538 : | Ligne 525 : | ||
=== Bfile_FindClose === | === Bfile_FindClose === | ||
− | prototype : | + | prototype : <syntaxhighlight>int Bfile_FindClose(int FindHandle);</syntaxhighlight> |
Cette fonction ferme la recherche dont le handle est passé en argument. La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec. | Cette fonction ferme la recherche dont le handle est passé en argument. La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec. | ||
Ligne 547 : | Ligne 534 : | ||
=== Bkey_Set_RepeatTime === | === Bkey_Set_RepeatTime === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Bkey_Set_RepeatTime(long FirstCount,long NextCount);</syntaxhighlight> |
Voilà une fonction bien étrange pour commencer notre travail sur le clavier. Cette fonction définit les valeurs du temps de déclenchement entre l'appui d'une touche et le signal et le temps de répétition de la touche. Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25). Traduction : votre calculatrice répète virtuellement l'appui d'une touche... | Voilà une fonction bien étrange pour commencer notre travail sur le clavier. Cette fonction définit les valeurs du temps de déclenchement entre l'appui d'une touche et le signal et le temps de répétition de la touche. Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25). Traduction : votre calculatrice répète virtuellement l'appui d'une touche... | ||
Ligne 555 : | Ligne 542 : | ||
=== Bkey_Get_RepeatTime === | === Bkey_Get_RepeatTime === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Bkey_Get_RepeatTime(long *FirstCount,long *NextCount);</syntaxhighlight> |
Cette fonction récupère les valeurs du temps de déclenchement et du temps de répétition de la touche, définies par la fonction Bkey_Set_RepeatTime(). Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25). | Cette fonction récupère les valeurs du temps de déclenchement et du temps de répétition de la touche, définies par la fonction Bkey_Set_RepeatTime(). Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25). | ||
Ligne 563 : | Ligne 550 : | ||
=== Bkey_Set_RepeatTime_Default === | === Bkey_Set_RepeatTime_Default === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Bkey_Set_RepeatTime_Default(void)</syntaxhighlight> |
Cette fonction réinitialise les valeurs du temps de déclenchement et du temps de répétition de la touche. Elle ne reçoit aucun argument et ne retourne aucune valeur. | Cette fonction réinitialise les valeurs du temps de déclenchement et du temps de répétition de la touche. Elle ne reçoit aucun argument et ne retourne aucune valeur. | ||
Ligne 569 : | Ligne 556 : | ||
=== GetKeyWait === | === GetKeyWait === | ||
− | prototype : | + | prototype : <syntaxhighlight>int GetKeyWait(int sel,int time,int menu,unsigned int *keycode);</syntaxhighlight> |
Cette fonction attend l'appui d'une touche et donne sa valeur. On lui donne en premier argument le type d'attente (''KEYWAIT_HALTON_TIMEROFF'' : attend la première arrivée dans le buffer de touches, ''KEYWAIT_HALTOFF_TIMEROFF'' : si le buffer de touches est vide, la fonction se termine immédiatement, ''KEYWAIT_HALTON_TIMERON'' : si aucune touche n'est pressée avant la fin du timer spécifié par le second argument en secondes, la fonction se termine). Si le troisième argument a pour valeur 0, la touche MENU mène au menu principal, si elle a pour valeur 1 la onction retourne la valeur de la touche MENU. La quatrième argument est l'adresse de la variable sur laquelle stocker le code de la touche appuyée (passage par pointeur). | Cette fonction attend l'appui d'une touche et donne sa valeur. On lui donne en premier argument le type d'attente (''KEYWAIT_HALTON_TIMEROFF'' : attend la première arrivée dans le buffer de touches, ''KEYWAIT_HALTOFF_TIMEROFF'' : si le buffer de touches est vide, la fonction se termine immédiatement, ''KEYWAIT_HALTON_TIMERON'' : si aucune touche n'est pressée avant la fin du timer spécifié par le second argument en secondes, la fonction se termine). Si le troisième argument a pour valeur 0, la touche MENU mène au menu principal, si elle a pour valeur 1 la onction retourne la valeur de la touche MENU. La quatrième argument est l'adresse de la variable sur laquelle stocker le code de la touche appuyée (passage par pointeur). | ||
Ligne 577 : | Ligne 564 : | ||
=== GetKey === | === GetKey === | ||
− | prototype : | + | prototype : <syntaxhighlight>int GetKey(unsigned int *keycode);</syntaxhighlight> |
Cette fonction attend l'appui d'une touche et écrit sa valeur sur la variable donnée en argument (passage par pointeur). Elle retourne 1 pour une touche alphanumérique, et 0 pour une touche de contrôle. L'appui de MENU amène au menu principal, et SHIFT/AC éteint la calculatrice. | Cette fonction attend l'appui d'une touche et écrit sa valeur sur la variable donnée en argument (passage par pointeur). Elle retourne 1 pour une touche alphanumérique, et 0 pour une touche de contrôle. L'appui de MENU amène au menu principal, et SHIFT/AC éteint la calculatrice. | ||
Ligne 583 : | Ligne 570 : | ||
=== IsKeyDown === | === IsKeyDown === | ||
− | prototype : | + | prototype : <syntaxhighlight>IsKeyDown(int keycode);</syntaxhighlight> |
Cette fonction retourne 1 si la touche dont on passe le code en argument est pressée, et 0 si elle ne l'est pas. | Cette fonction retourne 1 si la touche dont on passe le code en argument est pressée, et 0 si elle ne l'est pas. | ||
Ligne 589 : | Ligne 576 : | ||
=== IsKeyUp === | === IsKeyUp === | ||
− | prototype : | + | prototype : <syntaxhighlight>IsKeyUp(int keycode);</syntaxhighlight> |
Cette fonction retourne 0 si la touche dont on passe le code en argument est pressée, et 1 si elle ne l'est pas. | Cette fonction retourne 0 si la touche dont on passe le code en argument est pressée, et 1 si elle ne l'est pas. | ||
Ligne 598 : | Ligne 585 : | ||
=== SetTimer === | === SetTimer === | ||
− | prototype : | + | prototype : <syntaxhighlight>int SetTimer(int ID,int elapse,void (*hander)(void));</syntaxhighlight> |
− | Une fonction pas si simple à utiliser mais TRES utile. Elle permet de lancer un timer qui appellera une fonction à intervalle régulier. En premier argument on passe l'ID du timer (de | + | Une fonction pas si simple à utiliser mais TRES utile. Elle permet de lancer un timer qui appellera une fonction à intervalle régulier. En premier argument on passe l'ID du timer (de 1 à 5). En second argument le temps entre 2 répétitions (en millisecondes), et enfin la fonction à appeler. Attention, le passage de la fonction par pointeur s'effectue avec uniquement le nom de la fonction, sans parenthèses (un timer ne peut pas passer d'arguments). |
Si la fonction réussit, elle retourne l'ID du timer (utilité ?). Sinon elle retourne une valeur négative correspondant à un code d'erreur. Un échec survient si un paramètre est mauvais ou si le timer est utilisé. | Si la fonction réussit, elle retourne l'ID du timer (utilité ?). Sinon elle retourne une valeur négative correspondant à un code d'erreur. Un échec survient si un paramètre est mauvais ou si le timer est utilisé. | ||
− | |||
=== KillTimer === | === KillTimer === | ||
− | prototype : | + | prototype : <syntaxhighlight>int KillTimer(int ID);</syntaxhighlight> |
− | |||
− | |||
+ | Cette fonction arrête le timer dont on donne l'ID en argument (de 1 à 5). Elle retourne l'ID en cas de succès (utilité ?), ou un code d'erreur correspondant à une valeur négative en cas d'échec (c'est-à-dire si l'ID ne correspond à aucun timer en marche). | ||
=== Sleep === | === Sleep === | ||
− | prototype : | + | prototype : <syntaxhighlight>void Sleep(int millisecond);</syntaxhighlight> |
Cette fonction est TRES utilisée et essentielle pour contrôler la vitesse d'exécution d'un programme. Elle met la calculatrice en pause durant le temps spécifié en argument en millisecondes. Elle ne retourne rien. | Cette fonction est TRES utilisée et essentielle pour contrôler la vitesse d'exécution d'un programme. Elle met la calculatrice en pause durant le temps spécifié en argument en millisecondes. Elle ne retourne rien. | ||
+ | En théorie une telle fonction devrait mettre en pause le processeur pour réduire la consommation d'énergie, en pratique ce n'est pas le cas. Considérez-la comme un boucle d'attente active (ce qu'elle est). | ||
=== SetQuitHandler === | === SetQuitHandler === | ||
− | prototype : | + | prototype : <syntaxhighlight>void SetQuitHandler(void (*callback)(void));</syntaxhighlight> |
Cette fonction définit la fonction à appeler juste avant de quitter l'add-in. C'est utile lorsque vous voulez vérifier que vous n'avez laissé aucune fuite de mémoire, ou juste dire au revoir au joueur. Attention, le passage de la fonction par pointeur s'effectue avec uniquement le nom de la fonction, sans parenthèses (on ne peut pas ici passer d'arguments). La fonction ne retourne rien. | Cette fonction définit la fonction à appeler juste avant de quitter l'add-in. C'est utile lorsque vous voulez vérifier que vous n'avez laissé aucune fuite de mémoire, ou juste dire au revoir au joueur. Attention, le passage de la fonction par pointeur s'effectue avec uniquement le nom de la fonction, sans parenthèses (on ne peut pas ici passer d'arguments). La fonction ne retourne rien. | ||
Ligne 631 : | Ligne 617 : | ||
Merci à Pierrotll pour ses éclairages par rapport à plusieurs fonctions. | Merci à Pierrotll pour ses éclairages par rapport à plusieurs fonctions. | ||
− | [[Catégorie: | + | [[Catégorie:Graph 75/85/95]] |
+ | [[Catégorie:C/C++/Asm]] |
Version actuelle datée du 29 avril 2018 à 14:35
La librairie "fxlib.h" est la librairie qui contient toutes les fonctions de bases du kit de développement de Casio pour Graph 75/85/95 (SD). Il existe d'autres librairies communautaires bien plus simples et puissantes, mais certaines fonctions de "fxlib.h" sont nécessaires, et n'ont pas d'équivalent dans les librairies non-officielles.
Dans cette documentation vous découvrirez un aperçu des fonctions, comment les utiliser et leur utilité. Si il vous manque des informations, vous pouvez toujours venir vous informer sur les forums Casio comme Planète-Casio côté francophone.
Sommaire
- 1 Fonctions d'affichage
- 1.1 Bdisp_PutDisp_DD
- 1.2 Bdisp_AllClr_DD/ Bdisp_AllClr_VRAM/ Bdisp_AllClr_DDVRAM
- 1.3 Bdisp_AreaClr_DD/ Bdisp_AreaClr_VRAM/ Bdisp_AreaClr_DDVRAM
- 1.4 Bdisp_AreaReverseVRAM
- 1.5 Bdisp_GetDisp_DD/ Bdisp_GetDisp_VRAM
- 1.6 Bdisp_PutDispArea_DD
- 1.7 Bdisp_SetPoint_DD/ Bdisp_SetPoint_VRAM/ Bdisp_SetPoint_DDVRAM
- 1.8 Bdisp_GetPoint_VRAM
- 1.9 Bdisp_WriteGraph_DD/ Bdisp_WriteGraph_VRAM/ Bdisp_WriteGraph_DDVRAM
- 1.10 Bdisp_ReadArea_DD / Bdisp_ReadArea_VRAM
- 1.11 Bdisp_DrawLineVRAM
- 1.12 Bdisp_ClearLineVRAM
- 1.13 locate
- 1.14 Print
- 1.15 PrintRev
- 1.16 PrintC
- 1.17 PrintRevC
- 1.18 PrintLine
- 1.19 PrintRLine
- 1.20 PrintXY
- 1.21 PrintMini
- 1.22 SaveDisp
- 1.23 RestoreDisp
- 1.24 PopUpWin
- 2 Fonctions de manipulation des fichiers
- 2.1 Bfile_OpenFile
- 2.2 Bfile_OpenMainMemory
- 2.3 Bfile_ReadFile
- 2.4 Bfile_WriteFile
- 2.5 Bfile_SeekFile
- 2.6 Bfile_CloseFile
- 2.7 Bfile_GetMediaFree
- 2.8 Bfile_GetFileSize
- 2.9 Bfile_CreateFile
- 2.10 Bfile_CreateDirectory
- 2.11 Bfile_CreateMainMemory
- 2.12 Bfile_RenameMainMemory
- 2.13 Bfile_DeleteFile
- 2.14 Bfile_DeleteDirectory
- 2.15 Bfile_DeleteMainMemory
- 2.16 Bfile_FindFirst
- 2.17 Bfile_FindNext
- 2.18 Bfile_FindClose
- 3 Fonctions de contrôle du clavier
- 4 Fonctions de gestion du temps
- 5 Sources et droits
Fonctions d'affichage
Bdisp_PutDisp_DD
prototype :
void Bdisp_PutDisp_DD(void);
Affiche à l'écran le contenu de la VRAM (buffer stockant le contenu de l'écran virtuel). Ne prend aucun argument et ne renvoie aucune valeur.
Bdisp_AllClr_DD/ Bdisp_AllClr_VRAM/ Bdisp_AllClr_DDVRAM
prototypes :
void Bdisp_AllClr_DD(void);
void Bdisp_AllClr_VRAM(void);
void Bdisp_AllClr_DDVRAM(void);
Ne prend aucun argument et ne renvoie aucune valeur.
Bdisp_AllClr_DDVRAM() efface l'écran et la VRAM. Pour effacer uniquement l'écran, utiliser Bdisp_AllClr_DD(). Pour effacer uniquement la VRAM, utiliser Bdisp_AllClr_VRAM().
Bdisp_AreaClr_DD/ Bdisp_AreaClr_VRAM/ Bdisp_AreaClr_DDVRAM
prototypes :
void Bdisp_AreaClr_DD(const DISPBOX *pArea);
void Bdisp_AreaClr_VRAM(const DISPBOX *pArea);
void Bdisp_AreaClr_DDVRAM(const DISPBOX *pArea);
La fonction ne renvoie aucune valeur.
Efface une partie de l'écran. L'argument à passer (par pointeur) à cette fonction est une structure de la forme :
typedef struct tag_DISPBOX{ // déclarée dans "dispbios.h" int left; // 0~127 int top; // 0~63 int right; // 0~127 int bottom; // 0~63 } DISPBOX;
Bdisp_AreaReverseVRAM
prototype :
void Bdisp_AreaReverseVRAM( int x1, // coordonnée x à gauche int y1, // coordonnée y en haut int x2, // coordonnée x à droite int y2 // coordonnée y en bas );
La fonction ne renvoie aucune valeur. Inverse une zone de la VRAM (pixel éteint en allumé et allumé en éteint). Passez-lui en argument les coordonnées de la zone à inverser, comme indiqué ci-dessus).
Bdisp_GetDisp_DD/ Bdisp_GetDisp_VRAM
prototypes :
void Bdisp_GetDisp_DD(unsigned char * pData);
void Bdisp_GetDisp_VRAM(unsigned char * pData);
La fonction ne renvoie aucune valeur. Elle permet de stocker dans un tableau le bitmap des écrans de la VRAM (écran virtuel) ou du DD (écran graphique). On lui passe en argument (par pointeur) le tableau où le bitmap sera stocké.
La documentation ne précise rien de plus à propos de cette fonction, si ce n'est que le tableau sur lequel est stocké le bitmap doit avoir une taille de 1024 octets. On peut donc penser que la méthode de codage utilisée par Casio est : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). Si l'on fait le calcul : (128*64)/8 = 1024.
Bdisp_PutDispArea_DD
prototype :void Bdisp_PutDispArea_DD(const DISPBOX *pArea);
Une des plus belles erreurs de la documentation de Casio ! Dans la doc ils ont mis les explications d'une autre fonction... Cette fonction permet d'afficher à l'écran graphique une zone de l'écran virtuel. On peut tout de même deviner que cette fonction demande en argument une structure (passage par pointeur) de la forme :
typedef struct tag_DISPBOX{ // déclarée dans "dispbios.h" int left; // 0~127 int top; // 0~63 int right; // 0~127 int bottom; // 0~63 } DISPBOX;
Bdisp_SetPoint_DD/ Bdisp_SetPoint_VRAM/ Bdisp_SetPoint_DDVRAM
prototypes :
void Bdisp_SetPoint_DD(int x,int y,unsigned char point);
void Bdisp_SetPoint_VRAM(int x,int y,unsigned char point);
void Bdisp_SetPoint_DDVRAM(int x,int y,unsigned char point);
Place ou supprime un pixel aux coordonnées x et y passées en argument. Ne renvoie aucune valeur. La troisième valeur passée en argument est le type de point : 1 pour mettre un pixel, 0 pour en enlever un. La première fonction permet d'agir sur l'écran graphique, la seconde dans la VRAM, et la troisième dans les deux.
Bdisp_GetPoint_VRAM
prototype :int Bdisp_GetPoint_VRAM(int x,int y);
Retourne la couleur du pixel dont les coordonnées sont passées en argument (1 pour un pixel allumé, 0 pour un pixel éteint).
Bdisp_WriteGraph_DD/ Bdisp_WriteGraph_VRAM/ Bdisp_WriteGraph_DDVRAM
prototypes :
void Bdisp_WriteGraph_DD(const DISPGRAPH *WriteGraph);
void Bdisp_WriteGraph_VRAM(const DISPGRAPH *WriteGraph);
void Bdisp_WriteGraph_DDVRAM(const DISPGRAPH *WriteGraph);
Affiche un bitmap sur la VRAM ou l'écran (ou les deux). Ne renvoie aucune valeur. Les arguments sont passés (par pointeur) dans une structure de la forme :
typedef struct tag_DISPGRAPH { // déclarée dans "dispbios.h" int x; // coordonnée x à gauche int y; // coordonnée y à gauche GRAPHDATA GraphData; // pointeur sur la structure contenant les données du bitmap (voir en dessous) WRITEMODIFY WriteModify; // type d'écriture du graphe (IMB_WRITEMODIFY_NORMAL : écriture normale et IMB_WRITEMODIFY_REVERSE : écriture inverse). WRITEKIND WriteKind; // mode d'écriture } DISPGRAPH;
Le mode d'écriture peut être :
OR = allumé si le pixel de l'écran OU le pixel du bitmap sont allumés
AND = allumé si le pixel de l'écran ET le pixel du bitmap sont allumés
XOR = allumé si le pixel de l'écran OU le pixel du bitmap sont allumés, MAIS PAS LES DEUX
La structure contenant les données du bitmap prend cette forme :
typedef struct tag_GRAPHDATA{ // déclarée dans "dispbios.h" int width; // largeur du bitmap int height; // hauteur du bitmap unsigned char *pBitmap; // pointeur sur les données du bitmap } GRAPHDATA;
Le bitmap est codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0).
On peut s'interroger sur l'utilité de faire des fonctions avec passage d'arguments aussi complexe, mais n'oubliez pas que nous sommes chez Casio.
Bdisp_ReadArea_DD / Bdisp_ReadArea_VRAM
prototypes :
void Bdisp_ReadArea_DD (const DISPBOX *ReadArea,unsigned char *ReadData);
void Bdisp_ReadArea_VRAM (const DISPBOX *ReadArea,unsigned char *ReadData);
Cette fonction permet de stocker une zone de l'écran graphique (DD) ou de l'écran virtuel (VRAM) sur un tableau, codé de la manière suivante : on regroupe les pixels par groupe de 8 (un octet), où chaque bit prend la valeur d'un pixel (allumé : 1, éteint : 0). La fonction ne retourne rien. On lui passe en argument (par pointeur) le tableau récepteur du bitmap et une structure de la forme :
typedef struct tag_DISPBOX { // déclarée dans "dispbios.h" int left; // 0~127 int top; // 0~63 int right; // 0~127 int bottom; // 0~63 } DISPBOX;
Bdisp_DrawLineVRAM
prototype :
void Bdisp_DrawLineVRAM(int x1,int y1,int x2,int y2);
La fonction trace une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). Elle ne retourne rien.
Bdisp_ClearLineVRAM
prototype :
void Bdisp_ClearLineVRAM(int x1,int y1,int x2,int y2);
La fonction efface une ligne entre deux points dont les coordonnées sont entières et de la forme : (0~127;0~63). Elle ne retourne rien.
locate
prototype :void locate(int x,int y);
La fonction déplace le curseur à la position spécifiée par les arguments x et y de la forme (1~21;1~8).
Chaque "case" de l'écran correspond à un rectangle de 6*8 pixels.
void Print(const unsigned char *str)
La fonction affiche à la position du curseur la chaîne de caractères passée en arguments. Elle ne renvoie rien.
Attention les textes trop longs ne sont pas renvoyés à la ligne ! C'est à vous de découper votre chaîne et de déplacer le curseur via la fonction locate().
PrintRev
prototype :void PrintRev(const unsigned char *str);
La fonction affiche à la position du curseur la chaîne de caractères passée en arguments en couleurs inversées : pixels éteints sur fond de pixels allumés. Elle ne renvoie rien.
Attention les textes trop longs ne sont pas renvoyés à la ligne ! C'est à vous de découper votre chaîne et de déplacer le curseur via la fonction locate().
PrintC
prototype :void PrintC(const unsigned char *c);
Selon Casio cette fonction sert à afficher un unique caractère. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction Print() ?
PrintRevC
prototype :void PrintRevC(const unsigned char *c);
Cette fonction sert à afficher un caractère en couleurs inversées : pixels éteints sur fond de pixels allumés. On lui passe en argument la chaîne de caractères à afficher, et elle ne renvoie rien. Après, pourquoi une fonction spécifique qui produit le même résultat que la fonction PrintRev() ?
PrintLine
prototype :void PrintLine(const unsigned char *str,int max);
Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument.
PrintRLine
prototype :void PrintRLine(const unsigned char *str,int max)
Cette fonction affiche une chaîne de caractère passée en premier argument à la position du curseur (définie par locate() ou positionnée de base en haut à gauche) en couleurs inversées (pixels éteints sur fond de pixels allumés), mais la spécificité de cette fonction est que l'affichage de la chaîne s'arrête à l'abscisse passée en second argument.
PrintXY
prototype:void PrintXY(int x,int y,const unsigned char *str,int type)
Cette fonction est très importante : elle permet d'afficher un texte passé en troisième argument aux coordonnées x et y précisées EN PIXELS et non en cases, de la forme : (0~127;0~63). Les caractères mesurent 6*8 pixels.
L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur.
PrintMini
prototype :void PrintMini(int x,int y,const unsigned char *str,int type);
Cette fonction permet d'afficher à l'écran un texte plus petit (4*6 contre 6*8) aux coordonnées x et y passées en argument précisées en pixels, de la forme : (0~127;0~63).
L'argument type correspond à 0 pour affichage normal et 1 pour affichage en couleurs inversées (pixels éteints sur fond de pixels allumés). La fonction ne renvoie aucune valeur.
SaveDisp
prototype :void SaveDisp(unsigned char num);
Permet de stocker l'image affichée à l'écran dans la RAM (mémoire vive, donc détruite à la fin de l'exécution du programme). L'argument num spécifie sur quelle image on doit la stocker : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour ressortir l'image, voir RestoreDisp().
RestoreDisp
prototype :void RestoreDisp(unsigned char num);
Permet de ressortir une image enregistrée à l'écran. L'argument num spécifie l'image source : SAVEDISP_PAGE1, SAVEDISP_PAGE2, SAVEDISP_PAGE3. La fonction ne renvoie aucune valeur. Pour stocker l'image, voir SaveDisp().
PopUpWin
prototype :void PopUpWin(int n);
Cette fonction affiche une fenêtre système, comme celles affichées par la calto lors d'une erreur. Vous lui donnez en argument la taille, en lignes, de la fenêtre (de 1 à 5 lignes en théorie, mais j'ai déjà utilisé la fonction avec l'argument 7 sans erreur). La fonction ne retourne rien.
Fonctions de manipulation des fichiers
Bfile_OpenFile
prototype :int Bfile_OpenFile(const FONTCHARACTER *filename,int mode);
Ouvre le fichier dont le nom est passé en argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};
Si votre fichier se trouve dans la mémoire de stockage, choisissez comme répertoire "fls", pour la carte SD choisissez "crd". Le nom de fichier fait maximum 8 caractères, plus le point et votre extension (choisissez celle que vous voulez, cela ne change rien au codage du fichier). La chaîne est terminée par un 0.
L'argument mode correspond à :
_OPENMODE_READ : lecture seule.
_OPENMODE_WRITE : écriture seule.
_OPENMODE_READWRITE : lecture et écriture.
_OPENMODE_READWRITE_SHARE : lecture et écriture exclusives à ce programme (si un autre programme y touche, il aura uniquement un code d'erreur).
La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative.
Bfile_OpenMainMemory
prototype :int Bfile_OpenMainMemory(const unsigned char *name);
Ouvre un fichier dans la mémoire principale. Le nom de fichier est de la forme :
unsigned char name[]={“filename”};
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire.
La valeur retournée est un handle. Il est ESSENTIEL de conserver ce handle tout au long de la lecture ou de l'écriture du fichier, il permet en effet d'accéder au fichier et de le fermer ! Si il y a erreur à l'ouverture du fichier, le handle retourné aura une valeur négative.
Bfile_ReadFile
prototype :int Bfile_ReadFile(int HANDLE,void *buf,int size,int readpos);
Le premier argument est le handle récupéré à l'ouverture du fichier. Le second est le buffer qui reçoit les données (passage par pointeur), c'est-à-dire un tableau dont vous aurez bien prévu la taille afin d'éviter que les données soient perdues dans la RAM. L'argument size est la longueur (en octets) à lire. Le dernier argument est la positon à laquelle va commencer la lecture. Si elle vaut -1, la lecture commencera à la position indiquée par le curseur du fichier, que l'on peut modifier grâce à la fonction Bfile_SeekFile(); sinon la lecture commence à la position indiquée en argument.
La fonction retourne le nombre d'octets lus. Si la fonction échoue, la valeur retournée est un code d'erreur, une valeur négative.
Bfile_WriteFile
prototype :int Bfile_WriteFile(int HANDLE,const void *buf,int size);
Cette fonction est compliquée à utiliser, puisqu'elle ne marche pas comme il le faudrait... La fonction prend en premier paramètre le handle du fichier ouvert, en second le buffer à écrire (un tableau sur lequel sont stockées les données à enregistrer) et enfin le nombre d'octets à écrire.
Mais dans la mémoire de stockage, si on fait plusieurs appels à Bfile_WriteFile() consécutifs, seul le premier aura une action. Si le fichier existe déjà et qu'on essaye de surécrire, ça donne des caractères inattendus. Dans la carte SD, on peut faire plusieurs appels consécutifs à Bfile_WriteFile(), tout sera écrit à la suite. Mais Bfile_SeekFile() ne change pas la position du curseur d'écriture, et si le fichier existe déjà, on écrit toujours à la suite de ce qu'il contient déjà.
En conclusion, la seule manière d'écrire sans risque dans les fichiers est d'effacer et recréer le fichier à chaque fois, et de tout écrire d'une seule traite.
La fonction retourne la position du curseur de fichier, oou un code d'erreur, une valeur négative.
Bfile_SeekFile
prototype :int Bfile_SeekFile(int HANDLE,int pos);
Cette fonction positionne le curseur du fichier dont le handle d'ouverture est passé en premier argument à la position indiquée par le second argument. Encore une fois, méfiez-vous : cette fonction ne produit pas toujours les résultats attendus, il arrive qu'elle n'ait aucun effet !
La fonction retourne le nombre d'octets pouvant être lus. En cas d'erreur, elle retourne un code d'erreur, qui est une valeur négative.
Bfile_CloseFile
prototype :int Bfile_CloseFile(int HANDLE);
Cette fonction ferme le fichier dont le handle d'ouverture est passé en argument.
Elle renvoie 0 si tout se passe bien et une valeur négative représentant un code d'erreur si elle échoue.
Bfile_GetMediaFree
prototype :int Bfile_GetMediaFree(enum DEVICE_TYPE devicetype,int *freebytes);
Cette fonction permet d'obtenir la place libre sur la carte SD, la mémoire principale ou la mémoire de stockage. Ceci est essentiel pour éviter les erreurs lorsque vous essayez d'enregistrer des fichiers. Le premier argument représente la mémoire étudiée (DEVICE_MAIN_MEMORY : méémoire principale, DEVICE_STORAGE : mémoire de stockage, DEVICE_SD_CARD : carte SD). Le second argument est l'adresse de la variable sur laquelle stocker l'espace libre (passage par pointeur). La fonction renvoie 0 si tout se passe bien et une valeur négative représentant un code d'erreur si elle échoue (pourquoi Casio n'a pas tout simplement fait une fonction qui renvoie l'espace libre, et qui éviterait de passer par les pointeurs ? Encore une logique étrange...).
Bfile_GetFileSize
prototype :int Bfile_GetFileSize(int HANDLE);
Cette fonction renvoie la taille du fichier dont le handle d'ouverture est passé en argument. Elle est très utile si vous créez des fichiers dont la taille varie à chaque enregistrement. Elle renvoie une valeur négative représentant un code d'erreur si elle échoue.
Bfile_CreateFile
prototype :int Bfile_CreateFile(const FONTCHARACTER *filename,int size);
Crée le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};
Si votre fichier se trouve dans la mémoire de stockage, choisissez comme répertoire "fls", pour la carte SD choisissez "crd". Le nom de fichier fait maximum 8 caractères, plus le point et votre extension (choisissez celle que vous voulez, cela ne change rien au codage du fichier). La chaîne est terminée par un 0.
Le second argument est la taille en octets du fichier. Prévoyez toujours un caractère de plus que la taille dont vous avez besoin, pour le caractère de fin de fichier essentiel pour une utilisation correcte du fichier. La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_CreateDirectory
prototype :int Bfile_CreateDirectory(const FONTCHARACTER *pathname);
Crée un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','d','i','r','n','a','m','e',0};
Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0.
La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_CreateMainMemory
prototype :int Bfile_CreateMainMemory(const unsigned char *name);
Crée un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme :
unsigned char name[]={“filename”};
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire.
La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_RenameMainMemory
prototype :int Bfile_RenameMainMemory(const unsigned char *oldname, unsigned char *newname);
Renomme le fichier dont le nom est passé en premier argument avec le nom passé en second argument. Les noms sont de la forme :
unsigned char name[]={“filename”};
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire.
La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_DeleteFile
prototype :int Bfile_DeleteFile(const FONTCHARACTER *filename);
Supprime le fichier dont le nom est passé en premier argument, sous forme d'une chaîne de caractère de type FONTCHARACTER. La forme de cette chaîne de caractère est :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','f','i','l','e','n','a','m','e','.','e','x','t',0};
Cette fonction sert généralement lorsque vous voulez recréer le fichier (ou si ça vous amuse de casser définitivement l'enregistrement). La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_DeleteDirectory
prototype :int Bfile_DeleteDirectory(const FONTCHARACTER *pathname);
Supprime un répertoire. L'argument passé est le chemin du répertoire, sous forme d'une chaîne de caractères de type FONTCHARACTER. La forme de cette chaîne de caractères est :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','d','i','r','n','a','m','e',0};
Si votre répertoire se trouve dans la mémoire de stockage, choisissez "fls", pour la carte SD choisissez "crd". Le nom fait maximum 8 caractères. La chaîne est terminée par un 0.
Cette fonction n'est valable que sur la mémoire de stockage, il est impossible de supprimer un répertoire sur la carte SD ou dans la mémoire de stockage. La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_DeleteMainMemory
prototype :int Bfile_DeleteMainMemory(const unsigned char *name);
Supprime un fichier dans la mémoire principale. Donnez-lui en argument le nom du fichier, de la forme :
unsigned char name[]={“filename”};
Vous n'avez à préciser que le nom, dont la taille est inférieure à 8 caractères, sans extension ni répertoire.
La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Bfile_FindFirst
prototype :int Bfile_FindFirst(const FONTCHARACTER *pathname,int *FindHandle,FONTCHARACTER *foundfile,FILE_INFO *fileinfo);
Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension.
Cette fonction permet de trouver le premier fichier (dans l'ordre alphabétique) correspondant au profil de recherche. Le premier argument est ce profil, de la forme :
FONTCHARACTER PathName[]={'\\','\\','f','l','s','0','\\','*','.','e','x','t',0};
On précise bien "fls" pour la mémoire de stockage, "crd" pour la carte SD. L'extension doit bien être choisie, en fonction du type de fichiers que vous recherchez.
En second argument vous passez l'adresse d'un handle de recherche (passage par pointeur). Il est essentiel de garder ce handle pour continuer la recherche et la fermer.
En troisième argument vous passez un tableau de type FONTCHARACTER sur lequel sera stockée la chaîne de caractères contenant le nom du fichier (passage par pointeur). Prévoyez le stockage de 20 caractères (en content le 0 de fin de chaîne).
Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme :
typedef struct tag_FILE_INFO { // déclarée dans "filebios.h" unsigned short id; // index du fichier unsigned short type; // type de fichier unsigned long fsize; // taille du fichier (en octets) unsigned long dsize; // taille des données (le header du fichier non compté) unsigned int property; // renseigne si le fichier est entièrement rempli (si oui, property=0) unsigned long address; // adresse la plus haute des données } FILE_INFO;
Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (DT_DIRECTORY : répertoire, DT_FILE : fichier, DT_ADDIN_APP : add-in, DT_EACT : e-Activity, DT_LANGUAGE : langue, DT_BITMAP : bitmap, DT_MAINMEM: donnée de la mémoire principale, DT_TEMP : fichier temporaire, DT_DOT : répertoire courant, DT_DOTDOT : répertoire parent, DT_VOLUME : libellé de volume).
Si la fonction réussit, elle retourne 0. Si elle ne trouve rien elle renvoie le code d'erreur IML_FILEERR_ENUMRATEEND, une valeur négative.
Bfile_FindNext
prototype :int Bfile_FindNext(int FindHandle, FONTCHARACTER *foundfile, FILE_INFO *fileinfo);
Bfile_FindFirst() et Bfile_FindNext() sont des fonctions assez complexes, et très peu utilisées pour des jeux, mais elles peuvent s'avérer bien utiles. Elles permettent en effet de rechercher des fichiers dans un répertoire selon leur extension.
Cette fonction permet de trouver le fichier suivant (dans l'ordre alphabétique) correspondant à la recherche dont le handle est passé en premier argument.
En second argument vous passez un tableau de type FONTCHARACTER sur lequel sera stockée la chaîne de caractères contenant le nom du fichier (passage par pointeur). Prévoyez le stockage de 20 caractères (en content le 0 de fin de chaîne).
Le dernier argument est la structure qui recevra les informations sur le fichier trouvé (passage par pointeur). cette structure est de la forme :
typedef struct tag_FILE_INFO { // déclarée dans "filebios.h" unsigned short id; // index du fichier unsigned short type; // type de fichier unsigned long fsize; // taille du fichier (en octets) unsigned long dsize; // taille des données (le header du fichier non compté) unsigned int property; // renseigne si le fichier est entièrement rempli (si oui, property=0) unsigned long address; // adresse la plus haute des données } FILE_INFO;
Le type de fichier renseigne si le fichier est un répertoire, un add-in, une e-Activity, une image, etc (DT_DIRECTORY : répertoire, DT_FILE : fichier, DT_ADDIN_APP : add-in, DT_EACT : e-Activity, DT_LANGUAGE : langue, DT_BITMAP : bitmap, DT_MAINMEM: donnée de la mémoire principale, DT_TEMP : fichier temporaire, DT_DOT : répertoire courant, DT_DOTDOT : répertoire parent, DT_VOLUME : libellé de volume).
Si la fonction réussit, elle retourne 0. Si elle ne trouve rien elle renvoie le code d'erreur IML_FILEERR_ENUMRATEEND, une valeur négative.
Bfile_FindClose
prototype :int Bfile_FindClose(int FindHandle);
Cette fonction ferme la recherche dont le handle est passé en argument. La valeur retournée est 0 en cas de réussite, et une valeur négative correspondant à un code d'erreur en cas d'échec.
Fonctions de contrôle du clavier
Bkey_Set_RepeatTime
prototype :void Bkey_Set_RepeatTime(long FirstCount,long NextCount);
Voilà une fonction bien étrange pour commencer notre travail sur le clavier. Cette fonction définit les valeurs du temps de déclenchement entre l'appui d'une touche et le signal et le temps de répétition de la touche. Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25). Traduction : votre calculatrice répète virtuellement l'appui d'une touche...
La fonction ne retourne rien.
Bkey_Get_RepeatTime
prototype :void Bkey_Get_RepeatTime(long *FirstCount,long *NextCount);
Cette fonction récupère les valeurs du temps de déclenchement et du temps de répétition de la touche, définies par la fonction Bkey_Set_RepeatTime(). Ces valeurs sont exprimées en 40èmes de secondes (temps en millisecondes divisé par 25).
La fonction ne retourne rien.
Bkey_Set_RepeatTime_Default
prototype :void Bkey_Set_RepeatTime_Default(void)
Cette fonction réinitialise les valeurs du temps de déclenchement et du temps de répétition de la touche. Elle ne reçoit aucun argument et ne retourne aucune valeur.
GetKeyWait
prototype :int GetKeyWait(int sel,int time,int menu,unsigned int *keycode);
Cette fonction attend l'appui d'une touche et donne sa valeur. On lui donne en premier argument le type d'attente (KEYWAIT_HALTON_TIMEROFF : attend la première arrivée dans le buffer de touches, KEYWAIT_HALTOFF_TIMEROFF : si le buffer de touches est vide, la fonction se termine immédiatement, KEYWAIT_HALTON_TIMERON : si aucune touche n'est pressée avant la fin du timer spécifié par le second argument en secondes, la fonction se termine). Si le troisième argument a pour valeur 0, la touche MENU mène au menu principal, si elle a pour valeur 1 la onction retourne la valeur de la touche MENU. La quatrième argument est l'adresse de la variable sur laquelle stocker le code de la touche appuyée (passage par pointeur).
La fonction retourne KEYREP_NOEVENT si elle s'est terminée immédiatement car le buffer de touches est vide, KEYREP_KEYEVENT si elle a enregistré un appui, et KEYREP_TIMEREVENT si le timer s'est terminé avant appui d'une touche.
GetKey
prototype :int GetKey(unsigned int *keycode);
Cette fonction attend l'appui d'une touche et écrit sa valeur sur la variable donnée en argument (passage par pointeur). Elle retourne 1 pour une touche alphanumérique, et 0 pour une touche de contrôle. L'appui de MENU amène au menu principal, et SHIFT/AC éteint la calculatrice.
IsKeyDown
prototype :IsKeyDown(int keycode);
Cette fonction retourne 1 si la touche dont on passe le code en argument est pressée, et 0 si elle ne l'est pas.
IsKeyUp
prototype :IsKeyUp(int keycode);
Cette fonction retourne 0 si la touche dont on passe le code en argument est pressée, et 1 si elle ne l'est pas.
Fonctions de gestion du temps
SetTimer
prototype :int SetTimer(int ID,int elapse,void (*hander)(void));
Une fonction pas si simple à utiliser mais TRES utile. Elle permet de lancer un timer qui appellera une fonction à intervalle régulier. En premier argument on passe l'ID du timer (de 1 à 5). En second argument le temps entre 2 répétitions (en millisecondes), et enfin la fonction à appeler. Attention, le passage de la fonction par pointeur s'effectue avec uniquement le nom de la fonction, sans parenthèses (un timer ne peut pas passer d'arguments).
Si la fonction réussit, elle retourne l'ID du timer (utilité ?). Sinon elle retourne une valeur négative correspondant à un code d'erreur. Un échec survient si un paramètre est mauvais ou si le timer est utilisé.
KillTimer
prototype :int KillTimer(int ID);
Cette fonction arrête le timer dont on donne l'ID en argument (de 1 à 5). Elle retourne l'ID en cas de succès (utilité ?), ou un code d'erreur correspondant à une valeur négative en cas d'échec (c'est-à-dire si l'ID ne correspond à aucun timer en marche).
Sleep
prototype :void Sleep(int millisecond);
Cette fonction est TRES utilisée et essentielle pour contrôler la vitesse d'exécution d'un programme. Elle met la calculatrice en pause durant le temps spécifié en argument en millisecondes. Elle ne retourne rien.
En théorie une telle fonction devrait mettre en pause le processeur pour réduire la consommation d'énergie, en pratique ce n'est pas le cas. Considérez-la comme un boucle d'attente active (ce qu'elle est).
SetQuitHandler
prototype :void SetQuitHandler(void (*callback)(void));
Cette fonction définit la fonction à appeler juste avant de quitter l'add-in. C'est utile lorsque vous voulez vérifier que vous n'avez laissé aucune fuite de mémoire, ou juste dire au revoir au joueur. Attention, le passage de la fonction par pointeur s'effectue avec uniquement le nom de la fonction, sans parenthèses (on ne peut pas ici passer d'arguments). La fonction ne retourne rien.
Sources et droits
Cette page a été écrite par louloux sous licence libre : piochez ce que vous voulez mais mettez pas de bêtises dessus.
La page a été écrite à partir de la documentation Casio officielle et de mes tests et connaissances personnels.
Merci à Pierrotll pour ses éclairages par rapport à plusieurs fonctions.