home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 18 / CD_ASCQ_18_111294_W.iso / dos / prg / c / x_lib10 / demo09.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-18  |  5.9 KB  |  323 lines
  1. /*----- demo09.cpp
  2.  
  3.     sujets :
  4.  
  5.         - ajout d'une zone statique
  6.         - ajout d'une liste
  7.         - surcharge du membre on_user()
  8.         - gestion de plusieurs fenêtres
  9.         - ajout d'une boîte de dialogue standard
  10.  
  11. */
  12.  
  13. /*-----
  14.     définitions
  15. */
  16. #include    "xe.h"                /* gestionnaire d'événements    */
  17. #include    "xk.h"                /* constantes clavier            */
  18. #include    "xo.h"                /* définitions des objets        */
  19. #include    "xw.h"                /* gestionnaire de fenêtres        */
  20.  
  21. #include    <stdio.h>
  22.  
  23. /*-----
  24.     classe de fenêtre MyWin
  25.  
  26.     Destructeur de MyWin :
  27.  
  28.         - aucun destructeur spécifique.
  29.  
  30.     Définition de MyWin :
  31.  
  32.         - largeur de 62 colonnes,
  33.         - hauteur de 18 lignes,
  34.         - fenêtre standard (cadre, titre, ombre, déplaçable, amodale).
  35.  
  36.     Membre on_call() :
  37.  
  38.         - il est déclenché lorsqu'un objet est appelé pour exécution.
  39.  
  40.         - en paramètre, on_call() apporte l'adresse de l'objet courant
  41.           demandant cette exécution.
  42.  
  43.     Membre on_char() :
  44.  
  45.         - il est déclenché pour tout caractère non reconnu par la fenêtre
  46.           ou ses objets.
  47.  
  48.         - en paramètre, on_char() apporte le code du caractère saisi.
  49.  
  50.     Membre on_goto() :
  51.  
  52.         - il est déclenché à chaque arrivée sur le nouvel objet courant
  53.           de la fenêtre.
  54.  
  55.     Membre on_user() :
  56.  
  57.         - il est déclenché à l'initiative de l'objet courant pour informer
  58.           d'un changement dans son état.
  59.  
  60.         - en paramètres, on_user() apporte l'adresse de l'objet courant et
  61.           le code d'information spécifique à l'objet.
  62.  
  63. */
  64.  
  65. class    MyWin : public XWin
  66.         {
  67.     protected :
  68.         virtual    void    on_call (XObj *obj);
  69.         virtual    void    on_char (int key);
  70.         virtual    void    on_user (XObj *obj, int val);
  71.  
  72.     protected :
  73.         XStatic *    o_sta;
  74.         XList *        o_lis;
  75.  
  76.     public :
  77.         MyWin (const char *str);
  78.         };
  79.  
  80. MyWin::MyWin (const char *str)
  81.         : XWin(62, 18)
  82.         {
  83.         int        i;
  84.         char    buf [32];
  85.  
  86.         /* supprimer attribut xw_MODAL pour fenêtre amodale
  87.         */
  88.         defw(xw_STDWIN & ~xw_MODAL);
  89.  
  90.         /* associe un titre à la fenêtre
  91.         */
  92.         head(str);
  93.  
  94.         /* ajout d'un cadre sortant
  95.         */
  96.         link(new XBox(1, 1, 2, 42, 3, 0, 1));
  97.  
  98.         /* ajout de la zone statique
  99.             identificteur :        1001
  100.         */
  101.         o_sta = (XStatic *)link(new XStatic(1001, 2, 4, 38, -1));
  102.  
  103.         /* ajout d'un cadre sortant
  104.         */
  105.         link(new XBox(1, 4, 2, 42, 11, 0, 1));
  106.  
  107.         /* ajout de la liste
  108.             identificateur :    2001
  109.         */
  110.         o_lis = (XList *)link(new XList(2001, 5, 4, 38, 9, 100, 30));
  111.  
  112.         /* remplit la liste
  113.         */
  114.         i = 0;
  115.  
  116.         do
  117.             sprintf(buf, "%u", i++);
  118.         while (o_lis->addv(buf) != 0);
  119.  
  120.         /* ajout du bouton poussoir Ok
  121.             identificateur :    9000
  122.             raccourci clavier :    ALT-O
  123.         */
  124.         link(new XPush(9000, 2, 46, 10, "&Ok", xk_aO));
  125.  
  126.         /* ajout du bouton poussoir Quitte
  127.             identificateur :    9001
  128.             raccourci clavier :    ALT-Q
  129.         */
  130.         link(new XPush(9001, 4, 46, 10, "&Quitte", xk_aQ));
  131.  
  132.         /* ajout du bouton poussoir Tous
  133.             identificateur :    9002
  134.             raccourci clavier :    ALT-T
  135.         */
  136.         link(new XPush(9002, 6, 46, 10, "&Tous", xk_aT));
  137.  
  138.         /* ajout du bouton poussoir Aucun
  139.             identificateur :    9003
  140.             raccourci clavier :    ALT-A
  141.         */
  142.         link(new XPush(9003, 8, 46, 10, "&Aucun", xk_aA));
  143.         }
  144.  
  145. void    MyWin::on_call (XObj *obj)
  146.         {
  147.         int        idt;
  148.  
  149.         idt = obj->id();
  150.  
  151.         /* si exécution d'un bouton poussoir
  152.         */
  153.         if (obj->type() == xo_PUSH)
  154.             {
  155.             /* enfonce le bouton
  156.             */
  157.             xo(obj, XPush)->push(1);
  158.  
  159.             /* si bouton Tous
  160.             */
  161.             if (idt == 9002)
  162.                 {
  163.                 o_lis->selv(1, 1);
  164.                 }
  165.             /* si bouton Aucun
  166.             */
  167.             else if (idt == 9003)
  168.                 {
  169.                 o_lis->selv(1, 0);
  170.                 }
  171.             /* sinon ferme la fenêtre
  172.             */
  173.             else if (xw.yes("???", "Etes-vous sûr de vouloir quitter ?\n"))
  174.                 hide();
  175.  
  176.             }
  177.  
  178.         }
  179.  
  180. void    MyWin::on_char (int key)
  181.         {
  182.         /* si caractère ESCAPE
  183.         */
  184.         if (key == xk_ESC)
  185.             /* alors ferme la fenêtre
  186.             */
  187.             hide();
  188.  
  189.         }
  190.  
  191. void    MyWin::on_user (XObj *obj, int val)
  192.         {
  193.         char    buf [32];
  194.  
  195.         /* si changement dans liste
  196.         */
  197.         if (obj->id() == 2001)
  198.             {
  199.             sprintf(buf, "USER:%u", val);
  200.             o_sta->defs(1, buf);
  201.  
  202.             /* si bascule sélection user(3)
  203.             */
  204.             if (val == 3)
  205.                 o_lis->revv(1, -1);
  206.             /* si sélection Tous user(4)
  207.             */
  208.             else if (val == 4)
  209.                 o_lis->selv(1, 1);
  210.             /* si sélection Aucun user(5)
  211.             */
  212.             else if (val == 5)
  213.                 o_lis->selv(1, 0);
  214.  
  215.             }
  216.  
  217.         }
  218.  
  219. /*-----
  220.     app_init() - initialisation de l'application
  221.  
  222.     L'initialisation de l'application passe par :
  223.  
  224.         - l'initialisation globale du gestionnaire de fenêtres,
  225.         - l'affichage du bureau.
  226.  
  227. */
  228.  
  229. void    app_init (void)
  230.         {
  231.         /* initialise tous les gestionnaires en une seule passe
  232.         */
  233.         xw.full(1);
  234.  
  235.         /* affiche le bureau
  236.         */
  237.         xw.desk();
  238.         }
  239.  
  240. /*-----
  241.     app_quit() - terminaison de l'application
  242.  
  243.     La terminaison de l'application passe par :
  244.  
  245.         - la terminaison globale du gestionnaire de fenêtres.
  246.  
  247. */
  248.  
  249. void    app_quit (void)
  250.         {
  251.         /* quitte tous les gestionnaires en une seule passe
  252.         */
  253.         xw.full(0);
  254.         }
  255.  
  256. /*-----
  257.     app_exec() - exécution de l'application
  258.  
  259.     L'exécution de l'application passe par :
  260.  
  261.         - la création d'une fenêtre de type MyWin,
  262.         - l'ouverture de la fenêtre,
  263.         - la lecture de chaque événement,
  264.         - l'évaluation de l'événement récupéré.
  265.  
  266.     L'exécution prend fin lorsque plus aucune fenêtre ne reste ouverte.
  267.  
  268. */
  269.  
  270. void    app_exec (void)
  271.         {
  272.         XEvn    evn;
  273.         MyWin *    wi1;
  274.         MyWin *    wi2;
  275.  
  276.         /* crée les fenêtres MyWin
  277.         */
  278.         wi1 = new MyWin("MA FENETRE 1");
  279.         wi2 = new MyWin("MA FENETRE 2");
  280.  
  281.         /* ouvre les fenêtres créées
  282.         */
  283.         wi1->topw();
  284.         wi2->topw();
  285.  
  286.         /* boucle de lecture des événements
  287.         */
  288.         while (1)
  289.             {
  290.             /* lit le prochain événement
  291.             */
  292.             xe.next(evn);
  293.  
  294.             /* si aucune fenêtre après évaluation de l'événement récupéré
  295.             */
  296.             if (xw.eval(evn) == 0)
  297.                 /* alors quitte la boucle
  298.                 */
  299.                 break;
  300.  
  301.             }
  302.  
  303.         /* détruit les fenêtres (déjà fermées)
  304.         */
  305.         delete wi2;
  306.         delete wi1;
  307.         }
  308.  
  309. void    main (void)
  310.         {
  311.         /* initialisation de l'application
  312.         */
  313.         app_init();
  314.  
  315.         /* exécution de l'application
  316.         */
  317.         app_exec();
  318.  
  319.         /* fin de l'application
  320.         */
  321.         app_quit();
  322.         }
  323.