home *** CD-ROM | disk | FTP | other *** search
/ DP Tool Club 18 / CD_ASCQ_18_111294_W.iso / dos / prg / c / x_lib10 / demo08.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-18  |  5.9 KB  |  327 lines
  1. /*----- demo08.cpp
  2.  
  3.     sujets :
  4.  
  5.         - ajout d'un éditeur
  6.         - ajout d'une zone défilante
  7.         - ajout d'une zone statique
  8.         - surcharge du membre on_user()
  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. #include    <stdio.h>
  21.  
  22. /*-----
  23.     classe de fenêtre MyWin
  24.  
  25.     Destructeur de MyWin :
  26.  
  27.         - aucun destructeur spécifique.
  28.  
  29.     Définition de MyWin :
  30.  
  31.         - largeur de 60 colonnes,
  32.         - hauteur de 14 lignes,
  33.         - fenêtre standard (cadre, titre, ombre, déplaçable, modale).
  34.  
  35.     Membre on_call() :
  36.  
  37.         - il est déclenché lorsqu'un objet est appelé pour exécution.
  38.  
  39.         - en paramètre, on_call() apporte l'adresse de l'objet courant
  40.           demandant cette exécution.
  41.  
  42.     Membre on_char() :
  43.  
  44.         - il est déclenché pour tout caractère non reconnu par la fenêtre
  45.           ou ses objets.
  46.  
  47.         - en paramètre, on_char() apporte le code du caractère saisi.
  48.  
  49.     Membre on_goto() :
  50.  
  51.         - il est déclenché à chaque arrivée sur le nouvel objet courant
  52.           de la fenêtre.
  53.  
  54.     Membre on_user() :
  55.  
  56.         - il est déclenché à l'initiative de l'objet courant pour informer
  57.           d'un changement dans son état.
  58.  
  59.         - en paramètres, on_user() apporte l'adresse de l'objet courant et
  60.           le code d'information spécifique à l'objet.
  61.  
  62. */
  63.  
  64. class    MyWin : public XWin
  65.         {
  66.     protected :
  67.         virtual    void    on_call (XObj *obj);
  68.         virtual    void    on_char (int key);
  69.         virtual    void    on_user (XObj *obj, int val);
  70.  
  71.     protected :
  72.         XEdit *        o_edi;
  73.         XPick *        o_pic;
  74.         XStatic *    o_sta;
  75.  
  76.     public :
  77.         MyWin (const char *str);
  78.         };
  79.  
  80. MyWin::MyWin (const char *str)
  81.         : XWin(60, 14)
  82.         {
  83.         int        i;
  84.         char    buf [32];
  85.  
  86.         /* associe un titre à la fenêtre
  87.         */
  88.         head(str);
  89.  
  90.         /* ajout d'un cadre sortant
  91.             identificateur :    0
  92.         */
  93.         link(new XBox(0, 1, 2, 54, 3, 0, 1));
  94.  
  95.         /* ajout de l'étiquette
  96.             identificateur :    1000
  97.             raccourci clavier :    ALT-E
  98.         */
  99.         link(new XLabel(1000, 2, 4, "&Edit:", xk_aE));
  100.  
  101.         /* ajout de l'éditeur
  102.             identificteur :        1001
  103.         */
  104.         o_edi = (XEdit *)link(new XEdit(1001, 2, 10, 44, 100));
  105.  
  106.         /* ajout d'un cadre sortant
  107.         */
  108.         link(new XBox(1, 4, 2, 54, 3, 0, 1));
  109.  
  110.         /* ajout de l'étiquette
  111.             identificateur :    2000
  112.             raccourci clavier :    ALT-P
  113.         */
  114.         link(new XLabel(2000, 5, 4, "&Pick:", xk_aP));
  115.  
  116.         /* ajout de la zone défilante
  117.             identificateur :    2001
  118.         */
  119.         o_pic = (XPick *)link(new XPick(2001, 5, 10, 44, 100, 40));
  120.  
  121.         /* remplit la zone défilante
  122.         */
  123.         i = 0;
  124.  
  125.         do
  126.             sprintf(buf, "%u", i++);
  127.         while (o_pic->addv(buf) != 0);
  128.  
  129.         /* ajout de la zone statique
  130.             identificateur :    3000
  131.         */
  132.         link(new XString(0, 7, 4, "USER:", 0));
  133.  
  134.         o_sta = (XStatic *)link(new XStatic(3000, 7, 10, 2, 1));
  135.  
  136.         /* ajout du bouton poussoir Ok
  137.             identificateur :    9000
  138.             raccourci clavier :    ALT-O
  139.         */
  140.         link(new XPush(9000, 8, 45, 10, "&Ok", xk_aO));
  141.  
  142.         /* ajout du bouton poussoir Quitte
  143.             identificateur :    9001
  144.             raccourci clavier :    ALT-Q
  145.         */
  146.         link(new XPush(9001, 10, 45, 10, "&Quitte", xk_aQ));
  147.         }
  148.  
  149. void    MyWin::on_call (XObj *obj)
  150.         {
  151.         int        typ, idt;
  152.  
  153.         /* récupére le type de l'objet
  154.         */
  155.         typ = obj->type();
  156.  
  157.         /* récupère l'identificateur de l'objet
  158.         */
  159.         idt = obj->id();
  160.  
  161.         /* si exécution d'un bouton poussoir
  162.         */
  163.         if (typ == xo_PUSH)
  164.             {
  165.             /* enfonce le bouton
  166.             */
  167.             xo(obj, XPush)->push(1);
  168.  
  169.             /* si bouton Ok
  170.             */
  171.             if (idt == 9000)
  172.                 {
  173.                 o_pic->strv(1, -1, o_edi->ptrv());
  174.                 }
  175.             /* sinon, ferme la fenêtre
  176.             */
  177.             else
  178.                 hide();
  179.  
  180.             }
  181.         /* si exécution d'une étiquette
  182.         */
  183.         else if (typ == xo_LABEL)
  184.             {
  185.             /* si étiquette de l'éditeur
  186.             */
  187.             if (idt == 1000)
  188.                 curr(1001);
  189.             /* si étiquette de la liste défilante
  190.             */
  191.             else if (idt == 2000)
  192.                 curr(2001);
  193.  
  194.             }
  195.  
  196.         }
  197.  
  198. void    MyWin::on_char (int key)
  199.         {
  200.         /* si caractère ESCAPE
  201.         */
  202.         if (key == xk_ESC)
  203.             /* alors ferme la fenêtre
  204.             */
  205.             hide();
  206.  
  207.         }
  208.  
  209. void    MyWin::on_user (XObj *obj, int val)
  210.         {
  211.         char    buf [2];
  212.  
  213.         /* si changement dans liste défilante : user(?)
  214.         */
  215.         if (obj->id() == 2001)
  216.             {
  217.  
  218.             if (val == 0)
  219.                 o_edi->strv(1, o_pic->ptrv(-1));
  220.  
  221.             sprintf(buf, "%u", val);
  222.             o_sta->defs(1, buf);
  223.             }
  224.  
  225.         }
  226.  
  227. /*-----
  228.     app_init() - initialisation de l'application
  229.  
  230.     L'initialisation de l'application passe par :
  231.  
  232.         - l'initialisation globale du gestionnaire de fenêtres,
  233.         - l'affichage du bureau.
  234.  
  235. */
  236.  
  237. void    app_init (void)
  238.         {
  239.         /* initialise tous les gestionnaires en une seule passe
  240.         */
  241.         xw.full(1);
  242.  
  243.         /* affiche le bureau
  244.         */
  245.         xw.desk();
  246.         }
  247.  
  248. /*-----
  249.     app_quit() - terminaison de l'application
  250.  
  251.     La terminaison de l'application passe par :
  252.  
  253.         - la terminaison globale du gestionnaire de fenêtres.
  254.  
  255. */
  256.  
  257. void    app_quit (void)
  258.         {
  259.         /* quitte tous les gestionnaires en une seule passe
  260.         */
  261.         xw.full(0);
  262.         }
  263.  
  264. /*-----
  265.     app_exec() - exécution de l'application
  266.  
  267.     L'exécution de l'application passe par :
  268.  
  269.         - la création d'une fenêtre de type MyWin,
  270.         - l'ouverture de la fenêtre,
  271.         - la lecture de chaque événement,
  272.         - l'évaluation de l'événement récupéré.
  273.  
  274.     L'exécution prend fin lorsque plus aucune fenêtre ne reste ouverte.
  275.  
  276. */
  277.  
  278. void    app_exec (void)
  279.         {
  280.         XEvn    evn;
  281.         MyWin *    win;
  282.  
  283.         /* crée la fenêtre MyWin
  284.         */
  285.         win = new MyWin("MA FENETRE");
  286.  
  287.         /* ouvre la fenêtre créée
  288.         */
  289.         win->topw();
  290.  
  291.         /* boucle de lecture des événements
  292.         */
  293.         while (1)
  294.             {
  295.             /* lit le prochain événement
  296.             */
  297.             xe.next(evn);
  298.  
  299.             /* si aucune fenêtre après évaluation de l'événement récupéré
  300.             */
  301.             if (xw.eval(evn) == 0)
  302.                 /* alors quitte la boucle
  303.                 */
  304.                 break;
  305.  
  306.             }
  307.  
  308.         /* détruit la fenêtre (déjà fermée)
  309.         */
  310.         delete win;
  311.         }
  312.  
  313. void    main (void)
  314.         {
  315.         /* initialisation de l'application
  316.         */
  317.         app_init();
  318.  
  319.         /* exécution de l'application
  320.         */
  321.         app_exec();
  322.  
  323.         /* fin de l'application
  324.         */
  325.         app_quit();
  326.         }
  327.