home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / zip / program / gempp15b.zoo / src / gemhf.cc < prev    next >
C/C++ Source or Header  |  1993-04-25  |  15KB  |  585 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. //
  3. //  This file is Copyright 1992,1993 by Warwick W. Allison.
  4. //  This file is part of the gem++ library.
  5. //  You are free to copy and modify these sources, provided you acknowledge
  6. //  the origin by retaining this notice, and adhere to the conditions
  7. //  described in the file COPYING.LIB.
  8. //
  9. /////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include <aesbind.h>
  12. #include <values.h>
  13. #include "gemhf.h"
  14. #include "gemrawo.h"
  15. #include "grect.h"
  16.  
  17.  
  18. static int FindEdit(GEMrawobject* o, int i)
  19. {
  20.     return o[i].Editable() ? i : -1;
  21. }
  22.  
  23. GEMhotform::GEMhotform(const GEMrsc& in, int RSCindex) :
  24.     GEMform(in,RSCindex)
  25. {
  26.     curedit=Map(FindEdit);
  27.     Zooms(FALSE);
  28. }
  29.  
  30. int GEMhotform::DoKey(int meta, int key)
  31. {
  32.     return Ignore;
  33. }
  34.  
  35. int GEMhotform::DoOff()
  36. {
  37.     return NoObject;
  38. }
  39.  
  40. int GEMhotform::DoHot(int ob, bool inside)
  41. {
  42.     static void objc_toggle(GEMrawobject* tree, int obj);
  43.  
  44.     objc_toggle(Obj,ob);
  45.  
  46.     // Could use this, but G_STRING objects are transparent, so do not
  47.     // Redraw well when selected.
  48.     //
  49.     // Obj[ob].Selected(inside);
  50.     // RedrawObject(ob);
  51.  
  52.     return Ignore;
  53. }
  54.  
  55. // "Hot" version from Profesional GEM, by Tim Oren.
  56. //
  57. // The following code is based on the file "gemcl13.c" in the
  58. // source code provided with the Professional GEM series.
  59. // Available in the /atari/Programming directory of atari.archive.umich.edu.
  60. //
  61. // Changes include:
  62. //
  63. //      - Ported to C++ (ie. uses ANSI prototypes).
  64. //      - Uses current bindings.
  65. //      - Added "machine" macros #defines at start.
  66. //      - Clicking off form detected.
  67.  
  68. #define NIL -1
  69.  
  70. #define    M1_ENTER    0x0000
  71. #define    M1_EXIT        0x0001
  72.  
  73. #define BS   0x0008
  74. #define    TAB  0x0009
  75. #define    CR   0x000D
  76. #define ESC  0x001B
  77. #define    BTAB 0x0f00
  78. #define    UP   0x4800
  79. #define    DOWN 0x5000
  80. #define    DEL  0x5300
  81.  
  82. /* Global variables used by */
  83. /* 'mapped' functions        */
  84.  
  85. static    GRect    br_rect;        /* Current break rectangle  */
  86. static    int    br_mx, br_my, br_togl;    /* Break mouse posn & flag  */ 
  87. static    int    fn_obj;            /* Found tabable object        */
  88. static    int    fn_last;        /* Object tabbing from        */
  89. static    int    fn_prev;        /* Last EDITABLE obj seen   */
  90. static    int    fn_dir;            /* 1 = TAB, 0 = BACKTAB        */
  91.  
  92. /************* Utility routines for new forms manager ***************/
  93.  
  94. /* Return the object's GRect through 'p' */
  95. static void objc_xywh(GEMrawobject* tree, int obj, GRect *p)
  96. {
  97.     objc_offset(tree, obj, &p->g_x, &p->g_y);
  98.     p->g_w = tree[obj].Width();
  99.     p->g_h = tree[obj].Height();
  100. }
  101.  
  102. /* Reverse the SELECT state */
  103. static void objc_toggle(GEMrawobject* tree, int obj)
  104. {
  105.     int    state, newstate;
  106.     GRect    root;
  107.  
  108.     objc_xywh(tree, ROOT, &root);
  109.     state = tree[obj].States();
  110.     newstate = state ^ SELECTED;
  111.     objc_change(tree, obj, 0, root.g_x, root.g_y, 
  112.         root.g_w, root.g_h, newstate, 1);
  113. }
  114.  
  115. /* If the object is not already SELECTED, make it so. */
  116. static void objc_sel(GEMrawobject* tree, int obj)
  117. {
  118.     if ( !(tree[obj].States() & SELECTED) )
  119.         objc_toggle(tree, obj);
  120. }
  121.  
  122. /* If the object is SELECTED, deselect it. */
  123. static void objc_dsel(GEMrawobject* tree, int obj)
  124. {
  125.     if (tree[obj].States() & SELECTED)
  126.         objc_toggle(tree, obj);
  127. }
  128.  
  129. /* Non-cursive traverse of an object tree. */
  130. static void map_tree(GEMrawobject* tree, int this1, int last, int routine(GEMrawobject*,int))
  131. {
  132.     int        tmp1;
  133.  
  134.     tmp1 = this1;        /* Initialize to impossible value: */
  135.                 /* TAIL won't point to self!       */
  136.                 /* Look until final node, or off   */
  137.                 /* the end of tree           */ 
  138.     while (this1 != last && this1 != NIL)
  139.                 /* Did we 'pop' into this1 node       */
  140.                 /* for the second time?           */
  141.         if (tree[this1].Tail() != tmp1)
  142.             {
  143.             tmp1 = this1;    /* This is a new node       */
  144.             this1 = NIL;
  145.                     /* Apply operation, testing  */
  146.                     /* for rejection of sub-tree */
  147.             if (!tree[tmp1].HideTree())
  148.                 if (routine(tree, tmp1))
  149.                     this1 = tree[tmp1].Head();
  150.                     /* Subtree path not taken,   */
  151.                     /* so traverse right         */    
  152.             if (this1 == NIL)
  153.                 this1 = tree[tmp1].Next();
  154.             }
  155.         else            /* Revisiting parent:          */
  156.                     /* No operation, move right  */
  157.             {
  158.             tmp1 = this1;
  159.             this1 = tree[tmp1].Next();
  160.             }
  161. }
  162.  
  163. /* Find the parent of an object of by traversing right */
  164. static int get_parent(GEMrawobject* tree, int obj)
  165. {
  166.     int        pobj;
  167.  
  168.     if (obj == NIL)
  169.         return (NIL);
  170.     pobj = tree[obj].Next();
  171.     if (pobj != NIL)
  172.     {
  173.       while( tree[pobj].Tail() != obj ) 
  174.       {
  175.         obj = pobj;
  176.         pobj = tree[obj].Next();
  177.       }
  178.     }
  179.     return(pobj);
  180. } 
  181.  
  182. /* determine if x,y is in rectangle    */
  183. static int inside(int x, int y, GRect *pt)    
  184. {
  185.     if ( (x >= pt->g_x) && (y >= pt->g_y) &&
  186.         (x < pt->g_x + pt->g_w) && (y < pt->g_y + pt->g_h) )
  187.         return(TRUE);
  188.     else
  189.         return(FALSE);
  190. } 
  191.  
  192. /************* "Hot-spot" manager and subroutines  ***************/
  193.  
  194. static int break_x(int *pxy)
  195. {                /* Breaking object is right of    */
  196.     if (br_mx < pxy[0])        /* mouse.  Reduce width of     */
  197.         {            /* bounding rectangle.        */
  198.         br_rect.g_w = pxy[0] - br_rect.g_x;
  199.         return (TRUE);
  200.         }
  201.     if (br_mx > pxy[2])        /* Object to left.  Reduce width*/
  202.         {            /* and move rect. to right    */
  203.         br_rect.g_w += br_rect.g_x - pxy[2] - 1;
  204.         br_rect.g_x = pxy[2] + 1;
  205.         return (TRUE);
  206.         }
  207.     return (FALSE);            /* Mouse within object segment.    */
  208. }                /* Break attempt fails.        */
  209.  
  210. static int break_y(int *pxy)
  211. {
  212.     if (br_my < pxy[1])        /* Object below mouse.  Reduce    */
  213.         {            /* height of bounding rect.    */
  214.         br_rect.g_h = pxy[1] - br_rect.g_y;
  215.         return (TRUE);
  216.         }
  217.     if (br_my > pxy[3])        /* Object above mouse.  Reduce    */
  218.         {            /* height and shift downward.    */
  219.         br_rect.g_h += br_rect.g_y - pxy[3] - 1;
  220.         br_rect.g_y = pxy[3] + 1;
  221.         return (TRUE); 
  222.         }
  223.     /* Emergency escape test! Protection vs. turkeys who nest */
  224.     /* non-selectable objects inside of selectables.          */
  225.     if (br_mx >= pxy[0] && br_mx <= pxy[1])
  226.         {                /* Will X break fail?      */
  227.         br_rect.g_x = br_mx;        /* If so, punt!          */
  228.         br_rect.g_y = br_my;
  229.         br_rect.g_w = br_rect.g_h = 1;
  230.         return (TRUE);
  231.         }
  232.     return (FALSE);
  233. }
  234.  
  235. /* Called once per object to    */
  236. static int break_obj(GEMrawobject* tree, int obj)
  237. {
  238.     GRect    s;
  239.     int    flags, broken, pxy[4];
  240.  
  241.     objc_xywh(tree, obj, &s);
  242.     grect_to_array(&s, pxy);
  243.     if (!rc_intersect(&br_rect, &s))
  244.         return (FALSE);        /* Trivial rejection case     */
  245.  
  246.     flags = tree[obj].Flags();    /* Is this1 object a potential    */
  247.     if (flags & HIDETREE)        /* hot-spot?                 */
  248.         return (FALSE);
  249.     if ( !(flags & SELECTABLE) )
  250.         return (TRUE);
  251.     if (tree[obj].States() & DISABLED)
  252.         return (TRUE);
  253.  
  254.     for (broken = FALSE; !broken; ) /* This could take two passes     */
  255.         {            /* if the first break fails.       */
  256.         if (br_togl)
  257.             broken = break_x(pxy);
  258.         else
  259.             broken = break_y(pxy);
  260.         br_togl = !br_togl;
  261.         }
  262.     return (TRUE);
  263. }
  264.  
  265. /* Manages mouse rectangle events */
  266. static int form_hot(GEMrawobject* tree, int hot_obj, int mx, int my, GRect *rect, int *mode)
  267. {
  268.     GRect    root;
  269.     int    state;
  270.  
  271.     objc_xywh(tree, ROOT, &root);    /* If there is already a hot-spot */
  272.  
  273.     if (!(inside(mx, my, &root)) )    /* Mouse has moved outside of       */
  274.         {            /* the dialog.  Wait for return.  */
  275.         *mode = M1_ENTER;
  276.         rc_copy(&root, rect);
  277.         return (NIL);
  278.         }
  279.                     /* What object is mouse over?      */
  280.                     /* (Hit is guaranteed.)           */
  281.     hot_obj = objc_find(tree, ROOT, MAX_DEPTH, mx, my);
  282.                     /* Is this object a hot-spot?      */
  283.     state = tree[hot_obj].States();
  284.     if (tree[hot_obj].Flags() & SELECTABLE)
  285.     if ( !(state & DISABLED) )
  286.         {            /* Yes!  Set up wait state.      */
  287.         *mode = M1_EXIT;
  288.         objc_xywh(tree, hot_obj, rect);
  289.         if (state & SELECTED)    /* But only toggle if it's not      */
  290.             return (NIL);    /* already SELECTED!          */
  291.         else
  292.             {
  293.             return (hot_obj);
  294.             }
  295.         }
  296.  
  297.     rc_copy(&root, &br_rect);    /* No hot object, so compute    */
  298.     br_mx = mx;            /* mouse bounding rectangle.    */
  299.     br_my = my;
  300.     br_togl = 0;
  301.     map_tree(tree, ROOT, NIL, break_obj);
  302.     rc_copy(&br_rect, rect);    /* Then return to wait state.    */
  303.     *mode = M1_EXIT;
  304.     return (NIL);
  305. }
  306.  
  307. /************* Keyboard manager and subroutines ***************/
  308.  
  309. /* Check if the object is DEFAULT    */
  310. static int find_def(GEMrawobject* tree, int obj)
  311.     {            /* Is sub-tree hidden?            */
  312.     if (HIDETREE & tree[obj].Flags())
  313.         return (FALSE);
  314.                 /* Must be DEFAULT and not DISABLED    */
  315.     if (DEFAULT & tree[obj].Flags())
  316.     if ( !(DISABLED & tree[obj].States()) )
  317.         fn_obj = obj;    /* Record object number            */
  318.     return (TRUE);
  319. }
  320.  
  321. /* Look for target of TAB operation.    */
  322. static int find_tab(GEMrawobject* tree, int obj)
  323.     {            /* Check for hiddens subtree.        */
  324.     if (HIDETREE & tree[obj].Flags())
  325.         return (FALSE);
  326.                 /* If not EDITABLE, who cares?        */
  327.     if ( !(EDITABLE & tree[obj].Flags()) )
  328.         return (TRUE);
  329.                 /* Check for forward tab match        */
  330.     if (fn_dir && fn_prev == fn_last)
  331.         fn_obj = obj;
  332.                 /* Check for backward tab match        */
  333.     if (!fn_dir && obj == fn_last)
  334.         fn_obj = fn_prev;
  335.     fn_prev = obj;        /* Record object for next call.        */
  336.     return (TRUE);
  337. }    
  338.  
  339. static int form_keyboard(GEMrawobject* tree, int edit_obj, int next_obj, int kr, int *out_obj, int *okr)
  340. {
  341.     if (kr&0xff)        /* If lower byte valid, mask out    */
  342.         kr &= 0xff;    /* extended code byte.            */
  343.     fn_dir = 0;        /* Default tab direction if backward.    */
  344.     switch (kr) {
  345.         case CR:    /* Zap character.            */
  346.             *okr = 0;
  347.                 /* Look for a DEFAULT object.        */
  348.             fn_obj = NIL;
  349.             map_tree(tree, ROOT, NIL, find_def);
  350.                 /* If found, SELECT and force exit.    */
  351.             if (fn_obj != NIL)
  352.                 {
  353.                 objc_sel(tree, fn_obj);
  354.                 *out_obj = fn_obj;
  355.                 return (FALSE);
  356.                 }        /* Falls through to     */ 
  357.         case TAB:            /* tab if no default     */
  358.         case DOWN:    
  359.             fn_dir = 1;        /* Set fwd direction     */
  360.         case BTAB:
  361.         case UP:
  362.             *okr = 0;        /* Zap character    */
  363.             fn_last = edit_obj;
  364.             fn_prev = fn_obj = NIL; /* Look for TAB object    */
  365.             map_tree(tree, ROOT, NIL, find_tab);
  366.             if (fn_obj == NIL)    /* try to wrap around     */
  367.                 map_tree(tree, ROOT, NIL, find_tab);
  368.             if (fn_obj != NIL)
  369.                 *out_obj = fn_obj;
  370.             break;
  371.         default:            /* Pass other chars    */
  372.             return (TRUE);
  373.         }
  374.     return (TRUE);
  375. }
  376.  
  377. /************* Mouse button manager and subroutines ***************/
  378.  
  379. static void do_radio(GEMrawobject* tree, int obj)
  380. {
  381.     GRect    root;
  382.     int    pobj, sobj;
  383.  
  384.     objc_xywh(tree, ROOT, &root);
  385.     pobj = get_parent(tree, obj);        /* Get the object's parent */
  386.  
  387.     for (sobj = tree[pobj].Head(); sobj != pobj;
  388.         sobj = tree[sobj].Next() )
  389.         {                /* Deselect all but...       */
  390.         if (sobj != obj)
  391.             objc_dsel(tree, sobj);
  392.         }
  393.     objc_sel(tree, obj);            /* the one being SELECTED  */
  394. }
  395.  
  396. /* Mouse button handler       */
  397. static int form_butn(GEMrawobject* tree, int obj, int clicks, int *next_obj, int *hot_obj)
  398. {
  399.     int    flags, state, hibit, texit, sble, dsbld, edit;
  400.     int    in_state;
  401.  
  402.     flags = tree[obj].Flags();        /* Get flags and states   */
  403.     state = tree[obj].States();
  404.     texit = flags & TOUCHEXIT;
  405.     sble = flags & SELECTABLE;
  406.     dsbld = state & DISABLED;
  407.     edit = flags & EDITABLE;
  408.  
  409.     if (!texit && (!sble || dsbld) && !edit) /* This is not an      */
  410.         {                 /* interesting object    */
  411.         *next_obj = 0;
  412.         return (TRUE);
  413.         }
  414.  
  415.     if (texit && clicks == 2)        /* Preset special flag    */
  416.         hibit = 0x8000;
  417.     else
  418.         hibit = 0x0;
  419.  
  420.     if (sble && !dsbld)            /* Hot stuff!        */
  421.         {
  422.         if (flags & RBUTTON)        /* Process radio buttons*/
  423.             do_radio(tree, obj);    /* immediately!        */ 
  424.         else if (!texit)
  425.             {
  426.             in_state = (obj == *hot_obj)?    /* Already toggled ? */
  427.             state: state ^ SELECTED;    
  428.  
  429.             if (!graf_watchbox(tree, obj, in_state, 
  430.                 in_state ^ SELECTED))
  431.                 {            /* He gave up...  */
  432.                 *next_obj = 0;
  433.                 *hot_obj = NIL;
  434.                 return (TRUE);
  435.                 }
  436.             }
  437.         else /* if (texit) */
  438.             if (obj != *hot_obj)    /* Force SELECTED    */
  439.                 objc_toggle(tree, obj);
  440.         }
  441.  
  442.     if (obj == *hot_obj)        /* We're gonna do it! So don't    */
  443.         *hot_obj = NIL;        /* turn it off later.        */
  444.  
  445.     if (texit || (flags & EXIT) )    /* Exit conditions.        */
  446.         {
  447.         *next_obj = obj | hibit;
  448.         return (FALSE);        /* Time to leave!        */
  449.         }
  450.     else if (!edit)            /* Clear object unless tabbing    */
  451.         *next_obj = 0;
  452.  
  453.     return (TRUE);
  454. }
  455.  
  456. static int to_find;
  457. static int FindToFind(GEMrawobject* o, int i)
  458. {
  459.     return i==to_find ? i : -1;
  460. }
  461.  
  462.  
  463. /************* New forms manager: main loop *************/
  464.  
  465. int GEMhotform::FormDo()
  466. {
  467.     int    edit_obj;
  468.     int        next_obj, hot_obj, hot_mode;
  469.     int        which, cont;
  470.     int        idx;
  471.     int        mx, my, mb, meta, kr, br;
  472.     GRect        hot_rect;
  473.  
  474.     wind_update(BEG_MCTRL);
  475.  
  476.     /* Init. editing    */
  477.     to_find=curedit;
  478.     if (Map(FindToFind)!=to_find) // Is it hidden?
  479.         curedit=Map(FindEdit);
  480.     next_obj = curedit;
  481.     edit_obj = 0;
  482.                         /* Initial hotspot cndx */
  483.     hot_obj = NIL; hot_mode = M1_ENTER;
  484.     objc_xywh(Obj, ROOT, &hot_rect);
  485.                         /* Main event loop    */
  486.     cont = TRUE;
  487.     while (cont) {
  488.                         /* position cursor on    */
  489.                         /*   the selected     */
  490.                         /*   editting field    */
  491.         if (edit_obj!=next_obj && next_obj!=0) {
  492.             edit_obj = next_obj;
  493.             next_obj = 0;
  494.             objc_edit(Obj, edit_obj, 0, idx, EDINIT, &idx);
  495.         }
  496.                         /* wait for button or   */
  497.                         /* key or rectangle    */
  498.         which = evnt_multi(MU_KEYBD | MU_BUTTON | MU_M1, 
  499.             0x01, // WWA - Only single click - else race can occur between clicks
  500.             0x01, 0x01,
  501.             hot_mode, hot_rect.g_x, hot_rect.g_y, 
  502.                 hot_rect.g_w, hot_rect.g_h, 
  503.             0, 0, 0, 0, 0,
  504.             0x0L,
  505.             0,
  506.             &mx, &my, &mb, &meta, &kr, &br);
  507.  
  508.         if (which & MU_M1) {            /* handle rect. event     */
  509.             if (hot_obj != NIL) {
  510.                 int h=DoHot(hot_obj,FALSE);
  511.                 if (h!=Ignore) {
  512.                     next_obj=h;
  513.                     cont=FALSE;
  514.                 }
  515.             }
  516.  
  517.             if (cont) {
  518.                 hot_obj = form_hot(Obj, hot_obj, mx, my, &hot_rect, &hot_mode);
  519.  
  520.                 if (hot_obj != NIL) {
  521.                     int h=DoHot(hot_obj,TRUE);
  522.                     if (h!=Ignore) {
  523.                         next_obj=h;
  524.                         cont=FALSE;
  525.                     }
  526.                 }
  527.             }
  528.         }
  529.  
  530.         if (which & MU_KEYBD) { /* handle keyboard event*/
  531.             /* Control char filter    */
  532.             cont = form_keyboard(Obj, edit_obj, next_obj, kr, &next_obj, &kr);
  533.             if (kr) {
  534.                 int k=DoKey(meta,kr);
  535.                 if (k!=Ignore) {
  536.                     next_obj=k;
  537.                     cont=FALSE;
  538.                 } else {
  539.                     if (edit_obj>0) {
  540.                         objc_edit(Obj, edit_obj, kr, idx, EDCHAR, &idx);
  541.                     }
  542.                 }
  543.             }
  544.           }
  545.                         /* handle button event    */
  546.         if (which & MU_BUTTON) {
  547.             /* Which object hit?    */
  548.             next_obj = objc_find(Obj, ROOT, MAX_DEPTH, mx, my);
  549.              if (next_obj == NIL) {
  550.                 next_obj = DoOff();
  551.                 if (next_obj==NoObject) {
  552.                     cont = FALSE; // We want non-form click to cancel form
  553.                 }
  554.             } else {
  555.                     /* Process a click    */
  556.                 // UnHot the object, rather than expecting form_butn to deal with it.
  557.                 if (hot_obj != NIL) {
  558.                     DoHot(hot_obj,FALSE);
  559.                     hot_obj=NIL;
  560.                 }
  561.                 cont = form_butn(Obj, next_obj, br, &next_obj, &hot_obj);
  562.             }
  563.           }
  564.                         /* handle end of field    */
  565.                         /*   clean up        */
  566.         if (!cont || (next_obj != edit_obj && next_obj != 0))
  567.         if (edit_obj != 0) 
  568.           objc_edit(Obj, edit_obj, 0, idx, EDEND, &idx);
  569.     }
  570.                         /* If defaulted, may    */
  571.                         /* need to clear hotspot*/
  572.     if (hot_obj != (next_obj & 0x7fff))
  573.         if (hot_obj != NIL)
  574.             DoHot(hot_obj,FALSE);
  575.                         /* return exit object    */
  576.                         /*   hi bit may be set    */
  577.                         /*   if exit obj. was    */
  578.                         /*   double-clicked    */
  579.     curedit = edit_obj;
  580.  
  581.     wind_update(END_MCTRL);
  582.  
  583.     return(next_obj);
  584. }
  585.