|
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
XVI
Ce chapitre va nous permettre d'étudier les menus, que ce
soit de type PopUp ou de type ToolBar...
Nous allons en premier lieu étudier les fonctions permettant
de créer des menus de type PopUp,
puis, nous verrons celles qui permettent de créer des menus de type ToolBar
(dont une sous-partie qui regroupe les fonctions
indispensables, et une autre les fonctions
non nécessaires).
Je vous conseille de lire la partie concernant les menus
PopUp, même s'ils ne vous intéressent pas, car les menus ToolBar sont basés
sur le même fonctionnement, mais avec plus de possibilités.
I:\ Les
menus PopUp :
Avant de pouvoir utiliser un menu de type PopUp, il faut le déclarer, grâce
à l'instruction suivante :
PopupNew(titre, hauteur);
Cette fonction prend en argument la chaîne de
caractères titre (18 caractères au maximum. Si cette chaîne de
caractères est plus longue que 18 caractères, elle sera tronquée.) qui
constituera le titre du menu. Si vous souhaitez utiliser un menu dépourvu de
titre, passez NULL au lieu de cet
argument.
Le second argument est la hauteur du popup en pixels. Si vous
précisez une taille inférieure à celle nécessaire pour afficher tous les
Items du menu, celui-ci vous offrira automatiquement la possibilité de faire
défiler verticalement la liste.
Cette fonction renvoie un HANDLE
vers la structure du menu, qui sera utilisé par les fonctions que nous allons
maintenant voir.
A présent que le menu est déclaré, il faut le remplir !
Pour cela, il faut utiliser l'instruction suivante :
PopupAddText(handle, link, texte, valeur_renvoyée);
Le premier argument de cette fonction est le HANDLE
qui a été renvoyé par la fonction précédente.
(Nous verrons la signification du second argument
ensuite...).
Le troisième argument est une chaîne de caractère. Elle
constitue le texte qui sera affiché dans le menu.
Le quatrième argument est la valeur qui sera renvoyée si
vous choisissez cet Item. (Voir la fonction popupDo).
- Utilisez link = -1 Pour les menus qui n'ont pas des sous-menus.
- Utilisez link = 0 Pour les menus qui ont des sous-menus.
- Utilisez link > 0, Pour les sous-menu qui sont associés
à un menu dont la valeur_renvoyée est égale à link.
Attention, les Items seront introduits dans le menu PopUp
dans l'ordre où vous les insérerez dans votre source : la valeur_renvoyée
n'a aucune influence sur ce sujet !!!
Enfin, il faut exécuter le menu, pour qu'il apparaisse à l'écran, que vous
puissiez faire votre choix, et, ensuite, que la valeur de ce choix soit
renvoyée.
Pour cela, on utilise la fonction suivante :
PopupDo(handle, x, y, option_de_départ);
Cette fonction renvoie une valeur de type unsigned
short, qui est la valeur_renvoyée par l'Item choisi (vois la
fonction précédente !).
Le premier argument est, une fois encore, le HANDLE
que vous avez obtenu lors de la création du menu.
Le second et le troisième sont la position en X et Y du coin
supérieur gauche du menu. Si vous voulez centrer le popup sur l'écran, vous
pouvez passer CENTER en x et y.
Enfin, l'option_de_départ est la valeur de l'Item qui
sera actif par défaut au lancement du menu. (Correspond à la valeur_renvoyée
de l'instruction PopupAddText). Si vous
voulez que le premier Item de la liste soit celui actif par défaut, passez 0
pour cet argument.
Cette fonction renvoie 0 si c'est la touche ESC qui a
été utilisée pour quitter le menu, et, si vous choisissez un Item, c'est la
valeur qui lui a été affectée avec PopupAddText
qui est renvoyée.
D'autres fonctions sont définies au sujet des menus Popup
dans la librairie <menus.h>, mais je ne les ai encore jamais utilisée (je
ne préfère donc pas essayer de les expliquer !), et je ne les considère
personnellement pas comme très utiles... Pour ces deux raisons, je ne les
détaillerai pas ici...
A présent, nous allons étudier un exemple simple, qui
affiche un menu à l'écran, et affiche la valeur renvoyée par celui-ci au
moment où vous le quittez....
#define
OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti89,_ti92plus;
void _main(void)
{
HANDLE menu_popup = PopupNew("Menu
Popup", 53);
// Déclare le HANDLE qu'on va utiliser pour
faire le menu, et lui donne sa taille, et son titre.
unsigned
short valeur_popup = 0;
// Ici on déclare la variable qu'on va utiliser
pour stocker la valeur renvoyé par le menu quand on aura fait une sélection.
Si vous appuyez sur [ESC], la valeur renvoyé sera 0.
PopupAddText(menu_popup,
-1, "Option
1", 1);
// Les différents Items du menu.
PopupAddText(menu_popup,
-1, "Option
2", 2);
PopupAddText(menu_popup,
-1, "Option
3", 3);
PopupAddText(menu_popup,
0, "Option
4", 4);
PopupAddText(menu_popup,
4, "Sous-option
4.1", 41);
PopupAddText(menu_popup,
4, "Sous-option
4.2", 42);
PopupAddText(menu_popup,
4, "Sous-option
4.3", 43);
PopupAddText(menu_popup,
4, "Sous-option
4.4", 44);
PopupAddText(menu_popup,
4, "Sous-option
4.5", 45);
PopupAddText(menu_popup,
-1, "Option
5", 5);
PopupAddText(menu_popup,
0, "Option
6", 6);
PopupAddText(menu_popup,
6, "Sous-option
6.1", 61);
PopupAddText(menu_popup,
6, "Sous-option
6.2", 62);
valeur_popup = PopupDo(menu_popup,
CENTER, CENTER, 0);
// Activation du menu, en le centrant sur
l'écran.
clrscr();
// Efface l'écran.
FontSetSys(F_6x8);
// Sélection de la police de caractère
moyenne.
printf("Valeur
: %u", valeur_popup);
// Affiche la valeur renvoyée par le menu.
ngetchx();
// Attend qu'une touche soit pressée.
}
II:\ Les
menus ToolBar :
Les menus de type ToolBar fonctionnent un peu comme ceux
de type PopUp, sauf qu'ils offrent plus de possibilité...
Il existe une APPS flash disponible sur le site
officiel de TI, nommée Cabri géométrie. (Elle est gratuite
pour TI-92plus, mais payante pour TI-89...). C'est un bon exemple de ce qu'il
est possible de faire en utilisant les fonctions que nous allons voir ici.
A: L'indispensable
:
Nous allons dans cette sous-partie étudier les fonctions
qu'il est nécessaire de connaître pour pouvoir utiliser des menus de type
ToolBar.
Tout d'abord, il faut les déclarer. Pour cela, il
convient d'utiliser l'instruction suivante :
MenuNew(2, largeur, hauteur);
Cette fonction renvoie un HANDLE vers le menu, qui
sera utilisé pour sa construction.
Le premier argument est un nombre (de type short),
mais Zeljko Juric ne donne pas de détails à son sujet dans la documentation de
TIGCC. La seul information dont on dispose est que le TIOS utilise toujours la
valeur 2. Nous allons donc faire de même...
Le second argument est la largeur du menu ToolBar, exprimée
en pixels, et la troisième est sa hauteur. Celle-ci doit être comprise
entre 1 et 18, mais, pour des raisons esthétiques, je vous conseille de passer
18.
Pour
"remplir" la barre de menus, il vous faut utiliser l'instruction
suivante :
MenuAddText(handle, link, texte, valeur_renvoyée,
0);
Cette fonction fonctionne exactement comme son
homologue pour les menus de type PopUp. Pour cette raison, nous ne ré-expliquerons
pas ici son fonctionnement... La seule différence est la denier argument, qu'il
vaut mieux mettre à 0 (pour la même raison que l'instruction précédente...).
Il est aussi possible de mettre des icônes dans les
en-têtes de menus, à la place de textes. (C'est ce que le TIOS fait pour le
menu F1 dans l'écran HOME sur TI-92plus !). Cette fonction n'est
certes pas indispensables, mais, de part sa ressemblance avec la précédente,
j'ai préféré la placer ici plutôt que dans la seconde sous-partie.
Pour cela, il faut utiliser l'instruction suivante :
MenuAddIcon(handle, 0, icone, valeur_renvoyée, 0);
Cette fonction doit être utilisée exactement comme
la précédente. La seule différence est au niveau de l'icône. Celui-ci doit
être défini de la façon suivante :
ICON icone1 = {{0x0, 0xFFFE, 0x2FF9, 0xBF9, 0x2F9, 0xB9, 0x1029, 0x3006, 0x6000,
0x6000, 0xFFFF, 0xFFFF, 0x6000, 0x6000, 0xF000, 0x0}};
(Il s'agit ici de la scie et du marteau du menu F1).
Ensuite, pour l'utiliser, il faudra faire :
MenuAddIcon(handle, 0, &icone1, valeur_renvoyée,
0);
Attention, dans cette instruction, c'est un pointeur
vers le nom (et l'adresse) de l'icône qui doit être utilisé. Celui-ci doit
donc être précédé du symbole "&"...
Avant d'être exécuté, le menu doit être
"converti" en "menu exécutable". pour cela, il faut
utiliser l'instruction suivante :
MenuBegin(HeapDeref(menu_handle), X, Y, 0);
menu_handle est le HANDLE
qui est utilisé depuis la déclaration du menu. X et Y sont les coordonnées du
point supérieur gauche du menu (en général, 0,0 !).
Cette fonction renvoie un HANDLE,
qui sera utilisé en temps que "menu_exécutable".( Pour cette raison,
il est possible de la nommer "menu_exec", comme nous le ferons dans le
programme qui nous servira ici d'exemple.).
Dans la suite de ce chapitre, nous ferons référence à
ce type de HANDLE comme de type menu_exec.
Enfin, pour qu'un menu soit vraiment utilisable, il faut
pouvoir l'afficher à l'écran, et, surtout, avoir la possibilité de savoir
quel choix a été effectué à l'intérieur de celui-ci ! Pour cela, il
convient d'utiliser la fonction suivante :
MenuKey(menu_exec, touche);
Elle prend en argument un HANDLE
de type exécutable (voir fonction précédente). Le second argument est un code
de touche. L'appel typique à MenuKey
est de passer le résultat d'un appel à ngetchx
(qui attend l'appui d'une touche et retourne sa valeur). C'est d'ailleurs ce que
nous ferons dans l'exemple que nous allons ici étudier...
Cette fonction renvoie un résultat de type short,
qui peut avoir les valeurs suivantes :
- -2, si un code de clavier erroné à été fourni à la fonction (par
exemple, une valeur qui n'est pas associée à un point du menu), ou si vous
avez pressé ESC sans avoir navigué dans le menu.
- 0, si l'utilisateur presse la touche ESC pendant que le menu était
lancé, ou si le code d'une barre d'outil inactive est passé en argument à
la fonction.
- Une valeur positive, si l'utilisateur à sélectionné un point du menu
normalement; dans ce cas, la valeur retournée sera égale à la valeur_retournée
qui a été affectée à l'Item (Voir MenuAddText)
sélectionné dans le menu.
Attention
: le premier argument de cette fonction n'est pas le HANDLE
qui a été utilisé depuis la création du menu pour le remplir, mais celui qui
a été renvoyé par la fonction MenuBegin
!!!
Si vous lancez cette fonction en passant en second argument
une valeur correspondant à un menu, celui-ci s'ouvre. Si la valeur ne
correspond qu'à une boite de titre, la fonction ne vous permettra pas de
naviguer dans le menu : elle s'achèvera immédiatement...
Nous pouvons à présent étudier notre premier exemple,
simple, qui utilise les fonctions que nous venons d'étudier. Le voici :
#define
OPTIMIZE_ROM_CALLS
#define SAVE_SCREEN
#include <tigcclib.h>
short _ti89,
_ti92plus;
void _main(void)
{
HANDLE menu_menu= MenuNew(2,
LCD_WIDTH, 18);
// Déclare le menu "non-exécutable".
HANDLE menu_exec; //
Déclare le "menu exécutable".
short valeur_menu =
0;
// Pa variable de la valeur qui sera retournée
par le menu.
ICON icone1 =
{{0x0, 0xFFFE,
0x2FF9, 0xBF9,
0x2F9, 0xB9,
0x1029, 0x3006,
0x6000, 0x6000,
0xFFFF, 0xFFFF,
0x6000, 0x6000,
0xF000, 0x0}};
// Déclare le premier icône.
ICON icone2 =
{{0x0, 0x0,
0xC0, 0x120,
0x3A0, 0x4C0,
0x880, 0x1100,
0x2200, 0x4400,
0xC800, 0xF000,
0xE000, 0xC000,
0x8000, 0x0}};
// Déclare le second icône.
MenuAddIcon(menu_menu,
0, &icone1,
1, 0);
// Crée les Items des menus.
MenuAddText(menu_menu,
1, "Sous-option
1.1", 11,
0);
MenuAddText(menu_menu,
1, "Sous-option
1.2", 12,
0);
MenuAddText(menu_menu,
-1, "Opt
2", 2,
0);
MenuAddText(menu_menu,
-1, "Opt
3", 3,
0);
MenuAddIcon(menu_menu,
0, &icone2,
4, 0);
MenuAddText(menu_menu,
4, "Sous-option
4.1", 41,
0);
MenuAddText(menu_menu,
4, "Sous-option
4.2", 42,
0);
MenuAddText(menu_menu,
4, "Sous-option
4.3", 43,
0);
MenuAddText(menu_menu,
4, "Sous-option
4.4", 44,
0);
MenuAddText(menu_menu,
4, "Sous-option
4.5", 45,
0);
MenuAddText(menu_menu,
-1, "Opt
5", 5,
0);
MenuAddText(menu_menu,
0, "Opt
6", 6,
0);
MenuAddText(menu_menu,
6,"Sous-option
6.1", 61,
0);
MenuAddText(menu_menu,
6, "Sous-option
6.2", 62,
0);
menu_exec = MenuBegin(HeapDeref(menu_menu),
0, 0,
0); //
Permet d'obtenir le "menu-exécutable".
valeur_menu =
MenuKey(menu_exec, ngetchx());
// Active le menu, et stocke la valeur choisie
dans la variable valeur_menu.
clrscr();
// Efface l'écran.
FontSetSys(F_6x8);
// Sélectionne la police de caractères
moyenne.
printf("Valeur
: %d", valeur_menu);
// Affiche cette valeur.
ngetchx();
// Attend qu'une touche soit pressée. (permet
de lire la valeur choisie.
}
B: Les
fonctions non indispensables, mais parfois utiles :
Dans cette sous-partie, nous allons étudier des fonctions
qu'il n'est pas nécessaire de connaître pour afficher des menus de type
ToolBar, mais qui peuvent apporter un "plus" à ceux-ci...
Certaines fonctions que nous allons voir d'ici peu
modifient les menus ToolBar. Il faut donc les redessiner à l'écran, afin que
les modifications soient perceptibles... pour cela, il faut utiliser
l'instruction suivante :
MenuOn(menu_exec);
Cette fonction prend en argument un HANDLE
de type menu_exec, qui correspond à la barre de menu que vous souhaitez
afficher.
Si vous remontez, à partir
de l'écran HOME de votre TI, dans l'historique de calculs, vous pourrez voir
que les menus (sauf les outils, et l'accès à l'écran de PrgmIO) deviennent
grisés. Ainsi, vous ne pouvez plus les utiliser. Pour effectuer ce type de
manipulation dans un de vos programmes, vous devez utiliser l'instruction
suivante :
MenuTopStat(menu_exec, item, état);
Cette fonction prend en argument un HANDLE
de type menu_exec. Le second argument correspond à la position du menu
par rapport à celui localisé le plus à gauche. Ainsi, pour désactiver le
premier menu, il faudra utiliser 0, pour le second, il faudra utiliser 1, etc...
Le troisième argument correspond à l'état dans lequel le
menu sera placé : si état vaut FALSE,
le menu sera désactivé. Si état vaut TRUE,
le menu sera activé.
Il est possible d'effectuer la
même manipulation avec les Items localisés à l'intérieur de menus. Par
exemple, dans l'écran HOME, les options 1 et 3 du menu F1 ne sont pas
accessibles.). Pour cela, il faut utiliser l'instruction suivante :
MenuSubStat(menu_exec, valeur_renvoyée, état);
Cette fonction doit être employée de la même façon
que la précédente. La seule différence est que valeur_renvoyée
correspond à la valeur affectée à l'Item lorsqu'il a été rajouté au menu
(Voir commande MenuAddText).
Il est possible de "marquer" à quel menu
appartient l'instruction en cours (l'APPS flash citée plus haut utilise cette
capacité.... ). En fait, cette "marque" est une bordure double pour
le menu en cours d'utilisation. Pour cela, il convient d'utiliser l'instruction
suivante :
MenuTopSelect(menu_exec, Item);
Cette fonction prend en premier argument un HANDLE de
type menu_exec, et en second, la valeur de position du menu (comme pour
l'instruction MenuTopStat).
Pour désélectionner un menu qui a été "marqué", il faut appeler
cette fonction en passant -1 comme valeur d'Item. (cela désélectionne
le menu, peu importe sa position...).
Cette fonction redessine automatiquement toute la barre de
menu à chaque exécution, ce qui peut devenir rapidement désagréable au
niveau oculaire : au bout d'un moment, on a l'impression qu'elle ne fait que
clignoter...
Pour effacer un menu de type ToolBar (à la fin du
programme, ou, du moins, quand vous êtes sûr de ne plus en avoir besoin !), il
faut utiliser l'instruction suivante :
MenuEnd(menu_exec);
Cette fonction prend en argument un HANDLE
de type menu_exec.
Cette fonction effectue deux opérations : elle libère la
mémoire qui était occupée par le HANDLE,
et elle efface le dessin du menu (et le remplace par du blanc).
Attention, l'appel à cette fonction ne restaure pas ce qui
était affiché avant le menu... Vous devez donc sauvegarder vous-même
l'écran, afin de le rappeler ensuite...
Pour libérer la mémoire qui a été utilisée par le HANDLE
utilisé pour la création du menu de type ToolBar, vous pouvez utiliser ceci :
HeapUnlock (nom_du_menu);
HeapFree(nom_du_menu);
Pour ces deux fonctions, le nom_du_menu
correspond à celui du HANDLE qui lui a
été associé lors de sa création (Voir l'instruction MenuNew).
Si vous souhaitez redessiner dans votre programme le menu
correspondant à l'Application en cours (en général, il s'agit du menu de l'écran
HOME), il vous faut utiliser l'instruction suivante :
MenuUpdate();
Cette fonction peut être utile après l'utilisation
de celle que nous venons de décrire... (entre autre !).
Il existe aussi une fonction qui permet de redéfinir un
icône de menu, et une autre qui permet d'obtenir son index, mais, ne les ayant
jamais utilisé, je préfère ne pas risquer de vous amener à commettre d'erreurs,
et je me refuses donc à tenter de les expliquer ici...
Retour au menu général
Chapitre
XVII
|
|