Sur cette page, je vais essayer de regrouper les
principales questions qui m'ont été posées par mails, qui m'ont pour
certaines demandé pas mal d'efforts pour les réponses, ou même, dans certains
cas, des questions que je me suis moi-même posé, et dont j'ai eu des
difficultés à venir à bout...
Naturellement, il est impossible que toute question ait sa
réponse ici, mais, avant de m'écrire, ça serait sympa de votre part de lire
cette page, quitte à me demander plus de précisions ultérieurement...
Je tiens aussi à préciser que certaines questions/réponses
que je propose ici sont présentes dans la doc (et, plus précisément, dans la
FAQ) de TIGCC, mais qu'on me les as tout de même posé... dans de tels cas, je
me suis bien souvent contenté d'un renvoie vers TIGCC, ou, à la limite, d'un
couper-coller ! S'il vous plait, ne m'écrivez pas pour me poser des questions
auxquelles Zeljko Juric a déjà répondu ! (Sauf si vous ne comprenez pas la
réponse.) Je crois que vous gagnerez plus de temps en étudiant un peu la FAQ
de TIGCC qu'en m'écrivant pour des questions dont la réponse est déjà
donnée, et en attendant la réponse !
Enfin, par soucis d'intimité pour chacun d'entre vous, je ne
nommerai pas les gens qui m'ont posé ces questions : les seules personnes qui
pourront voir leur nom ici cité seront celles qui m'auront aidé à répondre
à des questions, que ce soit par mail, ou sur le forum de TI-FR, et, à chaque
fois, leur nom ne sera placé ici que si elles m'y ont autorisé.
Je vais aussi vous demander de m'excuser si je fais ici
quelques remarques un peu "acides" : certaines question à forte
occurrence ont parfois tendance à me rendre hors de moi !
Liste des Questions : (Elles sont en vrac, dans l'ordre où je les reçois et où je réponds !)
Où puis-je trouver plus de documentation sur la programmation en C, que ce soit sur PC, ou sur TI ?
Si vous avez vous-même un site traitant de programmation en C, vous pouvez m'envoyer l'adresse, pour que je la rajoute ici...
Comment peut-on écrire des caractères spéciaux à l'écran de la TI ? (De façon équivalente à ce que l'on peut obtenir avec l'instruction char, en TI-BASIC).
Il doit être possible d'utiliser l'instruction suivante :
DrawChar(x, y, nombre, mode);
nombre correspond au code TI-BASIC pour les caractères
char. Ainsi, remplacer nombre par 174 permettra d'obtenir ®. Cette
fonction écrit à la position définie par le point d'abscisse x
et d'ordonnée y. mode
correspond à la façon dont sera affiché le caractère.
Par exemple, il est possible de faire :
ClrScr();
DrawChar(50, 10, 174, A_NORMAL);
ngetchx();
Ce morceau de code va écrire le caractère ® à la
position (50; 10)
Remarque : Si vous consultez la doc de TIGCC concernant cette fonction, vous pourrez remarquer que nombre est défini comme une variable de type char. Cela signifie qu'il s'agira d'une valeur codée sur 8 bits (et oui, une valeur chiffrée, comprise entre 0 et 254 !), comme tous les caractères de la TI.
Comment faire pour sauvegarder la totalité de l'écran graphique à un moment du programme, afin de pouvoir le rappeler plus tard ?
Ce petit extrait de code source va vous montrer comment résoudre ce problème :
#include <tigcclib.h>
short _ti92plus;
void _main(void)
{
LCD_BUFFER buffer; //
Déclare la variable de sauvegarde d'écran buffer
// Début du programme, les instructions à exécuter...
LCD_SAVE(buffer);
// Cette fonction
sauvegarde l'écran dans buffer.
// la suite du programme
LCD_RESTORE(buffer);
// Cette fonction rappelle l'écran
sauvegardé précédemment
// Suite et fin du programme
}
Cette manipulation est d'ailleurs celle qu'il fallait toujours utiliser, pour chaque programme, avec les anciennes versions de TIGCC, avant que SAVE_SCREEN ne soit implémentée...
Comment faire pour convertir une suite de chiffres (autrement dit, un nombre) en une chaîne de caractères, qui soit utilisable en temps que tel, par exemple pour l'afficher à l'écran ?
Pour convertir un nombre en chaîne de caractères, il est
possible d'utiliser la portion de codes suivante :
char string1[50];
char string2[50];
short var1 =
0;
ti_float var2 = 0;
// Le code du programme, qui
affecte, entre autre, des valeurs aux variables var1 et var2...
sprintf(string1,
"%d", var1);
sprintf(string2,
"%f", var2);
L'instruction sprintf
utilisée ici permet de remplir les chaînes de caractère string1 et 2
avec les valeurs des shorts
et floats var1
et 2...
Pour plus de renseignements concernant cette fonction, vous
pouvez consulter le Chapitre
XXIV du tutorial.
Quelle est la différence entre les pointeurs de type HSym et ceux de type SYM_ENTRY, pour les manipulations de la VAT ?
Le pointeur de type HSym
est défini de cette façon :
typedef struct
{
HANDLE folder;
unsigned short offset;
} HSym;
Et le pointeur de type SYM_ENTRY
est défini de cette façon :
typedef struct
{
char name[8];
unsigned
short compat;
union
{
unsigned
short flags_n;
struct
{
unsigned
short busy : 1,
local : 1,
flag1_5 : 1,
flag1_4 : 1,
collapsed : 1,
twin : 1,
archived : 1,
in_view : 1;
unsigned
short folder : 1,
overwritten : 1,
checked : 1,
hidden : 1,
locked : 1,
statvar : 1,
graph_ref_1 : 1,
graph_ref_0 : 1;
} bits;
} flags;
unsigned
short handle;
} SYM_ENTRY;
On peut ainsi voir que le pointeur de type SYM_ENTRY
permet d'accéder à beaucoup plus de choses concernant la variable pointée que
celui de type HSym. En effet, celui-ci
ne permet d'accéder qu'à l'offset de la variable, alors que le pointeur de
type SYM_ENTRY permet d'accéder aux
flags qui déterminent l'état de la variable.
C'est pour cela que c'est en utilisant des pointeurs de type SYM_ENTRY
qu'on peut cacher une variable, la verrouiller, ou alors détecter si elle est
archivée, si elle est sélectionnée...
Ainsi, les deux types de pointeurs sont utilisés par des instructions différentes, pour des buts différents.
Comment peut-on Zipper
ou Dézipper des fichiers de la TI en utilisant la librairie ZipLib de Marc
Teyssier ?
Je suis désolé de poser cette question, mais, malgré le long topic que Zeljko
Juric a écrit à ce sujet dans la FAQ de TIGCC, je n'arrive pas à compresser
ou décompresser des variables en utilisant ZipLib... A chaque fois, je n'ai pas
de problème lors de la compilation, mais j'obtient une "Adress Error"
au moment de faire l'appel à ZipLib... Comment puis-je faire pour utiliser ces
fonctions ?
Dans la FAQ de TIGCC, Zeljko Juric donne
cette macro :
#define compress(src, dest,
len) \
({ void *__src = (src), *__dest = (dest); \
unsigned long __len = (len); \
asm ("move.l %0,%%a0" :: "g"(__src));
\
asm ("move.l %0,%%a1" :: "g"(__dest));
\
asm ("move.w %0,%%d0" :: "g"(__len));
\
asm ("jsr ziplib__0004"); })
Le problème est, à mon avis, que la fonction
ziplib__004 ne sert pas à compresser des variables du TIOS (qui
apparaissent dans le VAR-LINK), mais des données internes au programme (comme
le montre le terme de "data" employé). En
effet, voici l'extrait de la doc de ZipLib qui correspond à cette fonction :
;----------------------------------------------------------------------------
; compress()
;
; Function: compress data
;
; Input: A0 = Pointer to uncompressed data
; A1 =
Pointer to where the compressed data should be stored
; D0.W =
Length of datas which will be compressed
;----------------------------------------------------------------------------
ziplib::compress equ ziplib@0004
A mon avis, c'est plutôt la fonction ziplib__006
qu'il conviendrait d'utiliser pour compresser ou décompresser des fichiers
("file") apparaissant dans le VAR-LINK. En effet, voici l'extrait de la doc de ZipLib qui
se rapport à cette fonction :
;----------------------------------------------------------------------------
; zipfile()
;
; Function: Compress or Extract a file
;
; Input: A0 = Pointer to file in the VAT
; D0.B =
0 disable commentary
;
1 semi-commentary (error displayed)
;
else enable commentary (Windows, Confirmations,...)
;
; Output: D0.B = 0 no error
;
1 cant manipulate because file is archived
;
2 compressed file bigger than original
;
3 not enough memory
;
4 Program running
; NO OTHER REGISTERS DESTROYED
;----------------------------------------------------------------------------
ziplib::zipfile equ ziplib@0006
Ici, on peut voir que cette fonction est conçue pour compresser ET
décompresser des "files", c'est-à-dire des fichiers.
Maintenant, il faut parvenir à utiliser cette fonction, afin d'arriver à
compresser ou décompresser une variable. Voici la routine que j'ai réussi à
écrire pour faire cela. Je ne garantit pas qu'elle soit parfaite : à toute fin
utiles, je précise que je connais quasiment rien à l'ASM : même si
j'arrive à comprendre en partie la logique de certains sources ASM, je
ne sais pas encore écrire de "gros programmes" en ce langage (Et,
pour compliquer le tout, l'ASM qu'il faut utiliser sous TIGCC est
du GNU ASM, et non le l'ASM A68k...). Donc, c'est
après beaucoup d'essais infructueux que j'ai fini par obtenir cette macro, qui
fonctionne sans plantage :
#define ZipFile(src, msg) \
({ void *__src = (src); \
short int __msg = (msg); \
asm ("move.l %0,%%a0" :: "g"(__src));
\
asm ("move.b %0,%%d0" :: "g"(__msg));
\
asm ("jsr ziplib__0006"); })
Pour pouvoir utiliser cette macro dans votre programme, il vous
suffit de l'inclure dans votre source. Ensuite, pour compresser ou décompresser
un fichier (il n'y a pas de test effectué : cette fonction inverse l'état de
la variable !), il faudra lancer cette macro de cette façon :
ZipFile(SymFindPtr($(nom_de_la_var)), 0), commentaire);
En fait, le premier argument de cet fonction doit être un pointeur de
type SYM_ENTRY vers la variable, et le
second est une valeur chiffrée qui vous permet d'activer ou non les
commentaires.
Si commentaire=0, il n'y aura pas de commentaires, si commentaire=1,
il n'y aura que quelques commentaires (messages d'erreur), et si commentaire=une
autre valeur, tous les commentaires seront autorisés.
Voilà, j'espère que, maintenant, je ne recevrai plus cette question...
J'ai plusieurs fois essayé d'utiliser la fonction EM_survey, pour savoir de quelle quantité de mémoire d'archive libre je disposais, mais je ne réussis pas à faire tourner cette fonction de façon correcte... Pourras-tu m'aider ?
Voilà une question qui m'est bien souvent parvenue, et qui a de nombreuses fois été postée sur le forum de TI-Fr. Je vais ici y répondre, en espérant ne plus la recevoir elle non plus...
Dans la doc de TIGCC, la fonction EM_survey est définie
comme ceci :
EM_survey (unsigned long *inUse, unsigned
long *freeAfterGC, unsigned long
*free, unsigned long *unusedSectors,
unsigned long *badSectors, unsigned
long *allExceptBaseCode);
Cette fonction prend en arguments 6 pointeurs vers des
variables de type unsigned
long.
Voici leurs significations, d'après ce que j'ai compris, et
les tests que j'ai effectué :
Si l'un de ces arguments ne vous intéresse pas, il vous sera possible de passer NULL à la place.
Pour déterminer la quantité de mémoire libre que vous avez dans votre TI,
il vous faudra faire ceci :
unsigned
long freeAfterGC;
unsigned
long free;
EM_survey(NULL, &freeAfterGC,
&free, NULL, NULL, NULL);
A présent, les variables free et freeAfterGC doivent être
additionnées pour vous donner ce que vous cherchez. Pour l'afficher, il faudra
faire :
printf("Mémore d'Archive libre : %lu", freeAfterGC+free);
Les erreurs que j'ai souvent vu dans les extrait de code que l'on m'a envoyé sont :
Je tiens aussi à vous prévenir d'un chose : certaines valeurs que vous pourrez obtenir à partir de cette fonction seront différentes de celles que vous pourrez lire dans le menu MEM de votre TI. Cela est du au fait que, dans ce menu, la lecture n'est pas faite en se basant sur les même calculs... En fait, les valeurs que vous obtiendrez avec la fonction EM_survey correspondent plutôt à celles que vous pourrez obtenir en utilisant la commande TI-BASIC getConfg().
J'ai cherché pendant pas mal de temps dans la doc de TIGCC, mais je n'ai pas réussi à trouver la fonction scanf (petite précision, cette fonction sert, en ANSI-C, à acquérir des données : c'est l'équivalent de printf, mais en Input au lieu de Output). Comment puis-je faire pour passer des valeurs au programme pendant son exécution ? Comment est-ce possible de remplacer cette fonction dans TIGCC ?
Effectivement, il est normal que tu n'ai rien trouvé correspondant à scanf dans la doc de TIGCC. En effet, cette fonction n'est pas présente dans ce logiciel ! Mais, pour pallier à ce problème, Zeljko Juric donne une fonction remplissant en gros le même rôle, dans la FAQ de TIGCC. Voici cette fonction :
void InputStr(char
*buffer, short
maxlen)
{
SCR_STATE ss;
short key,
captured, i=0;
void CaptureHandler (EVENT
*ev)
{
if (ev->Type
== CM_STRING)
captured =
*(ev->extra.pasteText);
}
buffer[0]
= 0;
SaveScrState (&ss);
do
{
MoveTo (ss.CurX,
ss.CurY);
printf ("%s_
", buffer);
//
Note that two spaces are required if F_4x6 font is used
key = ngetchx();
if (key
== KEY_CHAR && i
< maxlen)
{
EVENT ev;
ev.Type
= CM_KEYPRESS;
ev.extra.Key.Code
= key;
EV_captureEvents (CaptureHandler);
EV_defaultHandler (&ev);
EV_captureEvents (NULL);
buffer[i++]
= captured;
}
if (key
>= ' ' &&
key <= '~' &&
i < maxlen) buffer[i++]
= key;
if (key
== KEY_BACKSPACE && i)
i--;
buffer[i]
= 0;
} while (key
!= KEY_ENTER);
}
Cette fonction doit être utilisée de la façon suivante
:
InputStr(str_a_remplir, nbr_max_de_caracteres);
Le premier argument correspond à une chaîne de
caractères, et le second correspond au nombre maximal de caractères que la
fonction acceptera de lire. Attention : la
chaîne de caractères str_a_remplir
doit être assez grande pour pouvoir contenir tous les caractères qui seront
captés par la fonction !
Ensuite, la variable str_a_remplir contiendra ce que vous aurez entré pendant l'exécution de la fonction. Ces données constituerons une chaîne de caractères. Donc, si vous voulez utiliser une données chiffrée, il vous faudra convertir cette chaîne de caractères ! Voila comment faire pour certains types de variables : (les autres types de variables doivent être convertis de façon équivalente).
Je cherche à écrire des programmes de type TSR à partir de TIGCC. Pour cela, j'utilise l'exemple donné par Zeljko Juric dans l'aide du fichier <events.h>. Mon problème est que, suite au lancement des programmes que je crée de cette façon, il ne m'est plus possible d'utiliser le port link de ma TI, et j'obtient un plantage en utilisant les menus CATALOG et ABOUT !!! Comment puis-je faire pour résoudre ce problème, en ayant tout de même la possibilité de créer mes propres programmes TSR ???
Voilà une question que j'ai souvent reçu, et, sans nul doute, une de celles qui m'a le plus intéressé, puisque j'ai moi-même eu ce genre de difficultés quand j'ai commencé à vouloir développer mes propres programmes de type TSR pour mon usage personnel...
Effectivement, la technique donnée par Zeljko Juric pour créer des programmes de type TSR (Terminate and Stay Resident, c'est-à-dire restant actif en permanence, tant qu'il n'a pas été désinstallé, ou tant que l'on a pas fait effectuer un Reset à la TI) ne fonctionne pas à merveille !
En fait, je suis parfaitement incapable de développer le
type de routine permettant de faire des programmes de type TSR, et, pour tout
dire, je n'ai pas vraiment cherché à le faire ! Mais bon,
puisqu'on me demande... J'ai trouvé un site sur lequel il est possible de
télécharger un programme de ce style en Open-source, et en C. Voici
l'adresse : http://www.geocities.com/gdietsche/
L'avantage de ce programme est qu'il vous permet
d'écrire des programmes de type TSR qui soient compatibles avec la norme fixée
par Kevin Kofler, notamment au sujet de la position en RAM, ou de la
désinstallation...
Malheureusement, le programmeur qui a développé cet
exemple l'a écrit en anglais, mais, à mon avis, vous n'aurez pas besoin de
trop de connaissances dans cette langue pour comprendre, et parvenir à
développer vos programmes à partir de là.
J'ai moi-même testé cette solution de création de
programmes de type TSR, et je peux confirmer qu'elle fonctionne : j'utilise en
permanence sur ma TI un programme que j'ai développé de cette façon !
Pourquoi te fatigues-tu à créer des programmes, et même des chapitres entier dans deux versions différentes pour deux calculatrices ? Ne te serait-il pas plus simple de ne développer ton tutorial que pour TI-89 ? Après tout, je crois bien que cette calculatrice est nettement plus représentée que que la TI-92+ !
Voila une question qui me dérange très profondément !
Il est absolument HORS DE QUESTION
que je cesse de développer ce tutorial pour les TI-92plus ! En effet, c'est la
calculatrice que je possède moi même !!! En fait, tous les programmes et/ou
chapitres qui sont ici présentés pour TI-89 ne sont rien de plus que les
versions que j'ai écrit pour TI-92+ que j'ai par la suite porté pour TI-89 !
Donc, si jamais je venais à manquer considérablement de
temps, ce sont les version pour TI-89 qui disparaîtraient, et nullement celles
pour TI-92plus, et ce même s'il y a beaucoup plus de gens qui utilisent des
TI-89 que des TI-92plus !
Même si cela dérange certains d'entre vous de
télécharger des version pour TI-92plus alors que vous avez des TI-89, je vous
demanderai de ne pas oublier que je passe beaucoup de temps à écrire ce
tutorial, que je le fait bénévolement, que je passes moi-même pas mal de
temps de mon forfait à l'envoyer à mon hébergeur (l'inconvénient des
connexions lentes !), et que si je n'avais pas ma TI-92+, je ne l'aurai pas
écrit !!!
De plus, ce tutorial est écrit en bonne partie parce qu'il me
permet d'apprendre de nouvelles choses concernant la programmation sur ma 92+,
et parce que j'aime beaucoup, entre autre, recevoir des mails me prouvant que
mon tutorial est apprécié. Par contre, ce genre de question m'est assez
insupportable ! Je vous serait donc reconnaissant de ne plus me la poser. Merci
!
Pendant l'exécution de mon programme, je modifie les indicateur d'angle dans la ST, et je peux voir sur l'écran qu'ils ont bien été modifiés. Par contre, une fois que je quitte le programme, ceux-ci reviennent à ce qu'ils étaient avant que je n'exécute le programme... Comment faire pour éviter cela, c'est-à-dire que ces indicateurs restent à ce que j'ai fixé ?
C'est tout simple : tu utilises #define SAVE_SCREEN dans ton source, je penses ? (=> OUI !). Eh bien, cette instruction fait que l'écran est sauvegardé au lancement du programme, et qu'il est restauré à la sortie du programme... Donc, les indicateurs qui apparaîtront dans la ST après l'exécution du programme seront les mêmes que ceux qui étaient affichés au lancement !
Pour éviter ceci, il faut que tu sauvegarde manuellement
l'écran au début du programme, que tu le rappelle avant de quitter, et,
seulement après l'avoir rappelé, tu modifie les indicateurs... Voici, en gros,
comment il faut faire :
LCD_BUFFER sauv_ecran; //
Déclare l'espace mémoire nécessaire à la sauvegarde de l'écran.
LCD_save(sauv_ecran); // Sauvegarde
l'écran dans cet espace mémoire.
// ... ton programme, qui modifie l'écran, qui
l'efface...
LCD_restore(sauv_ecran); // Rappelle
l'écran précédemment sauvegardé.
// Et là, tu peux modifier ce que tu veux, cela
restera visible après la sortie du programme.
// Naturellement, il ne faut pas utiliser #define SAVE_SCREEN au lancement du
programme !
Avant la version 0.8 de TIGCC, la macro SAVE_SCREEN n'existait pas. Il fallait alors toujours utiliser cette technique pour sauvegarder l'écran au début d'un programme, et le restaurer après !
ATTENTION : Cette opération n'est possible qu'en mode Nostub. En effet, les Kernels sauvegardent eux-même l'écran au lancement des programmes, et le restaurent avant de quitter ! Il n'est donc pas possible de modifier l'écran de la sorte avec un programme de type Kernel (Enfin, du moins, ce n'est pas encore possible...)...
Je voudrais créer une variable de type EXPR (qui apparaisse en tant que telle dans le menu VAR-LINK) à partir de mon programme en C... Comment puis-je faire ?
C'est une bonne question que tu poses ici ! En effet, il
est très complexe de créer des variables d'un autre type que STR ou TEXT !
La réponse que je vais ici donner provient du forum C
de TI-Fr. Elle ne permet que de créer des variables de type EXPR simples,
c'est-à-dire ne contenant rien de plus qu'une valeur chiffrée : pas de formule
symbolique !
Pour créer un la variable
a = 5 (donc qui a pour valeur un entier naturel), c'est assez facile.
La variable contenant un entier naturel est composée ainsi : (en hexadécimal)
* 1er octet : 0x00
* 2ème octet : checksum, indique le nombre d'octet qu'il
reste jusqu'à la fin du fichier (pour des vérifications)
* n octets suivants : utilisés pour coder le nombre, on part
du dernier octet composant le nombre en hexa.
* octet suivant ces n octets : indique le nombre d'octets
décrivant la valeur du nombre (pour des vérifications).
* dernier octet : 0x1F, valeur pour les entiers naturels
Donc pour créer a = 5, il convient d'utiliser le code source suivant :
#define
OPTIMIZE_ROM_CALLS
#define ENTIER_NATUREL_TAG 0x1F
#define CHECKSUM 0x3
#include <tigcclib.h>
short _ti89;
void _main(void)
{
FILE *f;
f = fopen("a",
"wb");
fputc(0,
f);
fputc(CHECKSUM,
f);
fputc(0x5,
f);
fputc(0x1,
f);
fputc(ENTIER_NATUREL_TAG,
f);
fclose(f);
}
Je ne te pourrai pas t'aider beaucoup plus à ce sujet, mais, à mon avis, regarde un peu comment sont faites les variables avec un éditeur hexa : ça peut t'aider à comprendre pas mal de choses...
Merci aux personnes du forum de TI-Fr qui ont résolu cette question posées par l'un des visiteurs, et qui m'ont suggéré qu'elle pouvait avoir une place ici...
Je voudrais apprendre quelques trucs permettant de créer des programmes nécessitant moins d'espace mémoire... autrement dit, je voudrais savoir comment optimiser mes programmes sur le point de vue Mémoire... Comment puis-je faire ?
Tu veux créer des programmes occupant moins d'espace mémoire ? Eh bien, bon courage, tu vas t'amuser : la partie optimisation du programme au niveau de la mémoire est souvent la plus longue de tout le développement du programme !
En fait, tu peux utiliser plusieurs astuces, qui te permettront d'utiliser moins d'espace mémoire :
J'ai créé un petit programme, et, je ne comprend vraiment pas pourquoi, mais quand je l'utilises, j'ai de la mémoire RAM (entre 100 et 200 octets environ, à chaque utilisation du programme) qui disparaît... Certes, j'utilises de l'allocation dynamique de mémoire, mais je n'oublie pas de libérer les bloc alloués, comme expliqué dans le Chapitre XX. A quoi cela peut-il être du ??? (Mon programme ne fait pas grand chose : il affiche juste quelques graphismes et une boite de dialogue...)
Avant de lire la réponse que je vais te donner juste après, vérifie, à toute fins utiles, que la mémoire qui disparaît n'est pas tout simplement utilisée pour l'historique de calculs : c'est tout bête, mais il est possible que ce soit ça, puisque, à sa sortie, le nom du programme est placé dans celui-ci... et que, comme la plupart des gens, tu n'y ai pas pensé. (Ne t'inquiète pas, ça m'est à moi aussi bien souvent arrivé de me demander où ces quelques octets étaient passés !!!).
Maintenant, nous allons voir pourquoi, à mon avis, ton programme fait "disparaître" un peu de mémoire de la sorte...
Tout d'abord, il faut que tu saches que le problème vient
d'une forme d'allocation de mémoire. En effet, quand tu as créé ta boite de
dialogue, tu lui a alloué un peu de mémoire, à travers à HANDLE, en faisant
quelque chose qui ressemblait à ceci :
HANDLE nom_de_le_bte_de_dlg
= DialogNewSimple(largeur, hauteur);
Le problème est qu'il faut libérer la mémoire
allouée ainsi, de la même façon qu'il faut libérer celle qui est allouée
avec la fonction malloc. Ici, étant
donné que tu ne dispose pas d'un pointeur vers l'espace mémoire alloué, mais
de son HANDLE, il conviendra d'utiliser l'instruction suivante :
HeapFree(nom_de_le_bte_de_dlg);
Cette instruction doit être utilisée une fois que tu
n'as plus besoin de ta boite de dialogue :-) !
Mais, si tu utilises aussi des menus de type PopUp dans ta boite de dialogue, tu peux remarquer que tu perd encore un peu de mémoire RAM, même si c'est à présent en plus faible quantité... Cela est du au fait que, pour les menus de type PopUp, tu as aussi alloué un HANDLE. Il te faudra donc le libérer une fois que tu n'en auras plus besoin, exactement de la même manière que pour les boites de dialogue...
A présent, je penses que ton programme ne devrait plus te faire "perdre" de mémoire RAM (à part dans l'historique de calcul !)...
Cette page est en construction
permanente...
puisqu'elle recense des question que l'on me pose souvent...
Remerciements tout particulier à Kevin Kofler pour les nombreuses remarques qu'il m'a fait concernant cette page, afin de me permettre de l'améliorer...
Copyright Squale92 & Verstand. Logo et sigle TCI® réservés. Développé pour MS Internet Explorer 5.0 en 1024x768 pixels. Page modifiée le