|
L'équipe progG de Ti-Fr
|
Voici les nicks de vos serviteurs ;-)
chickensaver_john
Kevin Kofler
Thibaut
janjan2
TiMad
Iceman89
fréka
Zewoo
Squale92
Verstand
ZdRUbAl
UtOpIaH
et nEUrOne ...
|
|
Une idée ?
|
Une idée pour améliorez cette partie?
ou tout simplement vous souhaitez participer à l'élaborations
des tutos.
Mailez-nous ici
|
| |
Chapitre
VIII
Dans ce chapitre, nous allons essayer de voir
quelques aspects de boites de dialogue de nos TIs. Pour cela, nous allons avoir
besoin de manipuler un peu les fonctions servant à faire des menus de type
PopUp, que nous pourrons ensuite inclure dans notre boite de dialogue.
I:\
Les menus de type Popup :
Cette partie n'est pas destinée à vous
apprendre parfaitement comment utiliser les menus de type PopUp, mais juste à
vous donner une idée des instructions qu'il est nécessaire de connaître pour
pouvoir les inclure dans des boites de dialogue.
Tous d'abord, il faut déclarer une variable
de type HANDLE, qui correspondra au
menu de type PopUp. On peut d'ailleurs en profiter pour donner la taille que
prendra le PopUp. Pour cela, on utilise :
HANDLE nom_du_popup = PopupNew(titre, hauteur);
La chaîne de caractère titre doit être
composée de 18 caractères au maximum. dans le cas contraire, les caractères
après le 18ème seront ignorés. Si vous ne voulez pas donner de titre à votre
PopUp, alors, placez NULL à la place
de la chaîne de caractères titre.
hauteur est une valeur entière et positive, exprimée
en pixels. Dans le cas ou hauteur ne serait pas assez importante par
rapport au nombre de possibilités offertes par le PopUp, celui donnera la
possibilité de monter ou descendre.
Ensuite, il est possible d'ajouter du texte
au PopUp. Pour cela, on utilise la fonction suivante :
PopupAddText(nom_du_popup, link, texte, ret_val);
Ici, le nom_du_popup est celui qui a été
défini à partir de l'instruction précédente, texte est la chaîne de
caractères qui correspondra au choix qu'il sera possible de faire. Les
possibilités seront inclues dans le PopUp dans l'ordre où vous les aurez mis
dans le programme. ret_val est la valeur qui sera retournée par
l'instruction PopupDo (dans le cas où le Popup n'est pas associé à une boite
de dialogue.)
link peut avoir plusieurs valeurs, qui auront chacune
une conséquence différente :
* Si link = -1 => menu sans
sous-menu
* Si link = 0 => menu
avec sous-menu
* Si link > 0 =>
option d'un sous-menu qui appartient au sous-menu qui est associé à l'option
de menu dont la valeur de ret_val est égale à link.
Dans notre exemple, nous utiliserons toujours link =
-1, car les menus utilisés dans les boites de dialogue ne peuvent pas avoir de
sous-menus (Je suppose, car je n'en a jamais vu sur ma TI !)
Quand nous créons un menu de type PopUp,
nous lui réservons un HANDLE. Cette opération utilise un peu de mémoire RAM
de la TI... Il est donc impératif de libérer cet espace mémoire avant de
quitter le programme. (Ou, du moins, à partir du moment où le menu ne sera
plus utilisé !). Pour cela, il convient d'utiliser l'instruction suivante :
HeapFree(nom_du_popup);
Cette instruction prend en argument le nom que nous
avions donné au menu quand nous lui avons alloué un HANDLE.
Ne pas effectuer cette opération une fois ou deux fera tout
de même "disparaître" une centaine d'octet de mémoire RAM à chaque
lancement du programme, et il faudra effectuer un Reset pour les récupérer !!!
II:\ Les
boites de dialogue :
Cette partie va nous permettre d'apprendre
les manipulations de base qui concernent la création et l'utilisation de boites
de dialogue.
Tout d'abord, pour pouvoir utiliser une boite
de dialogue, il faut déclarer une variable de type HANDLE (tout comme pour les
menus de type PopUp !), qui servira à toutes le manipulations que nous ferons
par la suite. Pour cela, on utilise l'instruction :
HANDLE nom_de_la_boite_de_dialogue = DialogNewSimple(largeur, hauteur
);
Ainsi, on déclare une boite de dialogue dont le nom
est nom_de_la_boite_de_dialogue.
Les valeurs données pour la largeur et la hauteur ne
doivent pas être plus importantes que la hauteur et la largeur de l'écran pour
lequel le programme est destiné. dans le cas contraire, il est possible que
le programme refus de se lancer, ou alors, vous aurez droit à un "magnifique
spectacle" de barre noire : Address
Error, ou Internal Error !
Pour ajouter un titre à une boite de
dialogue, il faut utiliser la fonction suivante. Celle-ci sert aussi à affecter
des boutons à la boite de dialogue :
DialogAddTitle(nom_de_la_boite_de_dialogue, titre, BT_GAUCHE,
BT_DROIT );
La variable nom_de_la_boite_de_dialogue est
celle que nous avons défini précédemment, le tire est une chaîne de
caractères, et les valeurs que peuvent prendre BT_GAUCHE et BT_DROIT
sont celles que nous avons déjà donné pour DlgMessage,
c'est-à-dire :
BT_NONE |
Pas de bouton |
BT_OK |
Bouton "ENTER=OK" |
BT_SAVE |
Bouton "ENTER=SAVE" |
BT_YES |
Bouton "ENTER=YES" |
BT_CANCEL |
Bouton "ESC=CANCEL" |
BT_NO |
Bouton "ESC=NO" |
BT_GOTO |
Bouton "ESC=GOTO" |
L'instruction la plus utile pour remplir une
boîte de Dialogue maintenant qu'elle est déclarée et prête à servir est
celle qui permet d'y positionner du texte. Cette fonction doit être utilisée
avec la syntaxe suivante :
DialogAddText(nom_de_la_boite_de_dialogue, x, y, texte);
Le premier argument, nom_de_la_boite_de_dialogue,
que prend cette fonction est toujours le HANDLE de la boîte de Dialogue, tel
que nous l'avons défini précédemment. Les arguments x et y sont
deux valeurs de type short
qui correspondent à la position du texte dans la boite de dialogue par rapport
à son coin supérieur gauche, et, enfin, le dernier argument, texte,
correspond à la chaîne de caractères qui sera affichée.
A présent, il faudrait songer à inclure le
PopUp que nous avons défini précédemment dans la boite de dialogue. pour
cela, on utilisera l'instruction :
DialodAddPulldown(nom_de_la_boite_de_dialogue, x, y, demande,
nom_du_popup, index );
Le PopUp sera précédé de la phrase demande,
dont le début sera à la position (x,y), par rapport au sommet
supérieur gauche de la boite de dialogue. nom_du_popup correspond au nom
que nous avions donné précédemment à celui-ci, au moment où nous l'avons
défini.
La valeur index correspond au rang où sera classé la valeur
choisi dans le popup. Je vous conseille de prendre 0 pour la première option,
1 pour la seconde, 2 pour la troisième, et ainsi de suite. en effet, ce rang
correspond à la position que la réponse à un popup aura dans une liste, et,
en C, le premier indice d'une liste est 0. (Contrairement au TI-BASIC,
où le premier indice est 1 !!! => Attention,
c'est souvent trompeur !)
A présent, intéressons-nous à la façon
dont il est possible d'inclure un champ à remplir dans une boite de dialogue
(Instruction Request en TI-BASIC.).
Pour faire cela, nous utiliserons l'instruction :
DialogAddRequest(nom_de_la_boite_de_dialogue, x, y, demande,
offset, Max, largeur );
Comme vous pouvez le voir, les quatre premiers
arguments de cette fonction sont les mêmes que pour la fonction précédente.
Nous ne les ré-expliquerons donc pas ici.
L'argument offset reste assez mystérieux pour moi !
Désolé ! cependant, dans l'exemple que nous allons étudier ici, je lui ai
donné la valeur 1, et cela fonctionne comme je le voulais ! En effet, il doit
être fixé à 1 pour les boites de dialogue ne contenant qu'un seul champ de
type Request. Lui donner d'autres valeurs corresponds aux cas où il y a
plusieurs champs par boite de dialogue.
L'argument Max correspond au nombre maximal de
caractères qu'il sera possible d'entrer dans le champ à compléter.
Enfin, l'argument largeur correspond à la largeur du
champ.
Enfin, il faut activer la boite de
dialogue... En effet, sans cette opération, celle-ci ne s'affichera pas à
l'écran ! Pour cela, il faut utiliser la fonction :
DialogDo(nom_de_la_boite_de_dialogue, x, y, requestbuffer,
pulldownbuffer );
Les trois premier arguments sont simples ; il s'agit
du nom de la boite de dialogue, puis de sa position en x et y. Si vous voulez
vous simplifier la vie, en centrant le boite de dialogue sur l'écran, mettez
CENTER pour x et y.
La suite est plus complexe ! l'argument requestbuffer
doit être un pointeur vers une chaîne de caractères. Par exemple, vous pouvez
faire les opérations suivantes, vous pouvez décider de l'appeler buffer1. pour
cela, il faudra le déclarer au début du programme, par
l'instruction char
*buffer1;
L'argument pulldownbuffer doit être une liste, qui
compte autant d'indices que vous avez de pulldown dans la boite de dialogue. De
plus, cette liste doit être remplie avec les valeurs par défaut pour ces
pulldowns. Il sera possible de l'appeler buffer2, et, si vous avez 3 pulldowns
dans la boite de dialogue, il faudra la déclarer par
l'instruction short
buffer2[3] = {11, 21, 31} ;
(En admettant que 11 soit la valeur par défaut pour le premier menu, et ainsi
de suite.)
Pour récupérer les résultats, il faut savoir que buffer2
contiendra la chaîne de caractères qui été placée dans le champ Request,
et la liste buffer1 contiendra les valeurs des menus pulldown. ATTENTION,
en C, les indices des listes commencent à 0, et non pas à 1 comme en
TI-BASIC !!!
Donc, pour récupérer l valeur du deuxième menu, il faudra
utiliser buffer1[1] !
De la même façon que pour les menus de type
PopUp, nous avons associé un HANDLE à
la boite de dialogue... Pour éviter toute perte inutile de mémoire RAM à
chaque exécution du programme, il convient donc ici aussi de la libérer avant
de quitter. Pour cela, nous utiliserons exactement la même instruction que
précédemment :
HeapFree(nom_de_le_boite_de_dialogue);
III:\ Le
code du programme :
C'est le programme suivant que nos allons
prendre comme exemple. Il crée une boite de dialogue dotée de 2 menus de type
PopUp et un champ Request, puis présente les résultats grâce à la fonction printf.
Ce programme nous permettra d'ailleurs d'étudier certaines possibilités que
nous offre cette fonction.
#define
OPTIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti92plus,
_ti89;
void _main(void)
{
HANDLE dialog = DialogNewSimple(156,
60); //
Déclare la boite de dialogue, et lui donne sa taille
HANDLE menu1 = PopupNew(NULL,
30);
HANDLE menu2 = PopupNew(NULL,
30);
char
*buffer1 = "";
short
buffer2[2]
= {11, 21};
short
touche = 0;
// Le Popup menu1 :
PopupAddText(menu1,
-1, "Menu1
Option1", 11);
PopupAddText(menu1,
-1, "Menu1
Option2", 12);
PopupAddText(menu1,
-1, "Menu1
Option3", 13);
PopupAddText(menu1,
-1, "Menu1
Option4", 14);
// Le Popup menu2 :
PopupAddText(menu2,
-1, "Menu2
Option1", 21);
PopupAddText(menu2,
-1, "Menu2
Option2", 22);
// Remplit la boite de dialogue :
DialogAddTitle(dialog,
"Chap8 : Boite de dialogue",
BT_OK, BT_CANCEL);
DialogAddPulldown(dialog,
2, 13,
"Menu 1 ", menu1,
0);
DialogAddPulldown(dialog,
2, 23,
"Menu 2 ", menu2,
1);
DialogAddRequest(dialog,2,
33, "Votre
nom ? ", 0,
15, 11);
touche = DialogDo(dialog,
CENTER, CENTER, buffer1,
buffer2);
// Active la boite de dialogue, et la touche de
sortie qui sera utilisée (ENTER ou ESC) sera stockée dans la variable touche
HeapFree(dialog);
HeapFree(menu1);
// Libère les trois HANDLE alloués
précédemment...
HeapFree(menu2);
clrscr();
if
(touche == KEY_ENTER)
{
printf("Vous
êtes : %s", buffer1);
//Permet d'écrire la chaîne de caractères qui
est dans buffer1
printf("\nVos
choix : "); //
La balise \n permet de forcer un retour à la ligne
printf("\n
Menu 1 : ");
if(buffer2[0]
== 11)
printf("Option
1");
if(buffer2[0]
== 12)
printf("Option
2");
if(buffer2[0]
== 13)
printf("Option
3");
if(buffer2[0]
== 14)
printf("Option
4");
printf("\n
Menu 2 : ");
if(buffer2[1]
== 21)
printf("Option
1");
if(buffer2[1]
== 22)
printf("Option
2");
ngetchx();
}
if(touche
== KEY_ESC)
{
printf("Opération
annulée ...");
ngetchx();
}
}
Voilà, normalement, à présent, vous savez
créer des boites de dialogue simples, mais fonctionnelles. cependant, n'essayez
pas d'aller trop vite : comme pour tout, il vaut souvent mieux aller lentement,
mais sûrement !!!
ATTENTION
: D'après certains de mes tests, et plusieurs des mails que
j'ai reçu, il semblerait que l'usage de boites de dialogue contenant l'instruction
DialogAddRequest entraîne parfois un
plantage de type barre noire si le programme est archivé !
Retour au menu général
Chapitre
IX
|
|