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