home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 18 / CD_ASCQ_18_111294_W.iso / dos / prg / c / x_lib10 / demo11.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-18  |  6.5 KB  |  365 lines
  1. /*----- demo11.cpp
  2.  
  3.     sujets :
  4.  
  5.         - ajout d'un terminal
  6.         - surcharge de tous les membres
  7.         - gestion de plusieurs fenêtres
  8.         - ajout d'un menu pop-up
  9.  
  10. */
  11.  
  12. /*-----
  13.     définitions
  14. */
  15. #include    "xe.h"                /* gestionnaire d'événements    */
  16. #include    "xk.h"                /* constantes clavier            */
  17. #include    "xm.h"                /* gestionnaire de souris        */
  18. #include    "xo.h"                /* définitions des objets        */
  19. #include    "xs.h"                /* gestionnaire d'écran            */
  20. #include    "xw.h"                /* gestionnaire de fenêtres        */
  21.  
  22. #include    <stdio.h>
  23.  
  24. /*-----
  25.     classe de fenêtre MyWin
  26.  
  27.     Destructeur de MyWin :
  28.  
  29.         - aucun destructeur spécifique.
  30.  
  31.     Définition de MyWin :
  32.  
  33.         - largeur de 62 colonnes,
  34.         - hauteur de 15 lignes,
  35.         - fenêtre standard (cadre, titre, ombre, déplaçable, amodale).
  36.  
  37. */
  38.  
  39. class    MyWin : public XWin
  40.         {
  41.     protected :
  42.         virtual    void    on_call (XObj *obj);
  43.         virtual    void    on_char (int key);
  44.         virtual    void    on_drag (void);
  45.         virtual    void    on_exec (void);
  46.         virtual    void    on_goto (XObj *obj);
  47.         virtual    int        on_hide (XWin *win);
  48.         virtual    int        on_quit (XObj *obj);
  49.         virtual    void    on_lmou (int row, int col);
  50.         virtual    void    on_rmou (int row, int col);
  51.         virtual    void    on_lwin (int row, int col);
  52.         virtual    void    on_rwin (int row, int col);
  53.  
  54.     protected :
  55.         XTerm *    o_ter;
  56.  
  57.     public :
  58.         MyWin (int row, int col, const char *str);
  59.         };
  60.  
  61. MyWin::MyWin (int row, int col, const char *str)
  62.         : XWin(62, 15)
  63.         {
  64.         /* supprimer attribut xw_MODAL pour fenêtre amodale
  65.         */
  66.         defw(xw_STDWIN & ~xw_MODAL);
  67.  
  68.         /* déplace la fenêtre en mode absolu
  69.         */
  70.         move(1, row, col);
  71.  
  72.         /* associe un titre à la fenêtre
  73.         */
  74.         head(str);
  75.  
  76.         /* ajout d'un cadre sortant
  77.         */
  78.         link(new XBox(0, 1, 2, 42, 11, 0, 1));
  79.  
  80.         /* ajout du terminal
  81.             identificteur :        1001
  82.         */
  83.         o_ter = (XTerm *)link(new XTerm(1001, 2, 4, 38, 9, 4));
  84.  
  85.         /* ajout du bouton poussoir Ok
  86.             identificateur :    9000
  87.             raccourci clavier :    ALT-O
  88.         */
  89.         link(new XPush(9000, 2, 46, 10, "&Ok", xk_aO));
  90.  
  91.         /* ajout du bouton poussoir Quitte
  92.             identificateur :    9001
  93.             raccourci clavier :    ALT-Q
  94.         */
  95.         link(new XPush(9001, 4, 46, 10, "&Quitte", xk_aQ));
  96.         }
  97.  
  98. void    MyWin::on_call (XObj *obj)
  99.         {
  100.         char    buf [64];
  101.         int        idt;
  102.  
  103.         idt = obj->id();
  104.  
  105.         sprintf(buf, "on_CALL id:%u\n", idt);
  106.         o_ter->outs(1, buf);
  107.  
  108.         /* si exécution d'un bouton poussoir
  109.         */
  110.         if (obj->type() == xo_PUSH)
  111.             {
  112.             /* enfonce le bouton
  113.             */
  114.             xo(obj, XPush)->push(1);
  115.  
  116.             /* ferme la fenêtre si bouton Quitte
  117.             */
  118.             if (idt == 9001)
  119.                 {
  120.                 sprintf(buf, "Quitter %s ?\n", head());
  121.  
  122.                 if (xw.yes("???", buf) != 0)
  123.                     hide();
  124.  
  125.                 }
  126.             else
  127.                 {
  128.                 xw.ok(0, "Bouton OK\n");
  129.                 }
  130.  
  131.             }
  132.  
  133.         }
  134.  
  135. void    MyWin::on_char (int key)
  136.         {
  137.         char    buf [32];
  138.  
  139.         sprintf(buf, "on_CHAR %04X\n", key);
  140.         o_ter->outs(1, buf);
  141.  
  142.         /* si caractère ESCAPE
  143.         */
  144.         if (key == xk_ESC)
  145.             hide();
  146.  
  147.         }
  148.  
  149. void    MyWin::on_drag (void)
  150.         {
  151.         o_ter->outs(1, "on_DRAG\n");
  152.         }
  153.  
  154. void    MyWin::on_exec (void)
  155.         {
  156.         o_ter->outs(1, "on_EXEC\n");
  157.         }
  158.  
  159. void    MyWin::on_goto (XObj *obj)
  160.         {
  161.         char    buf [32];
  162.  
  163.         sprintf(buf, "on_GOTO id:%u\n", obj->id());
  164.         o_ter->outs(1, buf);
  165.         }
  166.  
  167. int        MyWin::on_hide (XWin *win)
  168.         {
  169.         char    buf [32];
  170.  
  171.         o_ter->outs(1, "on_HIDE\n");
  172.  
  173.         sprintf(buf, "Quitter pour %s\n", win->head());
  174.         return (xw.yes("???", buf));
  175.         }
  176.  
  177. void    MyWin::on_lmou (int row, int col)
  178.         {
  179.         char    buf [32];
  180.  
  181.         sprintf(buf, "on_LMOU %u %u\n", row, col);
  182.         o_ter->outs(1, buf);
  183.         }
  184.  
  185. void    MyWin::on_lwin (int row, int col)
  186.         {
  187.         char    buf [32];
  188.  
  189.         sprintf(buf, "on_LWIN %u %u\n", row, col);
  190.         o_ter->outs(1, buf);
  191.         }
  192.  
  193. void    MyWin::on_rmou (int row, int col)
  194.         {
  195.         char    buf [32];
  196.  
  197.         sprintf(buf, "on_RMOU %u %u\n", row, col);
  198.         o_ter->outs(1, buf);
  199.         }
  200.  
  201. void    MyWin::on_rwin (int row, int col)
  202.         {
  203.         char    buf [32];
  204.  
  205.         sprintf(buf, "on_RWIN %u %u\n", row, col);
  206.         o_ter->outs(1, buf);
  207.         }
  208.  
  209. int        MyWin::on_quit (XObj *obj)
  210.         {
  211.         char    buf [32];
  212.  
  213.         sprintf(buf, "on_QUIT id:%u\n", obj->id());
  214.         o_ter->outs(1, buf);
  215.  
  216.         return (1);
  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
  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. XOpt    options [] = {
  271.         { 1, "fenêtre &1", '1' },
  272.         { 2, "fenêtre &2", '2' },
  273.         { 3, "fenêtre &3", '3' },
  274.         { 0, 0, 0 },
  275.         { 4, "fenêtre &4", '4' },
  276.         { 5, "option &5 et suivantes ...", '5' },
  277.         { 0, 0, 0 },
  278.         { 6, "&Quitte", 'Q' },
  279.         { -1, 0, 0 } };
  280.  
  281. void    app_exec (void)
  282.         {
  283.         XEvn    evn;
  284.         MyWin *    wi1;
  285.         MyWin *    wi2;
  286.         MyWin *    wi3;
  287.         MyWin *    wi4;
  288.         int        ret;
  289.  
  290.         /* crée les fenêtres MyWin
  291.         */
  292.         wi1 = new MyWin(0, 1, "MA FENETRE 1");
  293.         wi2 = new MyWin(2, 5, "MA FENETRE 2");
  294.         wi3 = new MyWin(4, 10, "MA FENETRE 3");
  295.         wi4 = new MyWin(6, 15, "MA FENETRE 4");
  296.  
  297.         /* ouvre les fenêtres créées
  298.         */
  299.         wi1->topw();
  300.         wi2->topw();
  301.         wi3->topw();
  302.         wi4->topw();
  303.  
  304.         /* choisit la fenêtre dans le menu
  305.         */
  306.         ret = xw.pop("MENU:", options, 1);
  307.  
  308.         if ((ret >= 0) && (ret <= 4))
  309.             {
  310.  
  311.             switch (ret)
  312.                 {
  313.                 case 1 :    wi1->topw(); break;
  314.                 case 2 :    wi2->topw(); break;
  315.                 case 3 :    wi3->topw(); break;
  316.                 case 4 :    wi4->topw(); break;
  317.                 }
  318.  
  319.             }
  320.  
  321.         if ((ret != 0) && (ret != 6))
  322.             {
  323.  
  324.             /* boucle de lecture des événements
  325.             */
  326.             while (1)
  327.                 {
  328.                 /* lit le prochain événement
  329.                 */
  330.                 xe.next(evn);
  331.  
  332.                 /* si aucune fenêtre après évaluation de l'événement récupéré
  333.                 */
  334.                 if (xw.eval(evn) == 0)
  335.                     /* alors quitte la boucle
  336.                     */
  337.                     break;
  338.  
  339.                 }
  340.  
  341.             }
  342.  
  343.         /* détruit les fenêtres (déjà fermées)
  344.         */
  345.         delete wi4;
  346.         delete wi3;
  347.         delete wi2;
  348.         delete wi1;
  349.         }
  350.  
  351. void    main (void)
  352.         {
  353.         /* initialisation de l'application
  354.         */
  355.         app_init();
  356.  
  357.         /* exécution de l'application
  358.         */
  359.         app_exec();
  360.  
  361.         /* fin de l'application
  362.         */
  363.         app_quit();
  364.         }
  365.