home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 331 / gemfxm14 / minicolr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-20  |  34.4 KB  |  822 lines
  1. /**************************************************************************
  2.  *
  3.  * mini_pallete - A little bitty control-panel-like color pallete acc.
  4.  *
  5.  *  Public Domain example program by Ian Lepore.
  6.  *
  7.  *  This is distributed as an example of how to write an accessory using
  8.  *  my AESFAST public domain GEM bindings.  This example uses a few of
  9.  *  the nifty utilities from AESFAST, but it's pretty much straightforward
  10.  *  window-handling code.
  11.  *
  12.  *  I built this beast because I have some graphics programs (Mandelbrot
  13.  *  fractal generators, a spyrograph program, etc), in which one would
  14.  *  naturally want to change the screen colors on the fly, but the %^$%#*&
  15.  *  system control panel covers the whole screen in low rez.  This acc
  16.  *  gives a nice itty-bitty moveable window with all the necessary color
  17.  *  controls in it.
  18.  *
  19.  *  This acc does not behave like the system control panel, in that it
  20.  *  will not reset the colors the application has set when you call it up.
  21.  *  On the other hand, the color changes you do with this accessory will 
  22.  *  not be saved if you use 'Save Desktop'. (Hint:  You would need to code
  23.  *  the shel_read() and shel_write() AES functions to make that work.  
  24.  *  Actually doing it is left as an excerise for the reader <grin>).
  25.  *
  26.  *  Also, the order of the colored boxes on the screen corresponds to the
  27.  *  TOS order of colors, not the VDI order.  (EG:  The foreground and
  28.  *  background colors are the first and last boxes, not the first two).
  29.  *
  30.  *  This code is pretty heavily commented.  Please excuse me if some of 
  31.  *  the comments seem obvious, but I figure the audience for this will 
  32.  *  include both beginning C programmers, and old-timers who just need to
  33.  *  see how my bindings work as opposed to other bindings.
  34.  *
  35.  *************************************************************************/
  36.  
  37. #include <gemfast.h>
  38. #include <osbind.h>
  39.  
  40. #ifndef TRUE
  41. #define TRUE  1
  42. #define FALSE 0
  43. #endif
  44.  
  45. #define Getcolor(a) ((int)(Setcolor((a), -1)))
  46.  
  47. #define graf_mkstate    graq_mstate    /* use Line-A mouse state call */
  48.  
  49. /**************************************************************************
  50.  *
  51.  * global vars (gee, there's not many of these for a change...)
  52.  *
  53.  *************************************************************************/
  54.  
  55. struct rgb_settings {
  56.         char red, grn, blu, filler;
  57.         } cur_setting;
  58.  
  59. int     coloridx = 0;                   /* default color index is # 0    */
  60.  
  61. #define WI_KIND         (MOVER|CLOSER|NAME)
  62. #define NO_WINDOW       -1
  63.  
  64. extern int gl_apid;                     /* defined in bindings library   */
  65.  
  66. int     menu_id ;                       /* our menu id                   */
  67. int     wi_handle;                      /* window handle                 */
  68. GRECT   treerect;                       /* object tree (in window) rect  */
  69.  
  70. char    menu_title[] = "  Mini Pallete  ";
  71. char    wind_title[] = " Mini Pallete ";
  72.  
  73. /**************************************************************************
  74.  *
  75.  * palttree - The color pallete dialog tree.
  76.  *
  77.  *  This is NOT the output from a resource editor (it was a long time ago,
  78.  *  but it's been pretty much re-done by hand).
  79.  *
  80.  *  About extended object types... 
  81.  *
  82.  *  The ob_type field is a word, but the AES only uses the lower byte of 
  83.  *  it.  It has become a sort of standard technique for programs to use
  84.  *  the upper byte for their own evil purposes.  (Really, the object 
  85.  *  structure should have had an 'ob_apspec' longword in it for the 
  86.  *  application's use).  Anyway, there is some discussion under the 
  87.  *  'find_boxchar' routine below on accessing arrays of objects in a tree
  88.  *  without being sure where the objects are in the tree array.  The
  89.  *  methods discussed below work fine for boxchar objects; the extended
  90.  *  object type can be used for other types of objects.  
  91.  *
  92.  *  For example, suppose you have 10 strings in a dialog box.  You want to
  93.  *  set the ob_spec pointers at runtime to correspond to the elements in
  94.  *  an array of strings you've defined in your program.  You can code a
  95.  *  lot of C statements using the hard-coded object names, but what if you
  96.  *  have 50 strings instead of 10?  More to the point, what if some hacker
  97.  *  edits the .RSC file and changes the order of the objects? Bombs, that's
  98.  *  what.  So, you can (with most resource editors) set the extended 
  99.  *  object type for the strings to the numbers 1-10, then at runtime you
  100.  *  can scan the tree looking for an object with an extended type of 1,
  101.  *  then set the first string pointer, then scan for 2, and so on.  Now,
  102.  *  no matter where those strings get moved to in the tree structure, they
  103.  *  will be found at runtime and pointers will be assigned properly.
  104.  *
  105.  *  Now that I've described this nifty string-thing, I should mention that
  106.  *  this program doesn't use that techique, as it contains no strings in
  107.  *  the dialog. 
  108.  * 
  109.  *  This program uses the extended object type to hold the TOS color index
  110.  *  value that corresponds to the colored box which is the object.  This
  111.  *  is due to the screwy way the ST maps TOS colors to VDI colors.  If you
  112.  *  compare the VDI/object color number in the ob_spec field to the extended
  113.  *  object type value, you'll see the translation table that maps TOS colors
  114.  *  to GEM colors.  For the ob_type values below which are not described
  115.  *  by name, the format is 0xcc14, where 'cc' is the TOS color number, and
  116.  *  '14' is a box type object.
  117.  *
  118.  *  The ob_spec field for box-like objects maps out as follows:
  119.  *   0xaabbcdef
  120.  *     |||||||+-- inside fill color
  121.  *     ||||||+--- fill pattern and opaque/transparent flag
  122.  *     |||||+---- text color
  123.  *     ||||+----- border color
  124.  *     ||++------ border thickness (neg = outside width, pos = inside width)
  125.  *     ++-------- ASCII character for boxchar objects, zero for other types
  126.  *
  127.  *  The two objects flagged as HIDETREE are no longer used, and I don't
  128.  *  want to rebuild the whole tree to remove them (and I've lost the
  129.  *  .RSC file that this source comes from).
  130.  *************************************************************************/
  131.  
  132. OBJECT  palttree[] = {
  133.  
  134. /*          type       flags   state   ob_spec     x       y       w        h   */
  135.  
  136. -1,  1, 35, G_BOX,     NONE,     0, 0x00000000L, 0x0000, 0x0000, 0x0212, 0x0506,
  137.  
  138.  2, -1, -1, G_BOXCHAR, HIDETREE, 0, 0x05FF1100L, 0x0000, 0x0000, 0x0000, 0x0000,
  139.  3, -1, -1, G_BOX,     HIDETREE, 0, 0x00FF1121L, 0x0000, 0x0000, 0x0000, 0x0000,
  140.  
  141.  7,  4,  6, G_IBOX,    NONE,     0, 0x00001101L, 0x0100, 0x0100, 0x0401, 0x0703,
  142.  5, -1, -1, G_BOXCHAR, NONE,     0, 0x52001100L, 0x0200, 0x0100, 0x0001, 0x0001,
  143.  6, -1, -1, G_BOXCHAR, NONE,     0, 0x47001100L, 0x0200, 0x0401, 0x0001, 0x0001,
  144.  3, -1, -1, G_BOXCHAR, NONE,     0, 0x42001100L, 0x0200, 0x0702, 0x0001, 0x0001,
  145.  
  146. 35,  8, 26, G_IBOX,    NONE,     0, 0x00001100L, 0x0501, 0x0200, 0x0210, 0x0603,
  147.  
  148. 17,  9, 16, G_IBOX,    NONE,     0, 0x00001100L, 0x0100, 0x0000, 0x0010, 0x0001,
  149. 10, -1, -1, G_BOXCHAR, NONE,     0, 0x30FF1100L,  0, 0, 2, 1,
  150. 11, -1, -1, G_BOXCHAR, NONE,     0, 0x31FF1100L,  2, 0, 2, 1,
  151. 12, -1, -1, G_BOXCHAR, NONE,     0, 0x32FF1100L,  4, 0, 2, 1,
  152. 13, -1, -1, G_BOXCHAR, NONE,     0, 0x33FF1100L,  6, 0, 2, 1,
  153. 14, -1, -1, G_BOXCHAR, NONE,     0, 0x34FF1100L,  8, 0, 2, 1,
  154. 15, -1, -1, G_BOXCHAR, NONE,     0, 0x35FF1100L, 10, 0, 2, 1,
  155. 16, -1, -1, G_BOXCHAR, NONE,     0, 0x36FF1100L, 12, 0, 2, 1,
  156.  8, -1, -1, G_BOXCHAR, NONE,     0, 0x37FF1100L, 14, 0, 2, 1,
  157.  
  158. 26, 18, 25, G_IBOX,    NONE,     0, 0x00001100L, 0x0100, 0x0301, 0x0010, 0x0001,
  159. 19, -1, -1, G_BOXCHAR, NONE,     0, 0x30FF1100L,  0, 0, 2, 1,
  160. 20, -1, -1, G_BOXCHAR, NONE,     0, 0x31FF1100L,  2, 0, 2, 1,
  161. 21, -1, -1, G_BOXCHAR, NONE,     0, 0x32FF1100L,  4, 0, 2, 1,
  162. 22, -1, -1, G_BOXCHAR, NONE,     0, 0x33FF1100L,  6, 0, 2, 1,
  163. 23, -1, -1, G_BOXCHAR, NONE,     0, 0x34FF1100L,  8, 0, 2, 1,
  164. 24, -1, -1, G_BOXCHAR, NONE,     0, 0x35FF1100L, 10, 0, 2, 1,
  165. 25, -1, -1, G_BOXCHAR, NONE,     0, 0x36FF1100L, 12, 0, 2, 1,
  166. 17, -1, -1, G_BOXCHAR, NONE,     0, 0x37FF1100L, 14, 0, 2, 1,
  167.  
  168.  7, 27, 34, G_IBOX,    NONE,     0, 0x00001100L, 0x0100, 0x0602, 0x0010, 0x0001,
  169. 28, -1, -1, G_BOXCHAR, NONE,     0, 0x30FF1100L,  0, 0, 2, 1,
  170. 29, -1, -1, G_BOXCHAR, NONE,     0, 0x31FF1100L,  2, 0, 2, 1,
  171. 30, -1, -1, G_BOXCHAR, NONE,     0, 0x32FF1100L,  4, 0, 2, 1,
  172. 31, -1, -1, G_BOXCHAR, NONE,     0, 0x33FF1100L,  6, 0, 2, 1,
  173. 32, -1, -1, G_BOXCHAR, NONE,     0, 0x34FF1100L,  8, 0, 2, 1,
  174. 33, -1, -1, G_BOXCHAR, NONE,     0, 0x35FF1100L, 10, 0, 2, 1,
  175. 34, -1, -1, G_BOXCHAR, NONE,     0, 0x36FF1100L, 12, 0, 2, 1,
  176. 26, -1, -1, G_BOXCHAR, NONE,     0, 0x37FF1100L, 14, 0, 2, 1,
  177.  
  178.  0, 36, 51, G_IBOX,    NONE,     0, 0x00001100L, 0x0000, 0x0104, 0x0212, 0x0302,
  179. 37, -1, -1, 0x0014,    NONE,     0, 0x00011170L, 512,    512,    2,      1,
  180. 38, -1, -1, 0x0814,    NONE,     0, 0x00000179L, 512,    769,    2,      1,
  181. 39, -1, -1, 0x0114,    NONE,     0, 0x00001172L, 1026,   512,    2,      1,
  182. 40, -1, -1, 0x0214,    NONE,     0, 0x00002173L, 1540,   512,    2,      1,
  183. 41, -1, -1, 0x0314,    NONE,     0, 0x00003176L, 7,      512,    2,      1,
  184. 42, -1, -1, 0x0414,    NONE,     0, 0x00000174L, 521,    512,    2,      1,
  185. 43, -1, -1, 0x0514,    NONE,     0, 0x00001177L, 1035,   512,    2,      1,
  186. 44, -1, -1, 0x0614,    NONE,     0, 0x00002175L, 1549,   512,    2,      1,
  187. 45, -1, -1, 0x0A14,    NONE,     0, 0x0000217BL, 1540,   769,    2,      1,
  188. 46, -1, -1, 0x0B14,    NONE,     0, 0x0000317EL, 7,      769,    2,      1,
  189. 47, -1, -1, 0x0C14,    NONE,     0, 0x0000017CL, 521,    769,    2,      1,
  190. 48, -1, -1, 0x0D14,    NONE,     0, 0x0000117FL, 1035,   769,    2,      1,
  191. 49, -1, -1, 0x0E14,    NONE,     0, 0x0000217DL, 1549,   769,    2,      1,
  192. 50, -1, -1, 0x0714,    NONE,     0, 0x00003178L, 16,     512,    2,      1,
  193. 51, -1, -1, 0x0914,    NONE,     0, 0x0000117AL, 1026,   769,    2,      1,
  194. 35, -1, -1, 0x0F14,    LASTOB,   0, 0x00003171L, 16,     769,    2,      1
  195. }; /* END of palttree[] */
  196.  
  197. /* resource set indicies (names) for objects in palttree */
  198.  
  199. #define PALTTREE 0  /* root */
  200. #define PALTPNUM 7  /* Parent box for all the intensity parents */
  201. #define PALTPRED 8  /* Parent box for the RED intensity numbers */
  202. #define PALTPGRN 17 /* Parent box for the GRN intensity numbers */
  203. #define PALTPBLU 26 /* Parent box for the BLU intensity numbers */
  204. #define PALTPCOL 35 /* Parent box for the color-selection boxes */
  205.  
  206. /**************************************************************************
  207.  *
  208.  * find_boxchar - Return the object index of a child boxchar with a given
  209.  *  letter in its box, or -1 if no matching object can be found.
  210.  *
  211.  *  Say what?  Well, this routine cruises through all the children of a 
  212.  *  given parent object, and for every boxchar type object found the char
  213.  *  in the box is compared to the char passed to this routine.  On the 
  214.  *  first match found, the object index of the matching object is returned.
  215.  *  (Note that the object type is masked with 0x00FF to strip out any
  216.  *  extended object type info, so that the object type compare will work).
  217.  *  
  218.  *  Why do this, you wonder?  Well, boxchar objects make great radio
  219.  *  buttons, especially for things like selecting a device, or in this 
  220.  *  case, a color intensity from 0-7.  In the case of device selection, 
  221.  *  you need to have buttons for A-P, but on most systems, there won't
  222.  *  be this many devices, and you'll need to set some of the buttons
  223.  *  (boxchars) to DISABLED.  Since you'll be doing this at runtime, you
  224.  *  need a way to find the corresponding button for each device.  It is
  225.  *  AN ABSOLUTE NO-NO to hard-code object indicies (names) or treat the 
  226.  *  objects as an array, because as soon as you do some user will come  
  227.  *  along with a resouce editor & re-sort your objects.  Then the user will
  228.  *  complain when s/he clicks on the drive A button, and drive B gets
  229.  *  formatted instead.
  230.  *
  231.  *************************************************************************/
  232.  
  233. int
  234. find_boxchar(tree, parent, boxchar)
  235.         register OBJECT *tree;
  236.         register int    parent;
  237.         register char   boxchar;
  238. {
  239.         register int kid;
  240.  
  241.         kid = tree[parent].ob_head;
  242.  
  243.         while ( (kid != parent) && (kid >= R_TREE) ) {
  244.                 if ((0x00FF & tree[kid].ob_type) == G_BOXCHAR) {
  245.                         if (boxchar == (char)(tree[kid].ob_spec >> 24)) {
  246.                                 return(kid);
  247.                         }
  248.                 }
  249.                 kid = tree[kid].ob_next;
  250.         }
  251.         return(-1);
  252. }
  253.  
  254. /**************************************************************************
  255.  *
  256.  * rgb2color - convert cur_settings structure to a TOS color value.
  257.  *  This routine combines the separate ASCII RGB values into a single
  258.  *  integer RGB value in TOS format.  That is, if the cur_settings struct
  259.  *  contains '2', '6', and '3', this routine will return 0x0263.
  260.  *  
  261.  *************************************************************************/
  262.  
  263. int
  264. rgb2color()
  265. {
  266.         return ( ((cur_setting.red & 0x000F) << 8) | 
  267.                  ((cur_setting.grn & 0x000F) << 4) | 
  268.                   (cur_setting.blu & 0x000F) );
  269. }
  270.  
  271. /**************************************************************************
  272.  *
  273.  * color2rgb - convert a TOS color to characters in cur_settings.
  274.  *  This routine separates an integer TOS-format RGB value into 3 ASCII
  275.  *  characters in cur_settings.  If the TOS color is 0x0746, the structure
  276.  *  will contain '7', '4', and '6'.
  277.  *
  278.  *************************************************************************/
  279.  
  280. void
  281. color2rgb(color)
  282.         register int color;
  283. {
  284.         cur_setting.red = '0' + ( 0x000F & (color >> 8) );
  285.         cur_setting.grn = '0' + ( 0x000F & (color >> 4) );
  286.         cur_setting.blu = '0' + ( 0x000F &  color );
  287. } 
  288.  
  289. /**************************************************************************
  290.  *
  291.  * new_color - Change the current selected color box on the screen (like
  292.  *  a radio button), and set the new intensity settings (numbered boxes) 
  293.  *  to match the new active color box.
  294.  *
  295.  *  To show which color box is current, we set the ob_state to CROSSED
  296.  *  instead of SELECTED.  SELECTED will invert the color of the object,
  297.  *  which sorta defeats our purpose.  We don't have as much room on the
  298.  *  screen as the regular control panel, so we can't just make the box
  299.  *  a little bigger like it does.
  300.  *
  301.  *  If 'drawflag' is TRUE, the screen is updated with the state changes
  302.  *  (this is the normal state of affairs).  If the flag is FALSE, the
  303.  *  object states are set, but no screen work is done (this is for
  304.  *  initializing the dialog before it is displayed).
  305.  *************************************************************************/
  306.  
  307. void 
  308. new_color(newobject, drawflag)
  309.         register int newobject, drawflag;
  310. {
  311.         register OBJECT *ptree;
  312.         register int    wrkobject;
  313.         register int    curobject;
  314.         int             dmy;
  315.  
  316.         ptree = palttree;               /* quick register tree pointer */
  317.  
  318. /*
  319.  * figure out which is the currently-selected color box object. 
  320.  * if the current object is the same as the new object, the user is
  321.  * leaning on the mouse button; to avoid nasty object flashing on
  322.  * the screen in this case, just return.
  323.  */
  324.  
  325.         curobject = obj_rbfind(ptree, PALTPCOL, CROSSED);
  326.         if (curobject == newobject) {
  327.                 return;
  328.         }
  329.         
  330. /*
  331.  * de-select the numbered radio buttons that show the intensity
  332.  * settings for the current color.  the 'if (-1 != ...)' logic prevents
  333.  * us from croaking the first time thru, since no buttons will be selected.
  334.  */
  335.  
  336.         if (-1 != (wrkobject = objrb_which(ptree, PALTPRED)))
  337.                 objst_change(ptree, wrkobject, ~SELECTED, drawflag);
  338.         if (-1 != (wrkobject = objrb_which(ptree, PALTPGRN)))
  339.                 objst_change(ptree, wrkobject, ~SELECTED, drawflag);
  340.         if (-1 != (wrkobject = objrb_which(ptree, PALTPBLU)))
  341.                 objst_change(ptree, wrkobject, ~SELECTED, drawflag);
  342.  
  343. /*
  344.  * de-select the current color box, select the new color box.  
  345.  * again the '-1' check is for the first time thru case.
  346.  */
  347.  
  348.         if (-1 != curobject) 
  349.                 objst_change(ptree, curobject, ~CROSSED, drawflag);
  350.         objst_change(ptree, newobject,  CROSSED, drawflag);
  351.  
  352. /*
  353.  * change our picture of what's current.  the TOS color index is encoded
  354.  * as the 'extended object type' of the color-box objects (see discussion 
  355.  * on this above, where palttree is defined).  the 'color2rgb' call will
  356.  * fill in the 'cur_settings' structure to represent the current intensity
  357.  * of the color just selected.  
  358.  */
  359.  
  360.         coloridx = 0x000F & (ptree[newobject].ob_type >> 8);
  361.         color2rgb( Getcolor(coloridx) );
  362.  
  363. /*
  364.  * select the appropriate numbered boxes to represent the color intensity
  365.  * settings for the newly-selected color. the 'cur_settings' array holds
  366.  * the ASCII representation of the RGB instensities.  this is done so that
  367.  * we can find the corresponding radio buttons (which are BOXCHAR objects)
  368.  * via the find_boxchar() function.
  369.  */
  370.  
  371.         wrkobject = find_boxchar(ptree, PALTPRED, cur_setting.red);
  372.         objst_change(ptree, wrkobject,  SELECTED, drawflag);
  373.         
  374.         wrkobject = find_boxchar(ptree, PALTPGRN, cur_setting.grn);    
  375.         objst_change(ptree, wrkobject,  SELECTED, drawflag);
  376.         
  377.         wrkobject = find_boxchar(ptree, PALTPBLU, cur_setting.blu);
  378.         objst_change(ptree, wrkobject,  SELECTED, drawflag);
  379.  
  380. /* all done */
  381.  
  382. }
  383.      
  384. /**************************************************************************
  385.  *
  386.  * new_settings - Process a click in a numbered box of the dialog, and
  387.  *  change the color intensity in the TOS color pallete correspondingly.
  388.  *
  389.  *************************************************************************/
  390.  
  391. void
  392. new_settings(newobject)
  393. {
  394.         char boxchar;
  395.         int  curparent,
  396.              curobject;
  397.  
  398. /*
  399.  * figure out what's being changed.  the 'curparent' value will tell us
  400.  * whether it's the R, G, or B value.  the 'curobject' is used to detect
  401.  * whether the user is leaning on the mouse (curobject == newobject);
  402.  * in this case we exit without taking any action, to avoid nasty graphic
  403.  * flashing on the screen.
  404.  *
  405.  */
  406.  
  407.         curparent = obj_parent(palttree, newobject);
  408.         curobject = objrb_which(palttree, curparent);
  409.         
  410.         if (curobject == newobject) {
  411.                 return;
  412.         }
  413.         
  414. /*
  415.  * the displayed intensity buttons are G_BOXCHAR objects, with the chars
  416.  * ranging from '0' - '7' for each color.  we pluck the displayed char 
  417.  * out of the ob_spec value in the tree (ob_spec for boxchars looks like
  418.  * 0xCCnnnnnn), and we plug the char right into the 'cur_settings' array,
  419.  * still in its ASCII form. 
  420.  */
  421.  
  422.         boxchar = (char)(palttree[newobject].ob_spec >> 24);
  423.  
  424.         switch (curparent) {
  425.                 case PALTPRED:
  426.                         cur_setting.red = boxchar;
  427.                         break;
  428.                 case PALTPGRN:
  429.                         cur_setting.grn = boxchar;
  430.                         break;
  431.                 case PALTPBLU:
  432.                         cur_setting.blu = boxchar;
  433.                         break;
  434.         }  
  435.         
  436. /* 
  437.  * now that the 'cur_settings' array contains the new intensity setting,
  438.  * call 'rgb2color' to convert the ASCII values to a single binary TOS
  439.  * color value, then call the TOS 'Setcolor' function to make the change.
  440.  */
  441.  
  442.         Setcolor( coloridx, rgb2color() );
  443.  
  444. /*
  445.  * de-select the old intensity setting, select the new one...
  446.  */
  447.         objst_change(palttree, curobject, ~SELECTED, TRUE);
  448.         objst_change(palttree, newobject,  SELECTED, TRUE); 
  449.  
  450. /* all done */
  451.  
  452. }
  453.  
  454. /**************************************************************************
  455.  *
  456.  * prg_init - Mundane program init stuff.
  457.  *  The only item of note here is a call to 'rsc_treefix'.  This is a
  458.  *  routine from the AESFAST library that will do an rsrc_obfix() call for
  459.  *  each object in a tree.  It's used only for resource trees buried in 
  460.  *  source code, if the resource file is loaded, the rsrc_load() call
  461.  *  handles the object x/y/w/h fixup internally.
  462.  *
  463.  *  Oh yeah -- I discovered an interesting problem coding this:  If the
  464.  *  'menu_register' call is not the first AES call following the appl_init
  465.  *  the accessory sometimes doesn't show up on the DESK menu until
  466.  *  after you've run some other GEM program.  This is consistant with the
  467.  *  rules of AES multitasking:  your program can be swapped out on ANY
  468.  *  AES call, not just when you do an evnt_???? call.  It just isn't 
  469.  *  mentioned in any of the docs I have.
  470.  *************************************************************************/
  471.  
  472. prg_init()
  473. {
  474.         appl_init();
  475.  
  476.         menu_id = menu_register(gl_apid, menu_title);
  477.         
  478.         rsc_treefix(palttree);
  479.  
  480.         form_center(palttree, &treerect.g_x, &treerect.g_y, 
  481.                               &treerect.g_w, &treerect.g_h);
  482.  
  483.         new_color(0, FALSE);
  484.  
  485.         wi_handle = NO_WINDOW;
  486. }
  487.  
  488. /**************************************************************************
  489.  *
  490.  * open_window 
  491.  *   Create and open the window, if it's not open already.
  492.  *
  493.  *   If the window is already open, it may be hidden from the user by an
  494.  *   overlapping window, and the only way to get us back may be to
  495.  *   click on us again in the DESK menu.  In this case, we just ask
  496.  *   the AES to bring our window back to the top.
  497.  *
  498.  *   Before opening the window, we calculate its size and location (total 
  499.  *   size, including its borders & controls) based upon the current size 
  500.  *   and location of the pallete object tree.  The first time the window
  501.  *   opens, this will be the center of the screen, because we do a 
  502.  *   form_center on the pallete tree.  For subsequent calls, we show up
  503.  *   wherever we were last on the screen.
  504.  *
  505.  *   We also set the window title bar here, before opening the window.   
  506.  *************************************************************************/
  507.  
  508. open_window()
  509. {
  510.         GRECT windrect;
  511.         
  512.         if (wi_handle == NO_WINDOW) {
  513.         
  514.                 wind_calc(WC_BORDER, WI_KIND, treerect, 
  515.                            &windrect.g_x, &windrect.g_y,
  516.                            &windrect.g_w, &windrect.g_h);
  517.                            
  518.                 wi_handle = wind_create(WI_KIND, windrect);
  519.                 
  520.                 wind_set(wi_handle, WF_NAME, wind_title, 0L);
  521.                 
  522.                 wind_open(wi_handle, windrect);
  523.         } 
  524.         else {
  525.                 wind_set(wi_handle, WF_TOP, 0L, 0L);
  526.         }
  527. }
  528.  
  529. /**************************************************************************
  530.  *
  531.  * close_window
  532.  *  Close and delete the window, if it's open.
  533.  *************************************************************************/
  534.  
  535. close_window()
  536. {
  537.         if (wi_handle != NO_WINDOW) {       
  538.                 wind_close(wi_handle);
  539.                 wind_delete(wi_handle);
  540.                 wi_handle = NO_WINDOW;
  541.         }
  542. }
  543.  
  544. /**************************************************************************
  545.  *
  546.  * do_redraw - Process redraw list.
  547.  *  Ok, let's see if I can explain this better than the DRI books do...
  548.  *
  549.  *  After somebody has munged up the screen (say with a dialog box), they
  550.  *  send a redraw request to the whole world.  The redraw request comes
  551.  *  from one of two sources:  1) Somebody does a form_dial(FMD_FINISH...)
  552.  *  call, or 2) Somebody does a wind_close() call.  (Ummm, ok, so there's
  553.  *  other sources, now that I think of it, like windows being moved or
  554.  *  sized).  Anyway, when AES sends out a redraw request, it sends it to
  555.  *  everybody who owns a window, and what it sends is the full x/y/w/h
  556.  *  values of the area of the screen to restore.
  557.  *
  558.  *  The area to be restored may or may not overlap any of the windows you
  559.  *  have open on the screen.  The AES can provide you with a list of the
  560.  *  visible rectangles that comprise your window(s).  (Remember that not
  561.  *  all of a window you have open may be visible).  So, to process a 
  562.  *  redraw, you have to ask AES for each of the visible rectangles, and
  563.  *  for each one returned, see if it overlaps the screen area to be redrawn.
  564.  *
  565.  *  There is a library routine in AESFAST called 'rc_intersect' that will
  566.  *  compute the intersecting portion of 2 rectangular screen areas. If 
  567.  *  the rectangles don't overlap at all, it will return FALSE.  Thus, we
  568.  *  have a loop in which we ask the AES for each rectangle, and we check
  569.  *  it against the redraw rectangle, and if there is some overlap, we call
  570.  *  the routine which actually draws the window contents, passing that
  571.  *  routine the boundries of the intersecting rectangle.  The looping 
  572.  *  continues until the AES returns us a rectangle from the list that has
  573.  *  zero height and width.
  574.  *
  575.  *************************************************************************/
  576.  
  577. do_redraw(updtrect)
  578.         GRECT updtrect;         /* the full area that needs updating */
  579. {
  580.         GRECT listrect;         /* one of our visible areas */
  581.  
  582.         wind_get(wi_handle, WF_FIRSTXYWH,
  583.                   &listrect.g_x, &listrect.g_y, 
  584.                   &listrect.g_w, &listrect.g_h);
  585.                   
  586.         while ( listrect.g_w && listrect.g_h ) {
  587.                 if ( rc_intersect(&updtrect, &listrect) ) {
  588.                         draw_window(listrect);
  589.                 }
  590.                 wind_get(wi_handle, WF_NEXTXYWH, 
  591.                           &listrect.g_x, &listrect.g_y,
  592.                           &listrect.g_w, &listrect.g_h);
  593.         }
  594. }
  595.  
  596.  
  597. /**************************************************************************
  598.  *
  599.  * draw_window - Draw the contents of the window, with clipping.
  600.  *  In this case, we just do an objc_draw call on our tree, passing the
  601.  *  clipping rectangle we receive along to the objc_draw.
  602.  *
  603.  *************************************************************************/
  604.  
  605.  
  606. draw_window(cliprect)
  607. GRECT cliprect;
  608. { 
  609.         objc_draw(palttree, R_TREE, MAX_DEPTH, cliprect);
  610. }
  611.  
  612.  
  613. /**************************************************************************
  614.  *
  615.  * just for grins dept:  This is what a draw_window() routine might
  616.  *  look like if the window was not based upon an object tree.  I'm
  617.  *  assuming a really stupid window which has a circle and some blit-based
  618.  *  graphics in it.
  619.  *
  620.  *************************************************************************/
  621.  
  622. #if 0                           /* don't really compile this code... */
  623.  
  624. draw_vwindow(cliprect)
  625. GRECT cliprect;
  626. {
  627.         long  dmyfdb = 0L;
  628.         VRECT vdiclip;
  629.         struct {
  630.                 VRECT blit1rect;
  631.                 VRECT blit2rect;
  632.                 } blitarea;
  633.  
  634. /*
  635.  * convert the GRECT-type clipping rectangle (x/y/w/h) to a VRECT-type
  636.  * rectangle (x1,y1,x2,y2).  set the VDI clipping area, and call the
  637.  * VDI circle function.
  638.  */
  639.  
  640.         rc_gtov(&cliprect, &vdiclip);
  641.         vs_clip(vdi_handle, &vdiclip, TRUE);
  642.         v_circle(vdi_handle, x, y, r);
  643.  
  644. /*
  645.  * for the blit, I'm assuming the blit buffer is a 32k screen image, and
  646.  * you just want to blit the corresponding area back onto the screen. the
  647.  * MFDB structure describing the blit buffer has already been filled out
  648.  * before this routine is ever called <grin>.  (Obscure Fact Dept: for
  649.  * blitting to the screen, a full MFDB is not needed...one only needs
  650.  * a longword of zeroes, which is a key telling VDI to use the screen as
  651.  * the destination.)
  652.  *
  653.  * the blit routine needs a VRECT describing the source and another 
  654.  * describing the destination, and the docs always describe this as a 
  655.  * 'pxy array', so everybody defines pxy[8] and tediously loads all the
  656.  * array elements with x/y values.  structures in C place all the elements
  657.  * contiguously, so the 'blitarea' structure defined above is pretty much
  658.  * equivelent to using a pxy array, except the code is now *much* more
  659.  * readable.
  660.  */
  661.         
  662.         rc_gtov(&cliprect, &blitarea.blit1rect);
  663.         rc_gtov(&cliprect, &blitarea.blit2rect);
  664.         vro_cpyfm(vdi_handle, S_ONLY, &blitarea, &sourcefdb, &dmyfdb);
  665. }
  666.  
  667. #endif
  668.  
  669. /**************************************************************************
  670.  *
  671.  * do_msg - Handle a message returned by evnt_multi().
  672.  *  This is pretty standard message handling for an accessory.  One item of
  673.  *  interest I discovered when building this is that you should *not* 
  674.  *  attempt to close any open windows when you get an AC_CLOSED message.
  675.  *  This message apparently tells you that your windows have already been
  676.  *  closed and deleted, and you should just mark your window handle(s) as
  677.  *  no longer valid.
  678.  *
  679.  *  The only piece of weirdness here is the WM_MOVED case.  The window
  680.  *  provides a frame for our object tree, so when it gets moved, we have
  681.  *  to update the ob_x and ob_y values in the pallete tree to match (so
  682.  *  that objc_draw commands will draw inside the window's work area).
  683.  *  The values in msgbuf reflect the new x/y/w/h of the window's total 
  684.  *  size (borders and controls included).  We have the option of changing
  685.  *  these values (like snapping to a character grid or whatever) or even
  686.  *  of ignoring them, but in this instance we don't care about any of that
  687.  *  so we just tell AES to use the values directly.  After doing the 
  688.  *  wind_set call to set the new location of the window, we call wind_get
  689.  *  to find out the new x/y/w/h of the work area of the window, so that
  690.  *  we can reposition the object tree.  We don't have to redraw the
  691.  *  window contents during WM_MOVED processing, because the AES will blit
  692.  *  the window contents for us if it can.  If not all of the window can
  693.  *  be blitted, the AES will send redraw messages to us, and we'll get
  694.  *  them on the next iteration of the evnt_multi loop.
  695.  *************************************************************************/
  696.  
  697. do_msg(msgbuf)
  698. register int msgbuf[];
  699. {
  700.  
  701.         switch (msgbuf[0]) {
  702.  
  703.                 case AC_OPEN:
  704.                         if (msgbuf[4] == menu_id) 
  705.                                 open_window();
  706.                         break;
  707.  
  708.                 case AC_CLOSE:
  709.                         wi_handle = NO_WINDOW;
  710.                         break;
  711.  
  712.                 case WM_REDRAW:
  713.                         if (msgbuf[3] == wi_handle)
  714.                                 do_redraw(msgbuf[4], msgbuf[5],
  715.                                           msgbuf[6], msgbuf[7]);
  716.                         break;
  717.  
  718.                 case WM_NEWTOP:
  719.                 case WM_TOPPED:
  720.                         if (msgbuf[3] == wi_handle) 
  721.                                 wind_set(wi_handle, WF_TOP, 0L, 0L);
  722.                         break;
  723.  
  724.                 case WM_CLOSED:
  725.                         close_window();
  726.                         break;
  727.  
  728.                 case WM_MOVED:
  729.                         if(msgbuf[3] == wi_handle) {
  730.                                 wind_set(wi_handle, WF_CURRXYWH, 
  731.                                           msgbuf[4], msgbuf[5],
  732.                                           msgbuf[6], msgbuf[7]);
  733.                                 wind_get(wi_handle, WF_WORKXYWH,
  734.                                           &treerect.g_x, &treerect.g_y, 
  735.                                           &treerect.g_w, &treerect.g_h);
  736.                                 palttree->ob_x = treerect.g_x;
  737.                                 palttree->ob_y = treerect.g_y;                 
  738.                         }
  739.                         break;
  740.  
  741.                 } /* END switch (msgbuf[0]) */
  742. }
  743.  
  744. /**************************************************************************
  745.  *
  746.  * do_btn - Handle a button click within our window.
  747.  *  Do a graf_mkstate() call to get the most-current location of the
  748.  *  mouse.  Call objc_find() to see if the mouse is located over an object
  749.  *  in our tree.  If so, we determine the parent of the tree.  If the
  750.  *  parent is one of the boxes which holds our various radio buttons, we
  751.  *  go process the button, as appropriate.  If it is over an object of
  752.  *  ours, but not within a parent box, we just ignore the click.
  753.  *
  754.  *************************************************************************/
  755.  
  756. do_btn()
  757. {
  758.         int mouse_x;
  759.         int mouse_y;
  760.         int selobject;
  761.         int dmy;
  762.         
  763.         graf_mkstate(&mouse_x, &mouse_y, &dmy, &dmy);
  764.  
  765.         selobject = objc_find(palttree, R_TREE, MAX_DEPTH, mouse_x, mouse_y);
  766.  
  767.         if (selobject != -1) {
  768.                 switch (obj_parent(palttree, selobject)) {
  769.                         case PALTPCOL: 
  770.                                 new_color(selobject, TRUE);
  771.                                 break;
  772.                         case PALTPRED: 
  773.                         case PALTPGRN:
  774.                         case PALTPBLU:
  775.                                 new_settings(selobject);
  776.                                 break;
  777.                 } /* END switch (obj_parent(selobject)) */
  778.         } /* END if (selobject != -1) */
  779. }
  780.  
  781. /**************************************************************************
  782.  *
  783.  * main routine
  784.  *  Call the init routine, then fall into a do-forever evnt_multi() loop.
  785.  *
  786.  *************************************************************************/
  787.  
  788. main()
  789. {
  790.         int dmy;
  791.         int event;
  792.         int msgbuf[8];
  793.         
  794.         prg_init();
  795.  
  796.         while (TRUE) {
  797.                 event = evnt_multi(
  798.                          MU_MESAG | MU_BUTTON,
  799.                          1,1,1,               /* mbclicks, mbmask, mbstate*/
  800.                          0,0,0,0,0,           /* Mouse event rectangle 1  */
  801.                          0,0,0,0,0,           /* Mouse event rectangle 2  */
  802.                          msgbuf,              /* Message buffer           */
  803.                          0,0,                 /* timer event, time = 0,0  */
  804.                          &dmy, &dmy,          /* Mouse x & y at event     */
  805.                          &dmy,                /* Mouse button at event    */
  806.                          &dmy,                /* Keystate at event        */           
  807.                          &dmy,                /* Keypress at event        */
  808.                          &dmy);               /* Mouse click count        */
  809.  
  810.                 wind_update(BEG_UPDATE);
  811.  
  812.                 if (event & MU_MESAG)
  813.                         do_msg(msgbuf);
  814.                 
  815.                 if (event & MU_BUTTON) 
  816.                         do_btn();
  817.                 
  818.                 wind_update(END_UPDATE);
  819.         
  820.         } /* END while (TRUE) */
  821. }
  822.