home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 18 / CD_ASCQ_18_111294_W.iso / dos / prg / c / x_lib10 / demo05.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-18  |  5.6 KB  |  300 lines
  1. /*----- demo05.cpp
  2.  
  3.     sujets :
  4.  
  5.         - ajout d'un cadre
  6.         - ajout de boutons radio
  7.         - ajout d'une étiquette
  8.         - surcharge du membre on_call()
  9.  
  10. */
  11.  
  12. /*-----
  13.     définitions
  14. */
  15. #include    "xe.h"                /* gestionnaire d'événements    */
  16. #include    "xk.h"                /* constantes clavier            */
  17. #include    "xo.h"                /* définitions des objets        */
  18. #include    "xw.h"                /* gestionnaire de fenêtres        */
  19.  
  20. /*-----
  21.     classe de fenêtre MyWin
  22.  
  23.     Constructeur de MyWin :
  24.  
  25.         - titre str.
  26.  
  27.     Destructeur de MyWin :
  28.  
  29.         - aucun destructeur spécifique.
  30.  
  31.     Définition de MyWin :
  32.  
  33.         - largeur de 60 colonnes,
  34.         - hauteur de 13 lignes,
  35.         - fenêtre standard (cadre, titre, ombre, déplaçable, modale).
  36.  
  37.     membre on_call() :
  38.  
  39.         - il est déclenché lorsqu'un objet est appelé pour exécution.
  40.  
  41.         - en paramètre, on_call() apporte l'adresse de l'objet courant
  42.           demandant cette exécution.
  43.  
  44.         - si un des boutons Ok et Quitte est enfoncé, la fenêtre est
  45.           fermée.
  46.  
  47.         - si l'étiquette est appelée, l'objet courant devient la première
  48.           case à cocher ou le premier bouton radio.
  49.  
  50.     Membre on_char() :
  51.  
  52.         - il est déclenché pour tout caractère non reconnu par la fenêtre
  53.           ou ses objets.
  54.  
  55.         - en paramètre, on_char() apporte le code du caractère saisi.
  56.  
  57.         - si le caractère est ESCAPE, la fenêtre est fermée.
  58.  
  59. */
  60.  
  61. class    MyWin : public XWin
  62.         {
  63.     protected :
  64.         virtual    void    on_call (XObj *obj);
  65.         virtual    void    on_char (int key);
  66.  
  67.     public :
  68.         MyWin (const char *str);
  69.  
  70.         };
  71.  
  72. MyWin::MyWin (const char *str)
  73.         : XWin(60, 13)
  74.         {
  75.         /* associe un titre à la fenêtre
  76.         */
  77.         head(str);
  78.  
  79.         /* ajout du cadre
  80.             identificateur :    1
  81.             style :                enfoncé
  82.         */
  83.         link(new XBox(1, 1, 1, 28, 5, 0, 1));
  84.  
  85.         /* ajout du cadre
  86.             identificateur :    2
  87.             style :                enfoncé
  88.         */
  89.         link(new XBox(2, 1, 29, 28, 5, 0, 1));
  90.  
  91.         /* ajout de l'étiquette
  92.             identificateur :    2000
  93.             raccourci clavier :    ALT-C
  94.         */
  95.         link(new XLabel(2000, 1, 2, "&Checks:", xk_aC));
  96.  
  97.         /* ajout des cases à cocher 2001, 2002 et 2003
  98.         */
  99.         link(new XCheck(2001, 2, 3, 24, "Check &1", xk_a1));
  100.         link(new XCheck(2002, 3, 3, 24, "Check &2", xk_a2));
  101.         link(new XCheck(2003, 4, 3, 24, "Check &3", xk_a3));
  102.  
  103.         /* ajout de l'étiquette
  104.             identificateur :    3000
  105.             raccourci clavier :    aucun
  106.         */
  107.         link(new XLabel(3000, 1, 30, "Radios:", 0));
  108.  
  109.         /* ajout des boutons radio 3001, 3002 et 3003
  110.         */
  111.         link(new XRadio(3001, 2, 31, 24, "Radio &A", xk_aA));
  112.         link(new XRadio(3002, 3, 31, 24, "Radio &B", xk_aB));
  113.         link(new XRadio(3003, 4, 31, 24, "Radio &C", xk_aC));
  114.  
  115.         /* bouton radio 3001 déjà enfoncé
  116.         */
  117.         xo(addr(3001), XRadio)->setv(0);
  118.  
  119.         /* ajout du bouton poussoir Ok
  120.             identificateur :    1000
  121.             raccourci clavier :    ALT-O
  122.         */
  123.         link(new XPush(1000, 7, 45, 10, "&Ok", xk_aO));
  124.  
  125.         /* ajout du bouton poussoir Quitte
  126.             identificateur :    1001
  127.             raccourci clavier :    ALT-Q
  128.         */
  129.         link(new XPush(1001, 9, 45, 10, "&Quitte", xk_aQ));
  130.         }
  131.  
  132. void    MyWin::on_call (XObj *obj)
  133.         {
  134.         int        typ, idt;
  135.  
  136.         /* récupére le type de l'objet
  137.         */
  138.         typ = obj->type();
  139.  
  140.         /* récupère l'identificateur de l'objet
  141.         */
  142.         idt = obj->id();
  143.  
  144.         /* si exécution d'un bouton poussoir
  145.         */
  146.         if (typ == xo_PUSH)
  147.             {
  148.             /* enfonce le bouton
  149.             */
  150.             xo(obj, XPush)->push(1);
  151.  
  152.             /* ferme la fenêtre
  153.             */
  154.             hide();
  155.             }
  156.         /* si exécution d'une case à cocher
  157.         */
  158.         else if (typ == xo_CHECK)
  159.             {
  160.             /* inverse l'état de la case à cocher
  161.             */
  162.             xo(obj, XCheck)->revv(1);
  163.             }
  164.         /* si exécution d'un bouton radio
  165.         */
  166.         else if (typ == xo_RADIO)
  167.             {
  168.             /* enfonce le bouton
  169.             */
  170.             xo(obj, XRadio)->setv(1);
  171.             }
  172.         /* si exécution d'une étiquette
  173.         */
  174.         else if (typ == xo_LABEL)
  175.             {
  176.             /* si étiquette des cases à cocher
  177.             */
  178.             if (idt == 2000)
  179.                 curr(2001);
  180.             /* si étiquette des boutons radio
  181.             */
  182.             else if (idt == 3000)
  183.                 curr(3001);
  184.  
  185.             }
  186.  
  187.         }
  188.  
  189. void    MyWin::on_char (int key)
  190.         {
  191.         /* si caractère ESCAPE
  192.         */
  193.         if (key == xk_ESC)
  194.             /* alors ferme la fenêtre
  195.             */
  196.             hide();
  197.  
  198.         }
  199.  
  200. /*-----
  201.     app_init() - initialisation de l'application
  202.  
  203.     L'initialisation de l'application passe par :
  204.  
  205.         - l'initialisation globale du gestionnaire de fenêtres,
  206.         - l'affichage du bureau.
  207.  
  208. */
  209.  
  210. void    app_init (void)
  211.         {
  212.         /* initialise tous les gestionnaires en une seule passe
  213.         */
  214.         xw.full(1);
  215.  
  216.         /* affiche le bureau
  217.         */
  218.         xw.desk();
  219.         }
  220.  
  221. /*-----
  222.     app_quit() - terminaison de l'application
  223.  
  224.     La terminaison de l'application passe par :
  225.  
  226.         - la terminaison globale du gestionnaire de fenêtres.
  227.  
  228. */
  229.  
  230. void    app_quit (void)
  231.         {
  232.         /* quitte tous les gestionnaires en une seule passe
  233.         */
  234.         xw.full(0);
  235.         }
  236.  
  237. /*-----
  238.     app_exec() - exécution de l'application
  239.  
  240.     L'exécution de l'application passe par :
  241.  
  242.         - la création d'une fenêtre de type MyWin,
  243.         - l'ouverture de la fenêtre,
  244.         - la lecture de chaque événement,
  245.         - l'évaluation de l'événement récupéré.
  246.  
  247.     L'exécution prend fin lorsque plus aucune fenêtre ne reste ouverte.
  248.  
  249. */
  250.  
  251. void    app_exec (void)
  252.         {
  253.         XEvn    evn;
  254.         MyWin *    win;
  255.  
  256.         /* crée la fenêtre MyWin
  257.         */
  258.         win = new MyWin("MA FENETRE");
  259.  
  260.         /* ouvre la fenêtre créée
  261.         */
  262.         win->topw();
  263.  
  264.         /* boucle de lecture des événements
  265.         */
  266.         while (1)
  267.             {
  268.             /* lit le prochain événement
  269.             */
  270.             xe.next(evn);
  271.  
  272.             /* si aucune fenêtre après évaluation de l'événement récupéré
  273.             */
  274.             if (xw.eval(evn) == 0)
  275.                 /* alors quitte la boucle
  276.                 */
  277.                 break;
  278.  
  279.             }
  280.  
  281.         /* détruit la fenêtre (déjà fermée)
  282.         */
  283.         delete win;
  284.         }
  285.  
  286. void    main (void)
  287.         {
  288.         /* initialisation de l'application
  289.         */
  290.         app_init();
  291.  
  292.         /* exécution de l'application
  293.         */
  294.         app_exec();
  295.  
  296.         /* fin de l'application
  297.         */
  298.         app_quit();
  299.         }
  300.