Home   Archives    Hardware   Programmation   Challenges   Forum   Le Mag    Faq   La Communauté   L'Equipe
 
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

Les raccourcis
 

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(titrehauteur);
    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


 


Copyright © Ti-Fr v2.0 1999-2002