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