home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 18 / CD_ASCQ_18_111294_W.iso / dos / prg / c / x_lib10 / demo10.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-18  |  6.0 KB  |  335 lines
  1. /*----- demo10.cpp
  2.  
  3.     sujets :
  4.  
  5.         - ajout d'un terminal
  6.         - surcharge de tous les membres
  7.         - gestion de plusieurs fenêtres
  8.  
  9. */
  10.  
  11. /*-----
  12.     définitions
  13. */
  14. #include    "xe.h"                /* gestionnaire d'événements    */
  15. #include    "xk.h"                /* constantes clavier            */
  16. #include    "xm.h"                /* gestionnaire de souris        */
  17. #include    "xo.h"                /* définitions des objets        */
  18. #include    "xs.h"                /* gestionnaire d'écran            */
  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 15 lignes,
  34.         - fenêtre standard (cadre, titre, ombre, déplaçable, amodale).
  35.  
  36. */
  37.  
  38. class    MyWin : public XWin
  39.         {
  40.     protected :
  41.         virtual    void    on_call (XObj *obj);
  42.         virtual    void    on_char (int key);
  43.         virtual    void    on_drag (void);
  44.         virtual    void    on_exec (void);
  45.         virtual    void    on_goto (XObj *obj);
  46.         virtual    int        on_hide (XWin *win);
  47.         virtual    int        on_quit (XObj *obj);
  48.         virtual    void    on_lmou (int row, int col);
  49.         virtual    void    on_rmou (int row, int col);
  50.         virtual    void    on_lwin (int row, int col);
  51.         virtual    void    on_rwin (int row, int col);
  52.  
  53.     protected :
  54.         XTerm *    o_ter;
  55.  
  56.     public :
  57.         MyWin (int row, int col, const char *str);
  58.         };
  59.  
  60. MyWin::MyWin (int row, int col, const char *str)
  61.         : XWin(62, 15)
  62.         {
  63.         /* supprimer attribut xw_MODAL pour fenêtre amodale
  64.         */
  65.         defw(xw_STDWIN & ~xw_MODAL);
  66.  
  67.         /* déplace la fenêtre en mode absolu
  68.         */
  69.         move(1, row, col);
  70.  
  71.         /* associe un titre à la fenêtre
  72.         */
  73.         head(str);
  74.  
  75.         /* ajout d'un cadre sortant
  76.         */
  77.         link(new XBox(0, 1, 2, 42, 11, 0, 1));
  78.  
  79.         /* ajout du terminal
  80.             identificteur :        1001
  81.         */
  82.         o_ter = (XTerm *)link(new XTerm(1001, 2, 4, 38, 9, 4));
  83.  
  84.         /* ajout du bouton poussoir Ok
  85.             identificateur :    9000
  86.             raccourci clavier :    ALT-O
  87.         */
  88.         link(new XPush(9000, 2, 46, 10, "&Ok", xk_aO));
  89.  
  90.         /* ajout du bouton poussoir Quitte
  91.             identificateur :    9001
  92.             raccourci clavier :    ALT-Q
  93.         */
  94.         link(new XPush(9001, 4, 46, 10, "&Quitte", xk_aQ));
  95.         }
  96.  
  97. void    MyWin::on_call (XObj *obj)
  98.         {
  99.         char    buf [64];
  100.         int        idt;
  101.  
  102.         idt = obj->id();
  103.  
  104.         sprintf(buf, "on_CALL id:%u\n", idt);
  105.         o_ter->outs(1, buf);
  106.  
  107.         /* si exécution d'un bouton poussoir
  108.         */
  109.         if (obj->type() == xo_PUSH)
  110.             {
  111.             /* enfonce le bouton
  112.             */
  113.             xo(obj, XPush)->push(1);
  114.  
  115.             /* ferme la fenêtre si bouton Quitte
  116.             */
  117.             if (idt == 9001)
  118.                 {
  119.                 sprintf(buf, "Quitter %s ?\n", head());
  120.  
  121.                 if (xw.yes("???", buf) != 0)
  122.                     hide();
  123.  
  124.                 }
  125.             else
  126.                 {
  127.                 xw.ok(0, "Bouton OK\n");
  128.                 }
  129.  
  130.             }
  131.  
  132.         }
  133.  
  134. void    MyWin::on_char (int key)
  135.         {
  136.         char    buf [32];
  137.  
  138.         sprintf(buf, "on_CHAR %04X\n", key);
  139.         o_ter->outs(1, buf);
  140.  
  141.         /* si caractère ESCAPE
  142.         */
  143.         if (key == xk_ESC)
  144.             hide();
  145.  
  146.         }
  147.  
  148. void    MyWin::on_drag (void)
  149.         {
  150.         o_ter->outs(1, "on_DRAG\n");
  151.         }
  152.  
  153. void    MyWin::on_exec (void)
  154.         {
  155.         o_ter->outs(1, "on_EXEC\n");
  156.         }
  157.  
  158. void    MyWin::on_goto (XObj *obj)
  159.         {
  160.         char    buf [32];
  161.  
  162.         sprintf(buf, "on_GOTO id:%u\n", obj->id());
  163.         o_ter->outs(1, buf);
  164.         }
  165.  
  166. int        MyWin::on_hide (XWin *win)
  167.         {
  168.         char    buf [32];
  169.  
  170.         o_ter->outs(1, "on_HIDE\n");
  171.  
  172.         sprintf(buf, "Quitter pour %s\n", win->head());
  173.         return (xw.yes("???", buf));
  174.         }
  175.  
  176. void    MyWin::on_lmou (int row, int col)
  177.         {
  178.         char    buf [32];
  179.  
  180.         sprintf(buf, "on_LMOU %u %u\n", row, col);
  181.         o_ter->outs(1, buf);
  182.         }
  183.  
  184. void    MyWin::on_lwin (int row, int col)
  185.         {
  186.         char    buf [32];
  187.  
  188.         sprintf(buf, "on_LWIN %u %u\n", row, col);
  189.         o_ter->outs(1, buf);
  190.         }
  191.  
  192. void    MyWin::on_rmou (int row, int col)
  193.         {
  194.         char    buf [32];
  195.  
  196.         sprintf(buf, "on_RMOU %u %u\n", row, col);
  197.         o_ter->outs(1, buf);
  198.         }
  199.  
  200. void    MyWin::on_rwin (int row, int col)
  201.         {
  202.         char    buf [32];
  203.  
  204.         sprintf(buf, "on_RWIN %u %u\n", row, col);
  205.         o_ter->outs(1, buf);
  206.         }
  207.  
  208. int        MyWin::on_quit (XObj *obj)
  209.         {
  210.         char    buf [32];
  211.  
  212.         sprintf(buf, "on_QUIT id:%u\n", obj->id());
  213.         o_ter->outs(1, buf);
  214.  
  215.         return (1);
  216.         }
  217.  
  218. /*-----
  219.     app_init() - initialisation de l'application
  220.  
  221.     L'initialisation de l'application passe par :
  222.  
  223.         - l'initialisation globale du gestionnaire de fenêtres,
  224.         - l'affichage du bureau.
  225.  
  226. */
  227.  
  228. void    app_init (void)
  229.         {
  230.         /* initialise tous les gestionnaires
  231.         */
  232.         xs.init(1);
  233.         xs.mode(-28);
  234.         xm.init(1);
  235.         xk.init(1);
  236.         xe.init(1);
  237.         xw.init(1);
  238.  
  239.         /* affiche le bureau
  240.         */
  241.         xw.desk();
  242.         }
  243.  
  244. /*-----
  245.     app_quit() - terminaison de l'application
  246.  
  247.     La terminaison de l'application passe par :
  248.  
  249.         - la terminaison globale du gestionnaire de fenêtres.
  250.  
  251. */
  252.  
  253. void    app_quit (void)
  254.         {
  255.         /* quitte tous les gestionnaires en une seule passe
  256.         */
  257.         xw.full(0);
  258.         }
  259.  
  260. /*-----
  261.     app_exec() - exécution de l'application
  262.  
  263.     L'exécution de l'application passe par :
  264.  
  265.         - la création d'une fenêtre de type MyWin,
  266.         - l'ouverture de la fenêtre,
  267.         - la lecture de chaque événement,
  268.         - l'évaluation de l'événement récupéré.
  269.  
  270.     L'exécution prend fin lorsque plus aucune fenêtre ne reste ouverte.
  271.  
  272. */
  273.  
  274. void    app_exec (void)
  275.         {
  276.         XEvn    evn;
  277.         MyWin *    wi1;
  278.         MyWin *    wi2;
  279.         MyWin *    wi3;
  280.         MyWin *    wi4;
  281.  
  282.         /* crée les fenêtres MyWin
  283.         */
  284.         wi1 = new MyWin(0, 1, "MA FENETRE 1");
  285.         wi2 = new MyWin(2, 5, "MA FENETRE 2");
  286.         wi3 = new MyWin(4, 10, "MA FENETRE 3");
  287.         wi4 = new MyWin(6, 15, "MA FENETRE 4");
  288.  
  289.         /* ouvre les fenêtres créées
  290.         */
  291.         wi1->topw();
  292.         wi2->topw();
  293.         wi3->topw();
  294.         wi4->topw();
  295.  
  296.         /* boucle de lecture des événements
  297.         */
  298.         while (1)
  299.             {
  300.             /* lit le prochain événement
  301.             */
  302.             xe.next(evn);
  303.  
  304.             /* si aucune fenêtre après évaluation de l'événement récupéré
  305.             */
  306.             if (xw.eval(evn) == 0)
  307.                 /* alors quitte la boucle
  308.                 */
  309.                 break;
  310.  
  311.             }
  312.  
  313.         /* détruit les fenêtres (déjà fermées)
  314.         */
  315.         delete wi4;
  316.         delete wi3;
  317.         delete wi2;
  318.         delete wi1;
  319.         }
  320.  
  321. void    main (void)
  322.         {
  323.         /* initialisation de l'application
  324.         */
  325.         app_init();
  326.  
  327.         /* exécution de l'application
  328.         */
  329.         app_exec();
  330.  
  331.         /* fin de l'application
  332.         */
  333.         app_quit();
  334.         }
  335.