home *** CD-ROM | disk | FTP | other *** search
/ Dream 44 / Amiga_Dream_44.iso / Linux / Apps / xanim.tgz / xanim / xanim27064 / xa_x11.c < prev    next >
C/C++ Source or Header  |  1997-01-26  |  82KB  |  2,750 lines
  1.  
  2. /*
  3.  * xa_x11.c
  4.  *
  5.  * Copyright (C) 1990,1991,1992,1993,1994,1995,1996,1997 by Mark Podlipec. 
  6.  * All rights reserved.
  7.  *
  8.  * This software may be freely copied, modified and redistributed without
  9.  * fee for non-commerical purposes provided that this copyright notice is
  10.  * preserved intact on all copies and modified copies.
  11.  * 
  12.  * There is no warranty or other guarantee of fitness of this software.
  13.  * It is provided solely "as is". The author(s) disclaim(s) all
  14.  * responsibility and liability with respect to this software's usage
  15.  * or its effect upon hardware or computer systems.
  16.  *
  17.  */
  18.  
  19. /****************
  20.  * Rev History
  21.  *
  22.  * 12Feb95 - fixed calling params of Callbacks and Actions.
  23.  * 22Jun95 - Translations added to Remote Control Window as well so
  24.  *           now all keyboards commands should work there as well.
  25.  *******************************/
  26.  
  27.  
  28. #include "xanim.h"
  29. #include <Intrinsic.h>
  30. #include <StringDefs.h>
  31. #include <Shell.h>
  32. #include <Xatom.h>
  33.  
  34. #ifdef XA_ATHENA
  35. #include <Xaw/Form.h>
  36. #include <Xaw/Command.h>
  37. #endif
  38.  
  39. #ifdef XA_MOTIF
  40. #include <Xm/Xm.h>
  41. #include <Xm/Form.h>
  42. #include <Xm/PushB.h>
  43. #endif
  44.  
  45. #include <sys/signal.h>
  46. #ifndef VMS
  47. #include <sys/times.h>
  48. #endif
  49. #include <ctype.h>
  50.  
  51. #ifdef XSHM
  52. #include <sys/ipc.h>
  53. #include <sys/shm.h>
  54. #include <X11/extensions/XShm.h>
  55. #endif /*XSHM*/
  56. #ifdef XMBUF
  57. #include <X11/extensions/multibuf.h>
  58. #endif
  59.  
  60.  
  61. #include "xa_x11.h"
  62.  
  63. #include "xa_ipc.h"
  64.  
  65. extern xaULONG shm;
  66. extern xaULONG mbuf;
  67. extern XA_AUD_FLAGS *vaudiof;
  68. extern xaLONG xa_pingpong_flag;
  69.  
  70.  
  71. #include "xa_ipc_cmds.h"
  72. extern xaULONG xa_forkit;
  73.  
  74. /* These are the default X,Y Positions of the Main Window and the
  75.  * RemoteControl Window.
  76.  */
  77. #define XA_REMW_XPOS    20
  78. #define XA_REMW_YPOS    20
  79. #define XA_MAINW_XPOS   (XA_REMW_XPOS + 120)
  80. #define XA_MAINW_YPOS   20
  81.  
  82. extern XA_CHDR *xa_chdr_first;
  83. extern xaULONG x11_shared_flag;
  84. extern xaULONG x11_multibuf_flag;
  85. extern xaULONG x11_expose_flag;
  86. extern xaLONG x11_error_possible;
  87. extern xaULONG xa_speed_change;
  88. extern xaLONG xa_remote_ready;
  89. xaLONG xa_remote_realized = xaFALSE;
  90. xaLONG xa_remote_busy = xaFALSE;
  91.  
  92. /* SMR 8 */
  93. /* externs from xanim.c covering playing into another app's window */
  94. extern xaLONG xa_window_x;
  95. extern xaLONG xa_window_y;
  96. extern xaULONG xa_window_id;
  97. extern char *xa_window_propname;
  98. extern xaULONG xa_window_center_flag;
  99. extern xaULONG xa_window_prepare_flag;
  100. extern xaULONG xa_window_refresh_flag;
  101. extern xaULONG xa_window_resize_flag;
  102. /* end SMR 8 */
  103.  
  104. int XA_Error_Handler();
  105.  
  106. void xanim_expose();
  107. void xanim_key();
  108. void xanim_button();
  109. void xanim_resize();
  110. void xanim_events();
  111. void X11Setup();
  112. void X11_Show_Visuals();
  113. void X11_OutPut_Visual_Class();
  114. void X11_Init_Image_Struct();
  115. void X11_Get_Shift();
  116. void X11_Init();
  117. void X11_Pre_Setup();
  118. void X11_Setup_Window();
  119. void X11_Map_Window();
  120. void X11_Make_Nice_CHDR();
  121. void X11_Get_Colormap();
  122. void XA_Free_CMAP();
  123.  
  124. #ifdef XA_REMOTE_CONTROL
  125.  
  126. Widget play_widget,audio_widget,norm_widget;
  127. Widget remote_widget,last_widget;
  128.  
  129. void XA_Create_Remote();
  130. void XA_Realize_Remote();
  131. void XA_Unrealize_Remote();
  132. void XA_Remote_Free();
  133.  
  134. void XA_Remote_Pause();
  135. void XA_Remote_PlayNext();
  136. void XA_Remote_PlayPrev();
  137. void XA_Remote_PlayStop();
  138. void XA_Remote_StepPrev();
  139. void XA_Remote_StepNext();
  140. void XA_Remote_AudioOff();
  141. void XA_Remote_AudioOn();
  142. void XA_Remote_SpeedNorm();
  143. void XA_Remote_SpeedDiff();
  144. void XA_Remote_Adj_Volume();
  145. #endif
  146.  
  147. void XA_Install_CMAP();
  148. void IFF_Buffer_HAM6();
  149. void IFF_Buffer_HAM8();
  150. void UTIL_Mapped_To_Bitmap();
  151. void UTIL_Mapped_To_Mapped();
  152. xaULONG CMAP_Find_Closest();
  153. void XA_Store_Title();
  154.  
  155.  
  156.  
  157. /*********************************** X11 stuff */
  158. Display       *theDisp;
  159. int           theScreen;
  160. Visual        *theVisual;
  161. Colormap       theCmap = 0;
  162. Window         mainW;
  163.  
  164. #ifdef XMBUF
  165. Window        mainWreal;       /* actual main window */
  166. Window        mainWbuffers[2]; /* two buffers for the main window */
  167. int        mainWbufIndex;   /* which buffer is actually visible */
  168. #endif
  169.  
  170. GC             theGC = 0;
  171. XImage        *theImage = 0;
  172. XColor         defs[256];
  173. Widget           theWG;
  174.  
  175. GC             remoteGC = 0;
  176. Window         remoteW;
  177. /******************************** Xt stuff */
  178. extern XA_CHDR *xa_chdr_now;
  179. extern XA_ANIM_HDR *cur_file;
  180. extern xaULONG xa_title_flag;
  181. extern xaULONG xa_anim_flags;
  182. extern xaULONG x11_window_x,x11_window_y;
  183. extern xaULONG xa_buff_x,xa_buff_y;
  184. extern xaULONG xa_allow_resizing;
  185. extern xaULONG xa_allow_nice;
  186. extern xaULONG xa_speed_scale;
  187.  
  188. extern XA_AUD_FLAGS *AUD;
  189.  
  190. extern xaULONG xa_audio_newvol;
  191. extern xaLONG xa_audio_volume;
  192. extern xaULONG xa_audio_mute;
  193.  
  194.  
  195.  
  196. XtAppContext  theContext;
  197.  
  198. /*
  199.  * gf: Forward definitions of action procedures:
  200.  */
  201. static void xanim_step_prev_action(),xanim_step_next_action();
  202. static void xact_playnext(), xact_playprev(), xact_playstop();
  203. static void xanim_toggle_action(),xanim_quit_action();
  204. static void xanim_resize_action();
  205. static void xanim_install_cmap_action(),xanim_stop_cmap_action();
  206. static void xanim_restore_cmap_action();
  207. static void xanim_faster_action(),xanim_slower_action();
  208. static void xanim_speed_reset_action(); 
  209. static void xanim_next_anim_action(),xanim_prev_anim_action();
  210. static void xanim_step_prev_int_action(),xanim_step_next_int_action();
  211. static void xanim_dec_audio_5(),xanim_dec_audio_1();
  212. static void xanim_inc_audio_5(),xanim_inc_audio_1(),xanim_mute_audio();
  213. static void xanim_speaker_tog(),xanim_headphone_tog();
  214. static void xanim_realize_remote();
  215. static void xanim_set_volume();
  216. static void xanim_set_pingpong();
  217.  
  218. /*
  219.  * gf: Replace KeyUp() and ButtonPress() with more specific actions
  220.  */
  221.  
  222. #define ACTIONTABLE_SIZE 29
  223. XtActionsRec actionTable[] = {
  224.         {"Expose", xanim_expose},
  225.         {"Configure", xanim_resize},
  226.     {"StepPrev", xanim_step_prev_action},
  227.     {"StepNext", xanim_step_next_action},
  228.     {"RunStop", xanim_toggle_action},
  229.     {"Quit", xanim_quit_action},
  230.     {"Resize", xanim_resize_action},
  231.     {"InstallCmap", xanim_install_cmap_action},
  232.     {"RealizeRemote", xanim_realize_remote},
  233.     {"StopCmap", xanim_stop_cmap_action},
  234.     {"RestoreCmap", xanim_restore_cmap_action},
  235.     {"Slower", xanim_slower_action},
  236.     {"Faster", xanim_faster_action},
  237.     {"SpeedReset", xanim_speed_reset_action},
  238.     {"NextAnim", xanim_next_anim_action},
  239.     {"PrevAnim", xanim_prev_anim_action},
  240.     {"StepNextInt", xanim_step_next_int_action},
  241.     {"StepPrevInt", xanim_step_prev_int_action},
  242.     {"DecAudio5", xanim_dec_audio_5},
  243.     {"DecAudio1", xanim_dec_audio_1},
  244.     {"IncAudio5", xanim_inc_audio_5},
  245.     {"IncAudio1", xanim_inc_audio_1},
  246.     {"AudioMute", xanim_mute_audio},
  247.     {"SpeakerTog",xanim_speaker_tog},
  248.     {"HDPhoneTog",xanim_headphone_tog},
  249.     {"PlayNext",xact_playnext},
  250.     {"PlayPrev",xact_playprev},
  251.     {"PingPong",xanim_set_pingpong},
  252.     {"PlayStop",xact_playstop}
  253. };
  254.  
  255. typedef struct {
  256.   int anim;
  257.   int remote_xpos;
  258.   int remote_ypos;
  259.   int window_xpos;
  260.   int window_ypos;
  261.   int audio_volume;
  262. } xanim_resources;
  263.  
  264. xanim_resources xa_resources;
  265.  
  266. #define offset(field)   XtOffsetOf(xanim_resources, field)
  267.  
  268. XtResource application_resources[] = {
  269.   {"anim", "Anim", XtRBoolean, sizeof(Boolean),
  270.      offset(anim), XtRString, "False" },
  271.   {"remote_xpos", "XAnim_Var", XtRInt, sizeof(int),
  272.      offset(remote_xpos), XtRImmediate, (XtPointer)XA_REMW_XPOS },
  273.   {"remote_ypos", "XAnim_Var", XtRInt, sizeof(int),
  274.      offset(remote_ypos), XtRImmediate, (XtPointer)XA_REMW_YPOS },
  275.   {"window_xpos", "XAnim_Var", XtRInt, sizeof(int),
  276.      offset(window_xpos), XtRImmediate, (XtPointer)XA_MAINW_XPOS },
  277.   {"window_ypos", "XAnim_Var", XtRInt, sizeof(int),
  278.      offset(window_ypos), XtRImmediate, (XtPointer)XA_MAINW_YPOS },
  279.   {"audio_volume", "XAnim_Var", XtRInt, sizeof(int),
  280.      offset(audio_volume), XtRImmediate, (XtPointer)10 }
  281. };
  282.  
  283. String   Translation =
  284.   "<Expose>:        Expose()\n\
  285.    <Configure>:        Configure()\n\
  286.    <Btn1Down>,<Btn1Up>:    StepPrev()\n\
  287.    <Btn2Down>,<Btn2Up>:    RunStop()\n\
  288.    <Btn3Down>,<Btn3Up>:    StepNext()\n\
  289.    <Key>1:        DecAudio5()\n\
  290.    <Key>2:        DecAudio1()\n\
  291.    <Key>3:        IncAudio1()\n\
  292.    <Key>4:        IncAudio5()\n\
  293.    <Key>8:        SpeakerTog()\n\
  294.    <Key>9:        HDPhoneTog()\n\
  295.    <Key>s:        AudioMute()\n\
  296.    <Key>q:        Quit()\n\
  297.    <Key>w:        Resize()\n\
  298.    <Key>F:        InstallCmap()\n\
  299.    <Key>z:        RealizeRemote()\n\
  300.    <Key>g:        StopCmap()\n\
  301.    <Key>p:        PingPong()\n\
  302.    <Key>r:        RestoreCmap()\n\
  303.    <Key>-:        Slower()\n\
  304.    <Key>=:        Faster()\n\
  305.    <Key>0:        SpeedReset()\n\
  306.    <Key>.:        StepNext()\n\
  307.    <Key>comma:        StepPrev()\n\
  308.    <Key>greater:    NextAnim()\n\
  309.    <Key>less:        PrevAnim()\n\
  310.    <Key>/:        StepNextInt()\n\
  311.    <Key>m:        StepPrevInt()\n\
  312.    <Key>space:        RunStop()";
  313.  
  314. void X11_Get_Shift(mask,shift,size)
  315. xaULONG mask,*shift,*size;
  316. {
  317.   xaLONG i,j;
  318.  
  319.   i=0;
  320.   while( (i < 32) && !(mask & 0x01) ) 
  321.   {
  322.     mask >>= 1;
  323.     i++;
  324.   }
  325.   if (i >= 32)
  326.   {
  327.     fprintf(stderr,"X11_Get_Shift: wierd mask value %x\n",mask);
  328.     i = 0;
  329.   }
  330.   *shift = i;
  331.   j=0;
  332.   while( (i < 32) && (mask & 0x01) ) 
  333.   {
  334.     mask >>= 1;
  335.     i++;
  336.     j++;
  337.   }
  338.   *size = j;
  339. }
  340.  
  341. xaULONG X11_Get_True_Color(r,g,b,bits)
  342. register xaULONG r,g,b,bits;
  343. {
  344.   register xaULONG temp,temp_color;
  345.  
  346.   temp = (x11_red_bits >= bits)?(r << (x11_red_bits - bits))
  347.                                :(r >> (bits - x11_red_bits));
  348.   temp_color  = (temp << x11_red_shift) & x11_red_mask;
  349.  
  350.   temp = (x11_green_bits >= bits)?(g << (x11_green_bits - bits))
  351.                                  :(g >> (bits - x11_green_bits));
  352.   temp_color |= (temp << x11_green_shift) & x11_green_mask;
  353.  
  354.   temp = (x11_blue_bits >= bits)?(b << (x11_blue_bits - bits))
  355.                                 :(b >> (bits - x11_blue_bits));
  356.   temp_color |= (temp << x11_blue_shift) & x11_blue_mask;
  357.  
  358. /*
  359. temp = temp_color;
  360. temp_color  = ((temp >> 24) & 0xff) ;
  361. temp_color |= ((temp >> 16) & 0xff) <<  8;
  362. temp_color |= ((temp >>  8) & 0xff) << 16;
  363. temp_color |= ((temp      ) & 0xff) << 24;
  364. */
  365.   return(temp_color);
  366. }
  367.  
  368.  
  369. /****************************************************
  370.  * Initialize X11 Display, etc.
  371.  *
  372.  *
  373.  ****************/
  374. void X11_Init(argcp, argv)
  375. int *argcp;
  376. char *argv[];
  377. {
  378.   XtToolkitInitialize();
  379.   theContext = XtCreateApplicationContext();
  380.   XtAppAddActions(theContext, actionTable, ACTIONTABLE_SIZE);
  381.  
  382.   theDisp = XtOpenDisplay(theContext, NULL, "xanim", "XAnim",NULL,0,argcp,argv);
  383.   if (theDisp == NULL)
  384.   {
  385.     TheEnd1("Unable to open display\n");
  386.   }
  387.  
  388.   XSetErrorHandler(XA_Error_Handler);
  389. }
  390.  
  391. /****************************************************
  392.  *
  393.  ****************/
  394. void X11_Pre_Setup(xa_user_visual,xa_user_class)
  395. xaLONG xa_user_visual;
  396. xaLONG xa_user_class;
  397. { int i,vis_num,vis_i;
  398.   XVisualInfo *vis;
  399.  
  400.  
  401.   shm = 0;
  402. #ifdef XSHM
  403.   if ( (XShmQueryExtension(theDisp)) && (x11_shared_flag == xaTRUE)) shm = 1;
  404. #endif
  405.  
  406. /* SMR 9 */
  407. /* Use visual from window id user specified. */
  408.   if (xa_window_id != 0)
  409.   {
  410.     XWindowAttributes wAttributes;
  411.     XVisualInfo vis_template;
  412. /* catch events while preparing movie */
  413.     XSelectInput(theDisp, (Window)xa_window_id,
  414.                  StructureNotifyMask | PropertyChangeMask);
  415.     XGetWindowAttributes(theDisp, (Window)xa_window_id, &wAttributes);
  416.     vis_template.visualid = XVisualIDFromVisual(wAttributes.visual);
  417.     vis_template.screen = DefaultScreen(theDisp);
  418.     vis = XGetVisualInfo (theDisp, VisualIDMask | VisualScreenMask,
  419.                           &vis_template, &vis_num);
  420.     xa_user_visual = 0;
  421.   } /* end SMR 9 */
  422.   else if (xa_user_class >= 0) /* only attempt to use select visuals */
  423.   { XVisualInfo vis_template;
  424.     vis_template.class  = xa_user_class;
  425.     vis_template.screen = DefaultScreen(theDisp);
  426.     vis = XGetVisualInfo (theDisp, (VisualClassMask | VisualScreenMask), 
  427.                         &vis_template, &vis_num);
  428.     if ((vis == NULL) || (vis_num == 0) )
  429.     TheEnd1("X11: Couldn't get any Visuals of the desired class.");
  430.   }
  431.   else  /* look at them all (for the screen in question) */
  432.   { XVisualInfo vis_template;
  433.     vis_template.screen = DefaultScreen(theDisp);
  434.     vis = XGetVisualInfo (theDisp, VisualScreenMask, &vis_template, &vis_num);
  435.     if ((vis == NULL) || (vis_num == 0) )
  436.         TheEnd1("X11: Couldn't get any Visuals.");
  437.   }
  438.  
  439.   vis_i = xa_user_visual;
  440.   if (vis_i >= vis_num) TheEnd1("X11: Couldn't get requested Visual.");
  441.   if (vis_i < 0)
  442.   { int screen;
  443.     xaLONG max_csize,max_depth,max_class;
  444.  
  445.     max_class = -1;
  446.     max_depth = 0;
  447.     max_csize = 0;
  448.     screen = DefaultScreen(theDisp);
  449.  
  450.     /* look through visuals a choose a good one */
  451.     for(i=0;i<vis_num;i++)
  452.     { if (vis[i].screen != screen) continue; /* Visual for a diff screen */
  453.       if (vis[i].depth > max_depth)
  454.       { max_depth = vis[i].depth;
  455.     max_class = vis[i].class;
  456.     max_csize = vis[i].colormap_size;
  457.     vis_i = i;
  458.       }
  459.       else if (vis[i].depth == max_depth)
  460.       { if (vis[i].class > max_class) 
  461.     { if (   (vis[i].class < 4)    /* pseudo or less */
  462.           || (vis[i].depth > 8) )
  463.       { max_class = vis[i].class;
  464.         max_csize = vis[i].colormap_size;
  465.         vis_i = i;
  466.       }
  467.     }
  468.     else if (vis[i].class == max_class)
  469.     { if (vis[i].colormap_size > max_csize)
  470.       { max_csize = vis[i].colormap_size;
  471.         vis_i = i;
  472.       } 
  473.     } /* end same class */
  474.       } /* end same depth */
  475.     } /* end of vis loop */
  476.   } /* no valid user visuals */
  477.  
  478.   /* setup up X11 variables */
  479.  
  480.   theScreen = vis[vis_i].screen;
  481.   theVisual = vis[vis_i].visual;
  482.   x11_depth = vis[vis_i].depth;
  483.   x11_class = vis[vis_i].class;
  484.   x11_cmap_size   = vis[vis_i].colormap_size;
  485.   /* POD - For testing purposes only */
  486.   if ( (pod_max_colors > 0) && (pod_max_colors < x11_cmap_size) )
  487.         x11_cmap_size = pod_max_colors;
  488.   theGC  = DefaultGC(theDisp,theScreen);
  489.  
  490.   /* Make sure x11_cmap_size is power of two */
  491.   { xaULONG size;
  492.     size = 0x01; x11_disp_bits = 0;
  493.     while(size <= x11_cmap_size) { size <<= 1; x11_disp_bits++; }
  494.     size >>=1; x11_disp_bits--;
  495.     x11_cmap_size = 0x01 << x11_disp_bits;
  496.   }
  497.  
  498.   x11_bit_order   = BitmapBitOrder(theDisp);
  499.   if (x11_bit_order == MSBFirst) x11_bit_order = X11_MSB;
  500.   else x11_bit_order = X11_LSB;
  501.   x11_bitmap_unit = BitmapUnit(theDisp);
  502.   x11_depth_mask = (0x01 << x11_depth) - 1;
  503.   x11_cmap_type = 0;
  504.  
  505.   XFree( (void *)vis);  
  506.  
  507.   if (x11_depth == 1)
  508.   { x11_display_type = XA_MONOCHROME;
  509.     x11_bytes_pixel = 1; x11_bitmap_pad = x11_bitmap_unit; 
  510.     x11_cmap_flag = xaFALSE;
  511.     x11_black = BlackPixel(theDisp,DefaultScreen(theDisp));
  512.     x11_white = WhitePixel(theDisp,DefaultScreen(theDisp));
  513.     x11_bits_per_pixel = 1;
  514.     x11_byte_order = x11_bit_order;
  515.   }
  516.   else 
  517.   { if (x11_depth > 16)
  518.         { x11_bytes_pixel = 4; x11_bitmap_pad = 32; }
  519.     else if (x11_depth > 8)
  520.         { x11_bytes_pixel = 2; x11_bitmap_pad = 16; }
  521.     else { x11_bytes_pixel = 1; x11_bitmap_pad = 8; }
  522.  
  523.     theImage = XCreateImage(theDisp,theVisual,
  524.             x11_depth,ZPixmap,0,0,7,7,
  525.             x11_bitmap_pad,0);
  526.     if (theImage != 0)
  527.     { x11_bits_per_pixel = theImage->bits_per_pixel;
  528.       x11_byte_order = theImage->byte_order;
  529.       if (x11_byte_order == MSBFirst) x11_byte_order = X11_MSB;
  530.       else x11_byte_order = X11_LSB;
  531.       if (x11_verbose_flag == xaTRUE)
  532.       { fprintf(stderr,"bpp=%d   bpl=%d   byteo=%d  bito=%d\n",
  533.         x11_bits_per_pixel,theImage->bytes_per_line,
  534.         x11_byte_order,theImage->bitmap_bit_order);
  535.       }
  536.       XDestroyImage(theImage); theImage = NULL;
  537.     } else x11_bits_per_pixel = x11_depth;
  538.  
  539.     switch(x11_class)
  540.     { case StaticGray:
  541.     x11_display_type = XA_STATICGRAY;
  542.     x11_cmap_flag = xaFALSE;
  543.     break;
  544.       case GrayScale:
  545.     x11_display_type = XA_GRAYSCALE;
  546.     x11_cmap_flag = xaTRUE;
  547.     break;
  548.       case StaticColor:
  549.     x11_display_type = XA_STATICCOLOR;
  550.     x11_cmap_flag = xaFALSE;
  551.     break;
  552.       case PseudoColor:
  553.     x11_display_type = XA_PSEUDOCOLOR;
  554.     x11_cmap_flag = xaTRUE;
  555.     break;
  556.       case TrueColor:
  557.     x11_display_type = XA_TRUECOLOR;
  558.     x11_cmap_flag = xaFALSE;
  559.     break;
  560.       case DirectColor:
  561.     x11_display_type = XA_DIRECTCOLOR;
  562.     x11_cmap_flag = xaFALSE;
  563.     break;
  564.       default:
  565.     fprintf(stderr,"Unkown x11_class %x\n",x11_class);
  566.     TheEnd();
  567.     }
  568.   }
  569.  
  570.   if (x11_display_type & XA_X11_TRUE)
  571.   {
  572.     x11_red_mask = theVisual->red_mask;
  573.     x11_green_mask = theVisual->green_mask;
  574.     x11_blue_mask = theVisual->blue_mask;
  575.     X11_Get_Shift(x11_red_mask  , &x11_red_shift  , &x11_red_bits  );
  576.     X11_Get_Shift(x11_green_mask, &x11_green_shift, &x11_green_bits);
  577.     X11_Get_Shift(x11_blue_mask , &x11_blue_shift , &x11_blue_bits );
  578.   }
  579.   else if ( (x11_depth == 24) && (x11_cmap_size <= 256) ) x11_cmap_type = 1;
  580.  
  581.   xa_cmap = (ColorReg *) malloc( x11_cmap_size * sizeof(ColorReg) );
  582.   if (xa_cmap==0) fprintf(stderr,"X11 CMAP: couldn't malloc\n");
  583.  
  584.   if (x11_verbose_flag == xaTRUE)
  585.   {
  586.     fprintf(stderr,"Selected Visual:  ");
  587.     X11_OutPut_Visual_Class(x11_class);
  588.     fprintf(stderr," (%x) \n",x11_display_type);
  589.     fprintf(stderr,"  depth= %d  class= %d  cmap size=%d(%d) bytes_pixel=%d\n",
  590.         x11_depth, x11_class, x11_cmap_size, x11_disp_bits, x11_bytes_pixel );
  591.     if (x11_display_type & XA_X11_TRUE)
  592.     {
  593.       fprintf(stderr,"  X11 Color Masks =%x %x %x\n",
  594.                   x11_red_mask,x11_green_mask ,x11_blue_mask);
  595.       fprintf(stderr,"  X11 Color Shifts=%d %d %d\n",
  596.                   x11_red_shift, x11_green_shift, x11_blue_shift );
  597.       fprintf(stderr,"  X11 Color Sizes =%d %d %d\n",
  598.                   x11_red_bits,x11_green_bits ,x11_blue_bits);
  599.     }
  600.     else if (x11_display_type == XA_MONOCHROME)
  601.     { fprintf(stderr,"  Bit Order = %x  bitmapunit = %x bitmappad = %x\n",
  602.                 x11_bit_order,x11_bitmap_unit,BitmapPad(theDisp) );
  603.     }
  604.     fprintf(stderr,"\n");
  605.   }
  606.  
  607.   if (   (theVisual != DefaultVisual(theDisp,theScreen))
  608.       || (x11_display_type & XA_X11_TRUE)
  609.       || (x11_display_type == XA_MONOCHROME) ) xa_allow_nice = xaFALSE;
  610.   else xa_allow_nice = xaTRUE;
  611.  
  612.   /* kludges */
  613.   if (   (!(x11_display_type & XA_X11_TRUE))
  614.       && (x11_depth == 24) && (x11_cmap_size <= 256) ) x11_kludge_1 = xaTRUE;
  615.   XSync(theDisp,False);
  616. }
  617.  
  618. /*
  619.  * Setup X11 Display, Window and Toolkit
  620.  */
  621.  
  622. void X11_Setup_Window(max_imagex,max_imagey,startx,starty)
  623. xaLONG max_imagex,max_imagey;
  624. xaLONG startx,starty;
  625. { xaLONG n;
  626.   Arg arglist[20];
  627.   XWMHints xwm_hints;
  628.  
  629. /* SMR 10 */
  630. /* Use cmap from window id user specified. */
  631.   if (xa_window_id != 0)
  632.   {
  633.      XWindowAttributes wAttributes;
  634.  
  635.      XGetWindowAttributes(theDisp, (Window)xa_window_id, &wAttributes);
  636.      theCmap = wAttributes.colormap;
  637.   }
  638. /* end SMR 10 */
  639.   else if (   (   (theVisual == DefaultVisual(theDisp,theScreen))
  640.           && !(   (cmap_play_nice == xaFALSE) 
  641.                && (x11_display_type & XA_X11_CMAP)
  642.               )
  643.          ) 
  644.       || (x11_display_type == XA_MONOCHROME)
  645.      )
  646.   { DEBUG_LEVEL1 fprintf(stderr,"using default cmap\n");
  647.     theCmap = DefaultColormap(theDisp,theScreen);
  648.     x11_cmap_flag = xaFALSE; /* if nice */
  649.   }
  650.   else
  651.   { DEBUG_LEVEL1 fprintf(stderr,"creating new cmap\n");
  652.     if (x11_display_type & XA_X11_STATIC)
  653.     { theCmap = XCreateColormap(theDisp,RootWindow(theDisp,theScreen),
  654.                             theVisual, AllocNone);
  655.     }
  656.     else if (   (x11_display_type == XA_DIRECTCOLOR)
  657.              && (theVisual != DefaultVisual(theDisp,theScreen))  )
  658.     {     /* Fake Direct Color, usually on top of a PseudoColor */
  659.       xaULONG i,r_scale,g_scale,b_scale;
  660.       xaULONG rmsk,gmsk,bmsk;
  661.  
  662.  
  663.       theCmap = XCreateColormap(theDisp,RootWindow(theDisp,theScreen),
  664.                             theVisual, AllocAll);
  665.       r_scale = cmap_scale[x11_red_bits];
  666.       g_scale = cmap_scale[x11_green_bits];
  667.       b_scale = cmap_scale[x11_blue_bits];
  668.       rmsk = (0x01 << x11_red_bits)   - 1;
  669.       gmsk = (0x01 << x11_green_bits) - 1;
  670.       bmsk = (0x01 << x11_blue_bits)  - 1;
  671.       for(i=0; i < x11_cmap_size; i++)
  672.       {
  673.         defs[i].pixel  =  (i << x11_red_shift)   & x11_red_mask;
  674.         defs[i].pixel |=  (i << x11_green_shift) & x11_green_mask;
  675.         defs[i].pixel |=  (i << x11_blue_shift)  & x11_blue_mask;
  676.         defs[i].red   = (i & rmsk) * r_scale;
  677.         defs[i].green = (i & gmsk) * g_scale;
  678.         defs[i].blue  = (i & bmsk) * b_scale;
  679.         defs[i].flags = DoRed | DoGreen | DoBlue;
  680.       }
  681.       XStoreColors(theDisp,theCmap,defs,x11_cmap_size);
  682.     }
  683.     else   /* re-instate here */
  684.     {  xaULONG i,csize;
  685.        theCmap = XCreateColormap(theDisp,RootWindow(theDisp,theScreen),
  686.                             theVisual, AllocAll);
  687.        if (theCmap == 0) TheEnd1("X11_Setup_Window: create cmap err");
  688.  
  689.        csize = CellsOfScreen(DefaultScreenOfDisplay(theDisp));
  690.        if (csize > x11_cmap_size) csize = x11_cmap_size;
  691.        for(i=0;i<csize;i++)
  692.        { if (x11_display_type & XA_X11_TRUE)
  693.          { xaULONG d;
  694.            d  =  (i << x11_red_shift)   & x11_red_mask;
  695.            d |=  (i << x11_green_shift) & x11_green_mask;
  696.            d |=  (i << x11_blue_shift)  & x11_blue_mask;
  697.            defs[i].pixel =  d;
  698.          } else defs[i].pixel = i;
  699.          defs[i].flags = DoRed | DoGreen | DoBlue; 
  700.        }
  701.        XQueryColors(theDisp,DefaultColormap(theDisp,theScreen),defs,csize);
  702.        for(i=0;i<csize;i++)
  703.        { xaULONG r,g,b;
  704.          r = xa_cmap[i].red   = defs[i].red;
  705.          g = xa_cmap[i].green = defs[i].green;
  706.          b = xa_cmap[i].blue  = defs[i].blue;
  707.          xa_cmap[i].gray = (xaUSHORT)( ( (r * 11) + (g * 16) + (b * 5) ) >> 5 );
  708.          if (x11_display_type & XA_X11_GRAY)
  709.          { defs[i].red   = xa_cmap[i].gray;
  710.            defs[i].green = xa_cmap[i].gray;
  711.            defs[i].blue  = xa_cmap[i].gray;
  712.          }
  713.          defs[i].pixel = i; /* probably redundant */
  714.          defs[i].flags = DoRed | DoGreen | DoBlue;
  715.       }
  716.       XStoreColors(theDisp,theCmap,defs,csize);
  717.     }
  718.   }
  719.  
  720.   n = 0;
  721. #ifdef XtNvisual
  722.   XtSetArg(arglist[n], XtNvisual, theVisual); n++;
  723. #endif
  724.   XtSetArg(arglist[n], XtNcolormap, theCmap); n++;
  725.   XtSetArg(arglist[n], XtNdepth, x11_depth); n++;
  726.   XtSetArg(arglist[n], XtNforeground, WhitePixel(theDisp,theScreen)); n++;
  727.   XtSetArg(arglist[n], XtNbackground, BlackPixel(theDisp,theScreen)); n++;
  728.   XtSetArg(arglist[n], XtNborderColor, WhitePixel(theDisp,theScreen)); n++;
  729.   XtSetArg(arglist[n], XtNwidth, startx); n++;
  730.   XtSetArg(arglist[n], XtNheight, starty); n++;
  731.   XtSetArg(arglist[n], XtNx, XA_MAINW_XPOS); n++;
  732.   XtSetArg(arglist[n], XtNy, XA_MAINW_YPOS); n++;
  733.   if (xa_allow_resizing==xaTRUE)
  734.   {
  735.     XtSetArg(arglist[n], XtNallowShellResize, True); n++;
  736.   }
  737.   else
  738.   {
  739.     XtSetArg(arglist[n], XtNmaxWidth, max_imagex); n++;
  740.     XtSetArg(arglist[n], XtNmaxHeight, max_imagey); n++;
  741.   }
  742.   XtSetArg(arglist[n], XtNtranslations, 
  743.             XtParseTranslationTable(Translation)); n++;
  744.   theWG = XtAppCreateShell("xanim", "XAnim", applicationShellWidgetClass, 
  745.                          theDisp, arglist, n);
  746.  
  747. /* SMR 11 */
  748. /* Fake mainW to be user specified window instead of widget window.
  749.    Note that shell window is never realized. */
  750.   if (xa_window_id != 0)
  751.   {
  752.     mainW = (Window)xa_window_id;
  753.   }
  754.   else
  755.   {
  756.     XtGetApplicationResources (theWG, &xa_resources, application_resources,
  757.                                XtNumber(application_resources), NULL, 0);
  758.  
  759.     XtRealizeWidget(theWG);
  760.     mainW = XtWindow(theWG);
  761.   }
  762. /* end SMR 11 */
  763.  
  764. #ifdef XMBUF
  765.   mainWreal = mainW;
  766.   if (mbuf) {
  767.     DEBUG_LEVEL1 fprintf(stderr, "Creating multiple buffers\n");
  768.     if (XmbufCreateBuffers(theDisp, mainW, 2,
  769.       MultibufferUpdateActionBackground, MultibufferUpdateHintFrequent,
  770.       mainWbuffers) < 2) {
  771.       fprintf(stderr,"X11 Setup: creating multiple buffers failed\n");
  772.       mbuf = 0;
  773.     } else
  774.       mainW = mainWbuffers[mainWbufIndex = 0];
  775.   }
  776. #endif
  777.  
  778.  
  779.   /* Need to Create New GC for Visuals that have a different depth than
  780.    * the default GC
  781.    */
  782.   {
  783.     xaULONG gc_mask;
  784.     XGCValues gc_init;
  785.  
  786.     gc_mask = 0;
  787.     gc_init.function = GXcopy;                          gc_mask |= GCFunction;
  788.     gc_init.foreground = WhitePixel(theDisp,theScreen); gc_mask |= GCForeground;
  789.     gc_init.background = BlackPixel(theDisp,theScreen); gc_mask |= GCBackground;
  790.     gc_init.graphics_exposures = False;         gc_mask |= GCGraphicsExposures;
  791.     theGC  = XCreateGC(theDisp,mainW,gc_mask,&gc_init);
  792.  
  793. XSetFunction(theDisp, theGC, GXcopy);
  794. XSetPlaneMask(theDisp, theGC, ~0L);
  795.  
  796.   }
  797.  
  798.  
  799.   if (x11_display_type == XA_MONOCHROME)
  800.   { xaULONG line_size;
  801.     line_size = X11_Get_Line_Size(max_imagex);
  802.     theImage = XCreateImage(theDisp,theVisual,
  803.             x11_depth,XYPixmap,0,0,max_imagex,max_imagey,
  804.             x11_bitmap_pad,line_size);
  805.     if (theImage == 0)
  806.     {
  807.       fprintf(stderr,"X11 Setup: create XY image failed\n");
  808.       TheEnd();
  809.     }
  810.   }
  811.   else
  812.   { xaULONG line_size;
  813.     line_size = X11_Get_Line_Size(x11_bytes_pixel * max_imagex);
  814.     if (x11_bits_per_pixel==2) line_size = (line_size + 3) / 4;
  815.     else if (x11_bits_per_pixel==4) line_size = (line_size + 1) / 2;
  816.  
  817.     theImage = XCreateImage(theDisp,theVisual,
  818.             x11_depth,ZPixmap,0,0,max_imagex,max_imagey,
  819.             x11_bitmap_pad,line_size);
  820.     if (theImage == 0)
  821.     {
  822.       fprintf(stderr,"X11 Setup: create Z image failed\n");
  823.       TheEnd();
  824.     }
  825.   }
  826.  
  827.   xwm_hints.input = True;    /* ask for keyboard input */
  828. /*xwm_hints.icon_pixmap = ???;      Eventually have a icon pixmap */
  829.   xwm_hints.flags = InputHint;   /* IconPixmapHint */
  830.   XSetWMHints(theDisp,mainW,&xwm_hints);
  831.   XSync(theDisp,False);
  832. }
  833.  
  834. void X11_Map_Window()
  835. {
  836.   XMapWindow(theDisp,mainW);
  837.   XSync(theDisp,False);
  838.  
  839.   if (x11_cmap_flag == xaFALSE) /* static or monochrome displays */
  840.   {
  841.     xaULONG i;
  842.     for(i=0;i<x11_cmap_size;i++)
  843.     { 
  844.       if (x11_display_type & XA_X11_TRUE)
  845.       {
  846.         xaULONG d;
  847.         d  =  (i << x11_red_shift)   & x11_red_mask;
  848.         d |=  (i << x11_green_shift) & x11_green_mask;
  849.         d |=  (i << x11_blue_shift)  & x11_blue_mask;
  850.         defs[i].pixel =  d;
  851.       }
  852.       else defs[i].pixel = i;
  853.       defs[i].flags = DoRed | DoGreen | DoBlue; 
  854.     }
  855.     XQueryColors(theDisp,theCmap,defs,x11_cmap_size);
  856.     for(i=0;i<x11_cmap_size;i++)
  857.     {
  858.       xaULONG r,g,b;
  859.       r = xa_cmap[i].red   = defs[i].red;
  860.       g = xa_cmap[i].green = defs[i].green;
  861.       b = xa_cmap[i].blue  = defs[i].blue;
  862.       xa_cmap[i].gray = (xaUSHORT)( ( (r * 11) + (g * 16) + (b * 5) ) >> 5 );
  863.     }
  864.   }
  865. /* Copy Default Colormap into new one */
  866.   else  if (!(x11_display_type & XA_X11_TRUE))
  867.   {
  868.     xaULONG i,csize;
  869.  
  870.     csize = CellsOfScreen(DefaultScreenOfDisplay(theDisp));
  871.     if (csize > x11_cmap_size) csize = x11_cmap_size;
  872.     for(i=0; i<csize; i++)
  873.     {   /* POD eventually removed this when it's determined to be fixed */
  874.       if (x11_display_type & XA_X11_TRUE)
  875.       { xaULONG d;
  876.         d  =  (i << x11_red_shift)   & x11_red_mask;
  877.         d |=  (i << x11_green_shift) & x11_green_mask;
  878.         d |=  (i << x11_blue_shift)  & x11_blue_mask;
  879.         defs[i].pixel =  d;
  880.       }
  881.       else defs[i].pixel = i;
  882.       defs[i].flags = DoRed | DoGreen | DoBlue;
  883.     }
  884.     XQueryColors(theDisp,theCmap,defs,csize);
  885.     for(i=0; i<csize; i++)
  886.     { xaULONG r,g,b;
  887.       r = xa_cmap[i].red   = defs[i].red;
  888.       g = xa_cmap[i].green = defs[i].green;
  889.       b = xa_cmap[i].blue  = defs[i].blue;
  890.       xa_cmap[i].gray = (xaUSHORT)( ( (r * 11) + (g * 16) + (b * 5) ) >> 5 );
  891.       if (x11_display_type & XA_X11_GRAY)
  892.       { defs[i].red   = xa_cmap[i].gray;
  893.         defs[i].green = xa_cmap[i].gray;
  894.         defs[i].blue  = xa_cmap[i].gray;
  895.       }
  896.       defs[i].pixel = i; /* probably redundant */
  897.       defs[i].flags = DoRed | DoGreen | DoBlue;
  898.     }
  899.     XStoreColors(theDisp,theCmap,defs,csize);
  900.   }
  901.   XSetWindowColormap(theDisp, mainW, theCmap);
  902.  
  903.   XInstallColormap(theDisp,theCmap);
  904.   XSync(theDisp,False);
  905. /*
  906. #ifndef NO_INSTALL_CMAP
  907.   XInstallColormap(theDisp,theCmap);
  908. #endif
  909.   XSync(theDisp,False);
  910. */
  911.  
  912. }
  913.  
  914. void xanim_resize(wg, event, str, np)
  915. Widget        wg;
  916. XConfigureEvent    *event;
  917. String        *str;
  918. int        *np;
  919. {
  920.   if (xa_anim_status == XA_UNSTARTED)  return;
  921. #ifdef XMBUF
  922.   if (event->window == mainWreal)
  923. #else
  924.   if (event->window == mainW)
  925. #endif
  926.   {
  927.     x11_window_x = event->width;
  928.     x11_window_y = event->height;
  929.     DEBUG_LEVEL1 
  930.     fprintf(stderr,"X11 RESIZE %dx%d\n",x11_window_x,x11_window_y);
  931.   }
  932. }
  933.  
  934.  
  935. static void xanim_realize_remote(wg, event, str, np)
  936. Widget          wg;
  937. XExposeEvent   *event;
  938. String         *str;
  939. int            *np;
  940. {
  941.   if (xa_remote_ready != xaTRUE) return;
  942.   if (xa_remote_busy == xaTRUE) return;
  943. #ifdef XA_REMOTE_CONTROL
  944.   if (xa_remote_realized == xaFALSE)
  945.   {
  946.     xa_remote_busy = xaTRUE;
  947.     XA_Realize_Remote(remote_widget);
  948.     xa_remote_busy = xaFALSE;
  949.   }
  950.   else
  951.   {
  952.     xa_remote_busy = xaTRUE;
  953.     XA_Unrealize_Remote(remote_widget);
  954.     xa_remote_busy = xaFALSE;
  955.   }
  956. #endif
  957. }
  958.  
  959.  
  960.  
  961. void xanim_expose(wg, event, str, np)
  962. Widget        wg;
  963. XExposeEvent    *event;
  964. String        *str;
  965. int        *np;
  966. {
  967.  x11_expose_flag = xaTRUE;
  968.  if (xa_anim_status == XA_UNSTARTED) 
  969.  {
  970.   xa_anim_status = XA_BEGINNING;
  971.   xa_anim_holdoff = xaTRUE;
  972.   XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped,
  973.                         (XtPointer)(XA_SHOW_NORM));
  974.  }
  975. }
  976.  
  977. /*    -       -       -       -       -       -       -       -       */
  978. /*
  979.  * gf: Broke xanim_button() and xanim_key() into more specific action
  980.  *     procedures.
  981.  */
  982. #define ACTION_PROC(NAME)     static void NAME(w,event,params,num_params) \
  983.                                       Widget w; \
  984.                                       XEvent *event; \
  985.                                       String *params; \
  986.                                       Cardinal *num_params;
  987.  
  988. ACTION_PROC(xanim_step_prev_action)
  989. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  990.   { xa_anim_status = XA_STEP_PREV;
  991.     if (xa_anim_holdoff == xaTRUE) return;
  992.     xa_anim_holdoff = xaTRUE;
  993.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  994.                         (XtPointer)XA_SHOW_NORM);
  995.   }
  996.   else xa_anim_status = XA_STOP_PREV;
  997. #ifdef XA_REMOTE_CONTROL
  998.   XA_Remote_StepPrev();
  999. #endif
  1000. }
  1001.  
  1002. ACTION_PROC(xanim_step_next_action)
  1003. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  1004.   { xa_anim_status = XA_STEP_NEXT;
  1005.     if (xa_anim_holdoff == xaTRUE) return;
  1006.     xa_anim_holdoff = xaTRUE;
  1007.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1008.                         (XtPointer)XA_SHOW_NORM);
  1009.   }
  1010.   else xa_anim_status = XA_STOP_NEXT;
  1011. #ifdef XA_REMOTE_CONTROL
  1012.   XA_Remote_StepNext();
  1013. #endif
  1014. }
  1015.  
  1016. ACTION_PROC(xanim_toggle_action)
  1017. { int button; /* <0 PlayNext> <1 PlayPrev> <2 PlayStop> */
  1018.   switch(xa_anim_status)
  1019.   {
  1020.     case XA_RUN_PREV:  /* if running, then stop */
  1021.     case XA_RUN_NEXT:
  1022.       button = 2;
  1023.       xa_anim_status &= XA_CLEAR_MASK;
  1024.       xa_anim_status |= XA_STOP_MASK;
  1025.       xa_anim_flags &= ~(ANIM_CYCLE);
  1026.       break;
  1027.     case XA_STOP_PREV: /* if stopped, then run */
  1028.     case XA_STOP_NEXT:
  1029.       button = (xa_anim_status & XA_NEXT_MASK)?(0):(1);
  1030.       xa_anim_status &= XA_CLEAR_MASK;
  1031.       xa_anim_status |= XA_RUN_MASK;
  1032.       if (xa_anim_holdoff == xaTRUE) return;
  1033.       xa_anim_holdoff = xaTRUE;
  1034.       XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1035.                         (XtPointer)XA_SHOW_NORM);
  1036.       break;
  1037.     case XA_STEP_PREV: /* if single stepping then run */
  1038.     case XA_STEP_NEXT:
  1039.     case XA_ISTP_PREV:
  1040.     case XA_ISTP_NEXT:
  1041.     case XA_FILE_PREV:
  1042.     case XA_FILE_NEXT:
  1043.       button = (xa_anim_status & XA_NEXT_MASK)?(0):(1);
  1044.       xa_anim_status &= XA_CLEAR_MASK;
  1045.       xa_anim_status |= XA_RUN_MASK;
  1046.       break;
  1047.     default:
  1048.       button = 2;
  1049.       if (xa_anim_status & XA_NEXT_MASK) xa_anim_status = XA_STOP_NEXT;
  1050.       else                 xa_anim_status = XA_STOP_PREV;
  1051.       break;
  1052.   }
  1053.   /* change Play Widget pixmap */
  1054. #ifdef XA_REMOTE_CONTROL
  1055.   if (button==0)    XA_Remote_PlayNext();
  1056.   else if (button==1)    XA_Remote_PlayPrev();
  1057.   else            XA_Remote_PlayStop();
  1058. #endif
  1059.   if ( (xa_title_flag == XA_TITLE_FILE) && (xa_anim_status & XA_RUN_MASK))
  1060.                 XA_Store_Title(cur_file,0,xa_title_flag);
  1061. }
  1062.  
  1063. ACTION_PROC(xact_playnext)
  1064. { if ((xa_anim_status == XA_STOP_PREV) || (xa_anim_status == XA_STOP_NEXT))
  1065.   { if (xa_anim_holdoff == xaTRUE) return;
  1066.     xa_anim_holdoff = xaTRUE;
  1067.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped,
  1068.                             (XtPointer)XA_SHOW_NORM);
  1069.   }
  1070.   xa_anim_status = XA_RUN_NEXT;
  1071. #ifdef XA_REMOTE_CONTROL
  1072.   XA_Remote_PlayNext();
  1073. #endif
  1074.   if (xa_title_flag == XA_TITLE_FILE) XA_Store_Title(cur_file,0,xa_title_flag);
  1075. }
  1076.  
  1077. ACTION_PROC(xact_playprev)
  1078. { if ((xa_anim_status == XA_STOP_PREV) || (xa_anim_status == XA_STOP_NEXT))
  1079.   { if (xa_anim_holdoff == xaTRUE) return;
  1080.     xa_anim_holdoff = xaTRUE;
  1081.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped,
  1082.                             (XtPointer)XA_SHOW_NORM);
  1083.   }
  1084.   xa_anim_status = XA_RUN_PREV;
  1085. #ifdef XA_REMOTE_CONTROL
  1086.   XA_Remote_PlayPrev();
  1087. #endif
  1088.   if (xa_title_flag == XA_TITLE_FILE) XA_Store_Title(cur_file,0,xa_title_flag);
  1089. }
  1090.  
  1091. ACTION_PROC(xact_playstop)
  1092. { xa_anim_status = (xa_anim_status & XA_NEXT_MASK)?(XA_STOP_NEXT)
  1093.                           :(XA_STOP_PREV); 
  1094.   xa_anim_flags &= ~(ANIM_CYCLE);
  1095. #ifdef XA_REMOTE_CONTROL
  1096.   XA_Remote_PlayStop();
  1097. #endif
  1098. }
  1099.  
  1100. ACTION_PROC(xanim_quit_action)
  1101. {
  1102.   TheEnd();
  1103. }
  1104.  
  1105. ACTION_PROC(xanim_resize_action)
  1106. {
  1107.   if ( (xa_buff_x != 0) && (xa_buff_y != 0) )
  1108.     XResizeWindow(theDisp,mainW,xa_buff_x,xa_buff_y);
  1109. }
  1110.  
  1111. ACTION_PROC(xanim_install_cmap_action)
  1112. {
  1113.   XInstallColormap(theDisp,theCmap);
  1114. }
  1115.  
  1116. ACTION_PROC(xanim_stop_cmap_action)
  1117. {
  1118.   xa_anim_flags &= ~(ANIM_CYCLE);
  1119. }
  1120.  
  1121. ACTION_PROC(xanim_restore_cmap_action)
  1122. {
  1123.   if (xa_chdr_now != 0) XA_Install_CMAP(xa_chdr_now);
  1124. }
  1125.  
  1126. /* decrease speed scale, but not to zero */
  1127. ACTION_PROC(xanim_slower_action)
  1128. {
  1129. #ifdef XA_REMOTE_CONTROL
  1130.   if (xa_speed_scale==XA_SPEED_NORM) XA_Remote_SpeedNorm();
  1131. #endif
  1132.   xa_speed_change = 1;
  1133.   if (xa_speed_scale > XA_SPEED_MIN) xa_speed_scale >>= 1;
  1134.   xa_speed_change = 2;
  1135. #ifdef XA_REMOTE_CONTROL
  1136.   if (xa_speed_scale==XA_SPEED_NORM) XA_Remote_SpeedDiff();
  1137. #endif
  1138. }
  1139.  
  1140. /* increase speed scale, but not more than 1000 */
  1141. ACTION_PROC(xanim_faster_action)
  1142. { 
  1143. #ifdef XA_REMOTE_CONTROL
  1144.   if (xa_speed_scale==XA_SPEED_NORM) XA_Remote_SpeedNorm();
  1145. #endif
  1146.   xa_speed_change = 1;
  1147.   if (xa_speed_scale < XA_SPEED_MAX) xa_speed_scale <<= 1;
  1148.   xa_speed_change = 2;
  1149. #ifdef XA_REMOTE_CONTROL
  1150.   if (xa_speed_scale==XA_SPEED_NORM) XA_Remote_SpeedDiff();
  1151. #endif
  1152. }
  1153.  
  1154. /* increase speed scale, but not more than 1000 */
  1155. ACTION_PROC(xanim_set_pingpong)
  1156. { 
  1157.   xa_pingpong_flag = (xa_pingpong_flag == xaTRUE)?(xaFALSE):(xaTRUE);
  1158. }
  1159.  
  1160.  
  1161. /*******************************
  1162.  * set speed to that at startup
  1163.  *******************************/
  1164. ACTION_PROC(xanim_speed_reset_action)
  1165. {
  1166. #ifdef XA_REMOTE_CONTROL
  1167.   if (xa_speed_scale != XA_SPEED_NORM) XA_Remote_SpeedDiff();
  1168. #endif
  1169.   xa_speed_change = 1;
  1170.   xa_speed_scale = XA_SPEED_NORM;
  1171.   xa_speed_change = 2;
  1172. }
  1173.  
  1174. /*******************************
  1175.  * single step across anims
  1176.  *******************************/
  1177. ACTION_PROC(xanim_next_anim_action)
  1178. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  1179.   { xa_anim_status = XA_FILE_NEXT;
  1180.     if (xa_anim_holdoff == xaTRUE) return;
  1181.     xa_anim_holdoff = xaTRUE;
  1182.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1183.                         (XtPointer)XA_SHOW_NORM);
  1184.   }
  1185.   else xa_anim_status = XA_FILE_NEXT;
  1186. #ifdef XA_REMOTE_CONTROL
  1187.   XA_Remote_StepNext();
  1188. #endif
  1189. }
  1190.  
  1191. /*******************************
  1192.  * single step across anims
  1193.  *******************************/
  1194. ACTION_PROC(xanim_prev_anim_action)
  1195. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  1196.   { xa_anim_status = XA_FILE_PREV;
  1197.     if (xa_anim_holdoff == xaTRUE) return;
  1198.     xa_anim_holdoff = xaTRUE;
  1199.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1200.                         (XtPointer)XA_SHOW_NORM);
  1201.   }
  1202.   else xa_anim_status = XA_FILE_PREV;
  1203. #ifdef XA_REMOTE_CONTROL
  1204.   XA_Remote_StepPrev();
  1205. #endif
  1206. }
  1207.  
  1208. /*******************************
  1209.  * single step within anim 
  1210.  *******************************/
  1211. ACTION_PROC(xanim_step_next_int_action)
  1212. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  1213.   { xa_anim_status = XA_ISTP_NEXT;
  1214.     if (xa_anim_holdoff == xaTRUE) return;
  1215.     xa_anim_holdoff = xaTRUE;
  1216.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1217.                         (XtPointer)XA_SHOW_NORM);
  1218.   }
  1219.   else xa_anim_status = XA_STOP_NEXT;
  1220. #ifdef XA_REMOTE_CONTROL
  1221.   XA_Remote_StepNext();
  1222. #endif
  1223. }
  1224.  
  1225. /*******************************
  1226.  * single step within anim 
  1227.  *******************************/
  1228. ACTION_PROC(xanim_step_prev_int_action)
  1229. { if (xa_anim_status & XA_STOP_MASK) /* if stopped */
  1230.   { xa_anim_status = XA_ISTP_PREV;
  1231.     if (xa_anim_holdoff == xaTRUE) return;
  1232.     xa_anim_holdoff = xaTRUE;
  1233.     XtAppAddTimeOut(theContext, 1, (XtTimerCallbackProc)XAnim_Looped, 
  1234.                         (XtPointer)XA_SHOW_NORM);
  1235.   }
  1236.   else xa_anim_status = XA_STOP_PREV;
  1237. #ifdef XA_REMOTE_CONTROL
  1238.   XA_Remote_StepPrev();
  1239. #endif
  1240. }
  1241.  
  1242. /*******************************
  1243.  * decrement xa_audio_volume by 5
  1244.  *******************************/
  1245. ACTION_PROC(xanim_dec_audio_5)
  1246. { vaudiof->volume -= 5; if (vaudiof->volume < 0) vaudiof->volume = 0;
  1247.   vaudiof->newvol = xaTRUE;
  1248.   XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1249. #ifdef XA_REMOTE_CONTROL
  1250.   XA_Remote_Adj_Volume(vaudiof->volume,XA_AUDIO_MAXVOL);
  1251. #endif
  1252. }
  1253.  
  1254. /*******************************
  1255.  * decrement xa_audio_volume by 1 
  1256.  *******************************/
  1257. ACTION_PROC(xanim_dec_audio_1)
  1258. { vaudiof->volume -= 1; if (vaudiof->volume < 0) vaudiof->volume = 0;
  1259.   vaudiof->newvol = xaTRUE;
  1260.   XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1261. #ifdef XA_REMOTE_CONTROL
  1262.   XA_Remote_Adj_Volume(vaudiof->volume,XA_AUDIO_MAXVOL);
  1263. #endif
  1264. }
  1265.  
  1266. /*******************************
  1267.  * increment xa_audio_volume by 5 
  1268.  *******************************/
  1269. ACTION_PROC(xanim_inc_audio_5)
  1270. { vaudiof->volume += 5;
  1271.   if (vaudiof->volume > XA_AUDIO_MAXVOL) vaudiof->volume = XA_AUDIO_MAXVOL;
  1272.   vaudiof->newvol = xaTRUE;
  1273.   XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1274. #ifdef XA_REMOTE_CONTROL
  1275.   XA_Remote_Adj_Volume(vaudiof->volume,XA_AUDIO_MAXVOL);
  1276. #endif
  1277. }
  1278.  
  1279. /*******************************
  1280.  * increment xa_audio_volume by 1
  1281.  *******************************/
  1282. ACTION_PROC(xanim_inc_audio_1)
  1283. { vaudiof->volume += 1;
  1284.   if (vaudiof->volume > XA_AUDIO_MAXVOL) vaudiof->volume = XA_AUDIO_MAXVOL;
  1285.   vaudiof->newvol = xaTRUE;
  1286.   XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1287. #ifdef XA_REMOTE_CONTROL
  1288.   XA_Remote_Adj_Volume(vaudiof->volume,XA_AUDIO_MAXVOL);
  1289. #endif
  1290. }
  1291.  
  1292. /*******************************
  1293.  * mute audio 
  1294.  *******************************/
  1295. ACTION_PROC(xanim_mute_audio)
  1296. { vaudiof->mute = (vaudiof->mute==xaTRUE)?(xaFALSE):(xaTRUE);
  1297.   vaudiof->newvol = xaTRUE;
  1298.   XA_AUDIO_SET_MUTE(vaudiof->mute);
  1299. #ifdef XA_REMOTE_CONTROL
  1300.   if (vaudiof->mute==xaTRUE)    XA_Remote_AudioOn();
  1301.   else                XA_Remote_AudioOff();
  1302. #endif
  1303. }
  1304.  
  1305. /*******************************
  1306.  * toggle speaker 
  1307.  *******************************/
  1308. ACTION_PROC(xanim_speaker_tog)
  1309. {
  1310.   XA_SPEAKER_TOG(2);
  1311. }
  1312.  
  1313. /*******************************
  1314.  * toggle headphone 
  1315.  *******************************/
  1316. ACTION_PROC(xanim_headphone_tog)
  1317. {
  1318.   XA_HEADPHONE_TOG(2);
  1319. }
  1320.  
  1321.  
  1322. /*******************************
  1323.  * Would you believe the main loop?
  1324.  *******************************/
  1325. void xanim_events()
  1326. {
  1327. /* SMR 12 */
  1328. /* If external window has been supplied, watch the properties on that
  1329.    window to determine what action to take. */
  1330.   if (xa_window_id == 0)    XtAppMainLoop(theContext);
  1331.   else
  1332.   {
  1333.     XEvent event;
  1334.     char *command = "";
  1335.     XDestroyWindowEvent *devent = (XDestroyWindowEvent *)&event;
  1336.     XConfigureEvent *cevent = (XConfigureEvent *)&event;
  1337.     XPropertyEvent *pevent = (XPropertyEvent *)&event;
  1338.     xaULONG window_atom = XInternAtom(theDisp, xa_window_propname, False);
  1339.     XChangeProperty(theDisp, mainW, window_atom, XA_STRING, 8,
  1340.             PropModeReplace, (unsigned char *)command, 1);
  1341.     if (xa_window_prepare_flag == xaFALSE)
  1342.       xanim_expose(theWG, event, NULL, 0);
  1343.     while (1)
  1344.     {
  1345.       XtAppNextEvent(theContext, &event);
  1346.  
  1347. /* POD NOTE:  eventually make these into Event Handlers that are
  1348.  * conditionally fired base on "xa_window_id" or some other option.
  1349.  */
  1350.       if (event.type == DestroyNotify && devent->window == mainW)
  1351.       {
  1352.     TheEnd();
  1353.       }
  1354.       else if (event.type == ConfigureNotify && cevent->window == mainW)
  1355.       {
  1356.     x11_window_x = cevent->width;
  1357.     x11_window_y = cevent->height;
  1358.       }
  1359.       else if (event.type == PropertyNotify && pevent->window == mainW)
  1360.       {
  1361.     if (pevent->atom == window_atom)
  1362.     {
  1363.       Atom type;
  1364.       int format;
  1365.       long unsigned int nitems;
  1366.       unsigned long extra;
  1367.       char *command;
  1368.       if (pevent->state == PropertyDelete) TheEnd();
  1369.       XGetWindowProperty(theDisp, pevent->window, pevent->atom, 0,
  1370.                  4, False, AnyPropertyType,
  1371.                  &type, &format, &nitems, &extra,
  1372.                  (unsigned char **)&command);
  1373.       switch (*command)
  1374.       {
  1375.       case 'q':
  1376.         XDeleteProperty(theDisp, pevent->window, pevent->atom);
  1377.         TheEnd();
  1378.         break;
  1379.       case ' ':
  1380.         if (xa_anim_status == XA_UNSTARTED) 
  1381.           xanim_expose(theWG, event, NULL, 0);
  1382.         else xanim_toggle_action(theWG, event, NULL, 0);
  1383.         break;
  1384.       case ',':
  1385.         xanim_step_prev_action(theWG, event, NULL, 0);
  1386.         break;
  1387.       case '.':
  1388.         xanim_step_next_action(theWG, event, NULL, 0);
  1389.         break;
  1390.       case 'm':
  1391.         xanim_step_prev_int_action(theWG, event, NULL, 0);
  1392.         break;
  1393.       case '/':
  1394.         xanim_step_next_int_action(theWG, event, NULL, 0);
  1395.         break;
  1396.       case '-':
  1397.         xanim_faster_action(theWG, event, NULL, 0);
  1398.         break;
  1399.       case '=':
  1400.         xanim_slower_action(theWG, event, NULL, 0);
  1401.         break;
  1402.       case '0':
  1403.         xanim_speed_reset_action(theWG, event, NULL, 0);
  1404.         break;
  1405.       case '1':
  1406.         xanim_dec_audio_5(theWG, event, NULL, 0);
  1407.         break;
  1408.       case '2':
  1409.         xanim_dec_audio_1(theWG, event, NULL, 0);
  1410.         break;
  1411.       case '3':
  1412.         xanim_inc_audio_1(theWG, event, NULL, 0);
  1413.         break;
  1414.       case '4':
  1415.         xanim_inc_audio_5(theWG, event, NULL, 0);
  1416.         break;
  1417.       case 's':
  1418.         xanim_mute_audio(theWG, event, NULL, 0);
  1419.         break;
  1420.       case '8':
  1421.         xanim_speaker_tog(theWG, event, NULL, 0);
  1422.         break;
  1423.       case '9':
  1424.         xanim_headphone_tog(theWG, event, NULL, 0);
  1425.         break;
  1426.       case 'v':
  1427.         vaudiof->volume = atoi(command + 1);
  1428.         if (vaudiof->volume < 0)
  1429.           vaudiof->volume = 0;
  1430.         if (vaudiof->volume > XA_AUDIO_MAXVOL)
  1431.           vaudiof->volume = XA_AUDIO_MAXVOL;
  1432.         vaudiof->newvol = xaTRUE;
  1433.         XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1434.         break;
  1435.       case 'e':
  1436.         x11_expose_flag = xaTRUE;
  1437. /* Need a function to redraw window here! */
  1438.         break;
  1439.       default:
  1440.         break;
  1441.       }
  1442.       XFree(command);
  1443.     }
  1444.       }
  1445.       else XtDispatchEvent(&event);
  1446.     }
  1447.   }
  1448. /* end SMR 12 */
  1449. }
  1450.  
  1451. /* PODNOTE:
  1452.  * macro this
  1453.  */
  1454. xaULONG X11_Get_Line_Size(xsize)
  1455. xaULONG xsize;
  1456. {
  1457.   xaULONG line_size;
  1458.  
  1459.   if (x11_display_type == XA_MONOCHROME)
  1460.        line_size = X11_Get_Bitmap_Width(xsize) / 8;
  1461.   else line_size = xsize * x11_bytes_pixel;
  1462.   return(line_size);
  1463. }
  1464.  
  1465. /*
  1466.  * What's this!? Direct access to X11 structures. tsch tsch.
  1467.  */
  1468. void X11_Init_Image_Struct(image,xsize,ysize)
  1469. XImage *image;
  1470. xaULONG xsize,ysize;
  1471. {
  1472.   xaULONG line_size;
  1473.   line_size = X11_Get_Line_Size(xsize);
  1474.   /*PACK*/
  1475.   if (x11_bits_per_pixel==2) line_size = (line_size + 3) / 4;
  1476.   else if (x11_bits_per_pixel==4) line_size = (line_size + 1) / 2;
  1477.   image->width = xsize;
  1478.   image->height = ysize;
  1479.   image->bytes_per_line = line_size;
  1480. DEBUG_LEVEL2 fprintf(stderr," InitImage %x <%d,%d>\n", (xaULONG)(image),xsize,ysize );
  1481. }
  1482.  
  1483.  
  1484. void X11_OutPut_Visual_Class(vis_class)
  1485. xaULONG vis_class;
  1486. {
  1487.   switch(vis_class)
  1488.   {
  1489.    case StaticGray:  fprintf(stderr,"StaticGray"); break;
  1490.    case GrayScale:   fprintf(stderr,"GrayScale"); break;
  1491.    case StaticColor: fprintf(stderr,"StaticColor"); break;
  1492.    case PseudoColor: fprintf(stderr,"PseudoColor"); break;
  1493.    case TrueColor:   fprintf(stderr,"TrueColor"); break;
  1494.    case DirectColor: fprintf(stderr,"DirectColor"); break;
  1495.   }
  1496. }
  1497.  
  1498. void X11_Show_Visuals()
  1499. { int i,vis_num;
  1500.   XVisualInfo *vis;
  1501.  
  1502.   vis = XGetVisualInfo (theDisp, VisualNoMask, NULL, &vis_num);
  1503.   if ((vis == NULL) || (vis_num == 0) )
  1504.   {
  1505.     fprintf(stderr,"X11: Couldn't get any Visuals\n");
  1506.     return;
  1507.   }
  1508.   else
  1509.   {
  1510.     for(i=0;i<vis_num;i++)
  1511.     {
  1512.       fprintf(stderr,"  visual %d) depth= %d  class= %d  cmap size=%d  ",
  1513.                        i, vis[i].depth, vis[i].class, vis[i].colormap_size );
  1514.       X11_OutPut_Visual_Class(vis[i].class);
  1515.       fprintf(stderr,"\n");
  1516.     }
  1517.   }
  1518. }
  1519.  
  1520. void X11_Get_Colormap(chdr)
  1521. XA_CHDR *chdr;
  1522. {
  1523.   ColorReg *cmap;
  1524.   xaULONG i,*map;
  1525.  
  1526.   /* grab the current cmap and lay it down */
  1527.   for(i=0;i<x11_cmap_size;i++)
  1528.   {
  1529.     if (x11_display_type & XA_X11_TRUE)
  1530.     {
  1531.       xaULONG d;
  1532.       d  =  (i << x11_red_shift)   & x11_red_mask;
  1533.       d |=  (i << x11_green_shift) & x11_green_mask;
  1534.       d |=  (i << x11_blue_shift)  & x11_blue_mask;
  1535.       defs[i].pixel =  d;
  1536.     }
  1537.     else defs[i].pixel = i;
  1538.     defs[i].flags = DoRed | DoGreen | DoBlue;
  1539.   }
  1540.   XQueryColors(theDisp,theCmap,defs,x11_cmap_size);
  1541.   
  1542.   cmap = chdr->cmap;
  1543.   map = chdr->map;
  1544.   if (cmap == 0) TheEnd1("X11_Get_Colormap: cmap = 0");
  1545.   if (map == 0) TheEnd1("X11_Get_Colormap: map = 0");
  1546. DEBUG_LEVEL2 fprintf(stderr,"X11_Get_Colormap:\n");
  1547.   for(i=0;i<x11_cmap_size;i++)
  1548.   {
  1549.     xaULONG r,g,b;
  1550.     r = cmap[i].red   = (xaUSHORT)defs[i].red; 
  1551.     g = cmap[i].green = (xaUSHORT)defs[i].green; 
  1552.     b = cmap[i].blue  = (xaUSHORT)defs[i].blue; 
  1553.     cmap[i].gray =  (xaUSHORT)( ((r * 11) + (g * 16) + (b * 5)) >> 5 ); 
  1554.     map[i] = i;
  1555.     DEBUG_LEVEL2 fprintf(stderr,"   %d) <%x %x %x> %x\n",i,r,g,b,chdr->cmap[i].gray);
  1556.   }
  1557. }
  1558.  
  1559. void X11_Make_Nice_CHDR(chdr)
  1560. XA_CHDR *chdr;
  1561. {
  1562.   ColorReg *old_cmap,*new_cmap;
  1563.   xaULONG i,*old_map,*new_map;
  1564.   xaULONG old_csize,old_msize;
  1565.  
  1566.   if ( !(x11_display_type & XA_X11_CMAP)) return;
  1567.   
  1568.   old_cmap = chdr->cmap;
  1569.   old_map  = chdr->map;
  1570.   old_csize = chdr->csize;
  1571.   old_msize = chdr->msize;
  1572.  
  1573.   /* try allocating colors */
  1574.   for(i=0;i<old_csize;i++)
  1575.   {
  1576.     if (x11_display_type & XA_X11_GRAY)
  1577.     {
  1578.       defs[i].red = defs[i].green = defs[i].blue = old_cmap[i].gray;
  1579.     }
  1580.     else
  1581.     {
  1582.       defs[i].red   = old_cmap[i].red;
  1583.       defs[i].green = old_cmap[i].green;
  1584.       defs[i].blue  = old_cmap[i].blue;
  1585.     }
  1586.     defs[i].flags = DoRed | DoGreen | DoBlue;
  1587.     XAllocColor(theDisp,theCmap,&defs[i]);
  1588.   }
  1589.   
  1590.   /* Query the cmap */
  1591.   for(i=0;i<x11_cmap_size;i++)
  1592.   {
  1593.     if (x11_display_type & XA_X11_TRUE)
  1594.     {
  1595.       xaULONG d;
  1596.       d  =  (i << x11_red_shift)   & x11_red_mask;
  1597.       d |=  (i << x11_green_shift) & x11_green_mask;
  1598.       d |=  (i << x11_blue_shift)  & x11_blue_mask;
  1599.       defs[i].pixel =  d;
  1600.     }
  1601.     else defs[i].pixel = i;
  1602.     defs[i].flags = DoRed | DoGreen | DoBlue;
  1603.   }
  1604.   XQueryColors(theDisp,theCmap, defs,x11_cmap_size);
  1605.  
  1606.   if (old_csize != x11_cmap_size)
  1607.   {
  1608.     new_cmap = (ColorReg *)malloc(x11_cmap_size * sizeof(ColorReg) );
  1609.     if (new_cmap == 0) TheEnd1("X11_Make_Nice_CHDR: cmap malloc err");
  1610.     FREE(old_cmap,0x400); old_cmap=0;
  1611.     chdr->csize = x11_cmap_size;
  1612.     chdr->cmap = new_cmap;
  1613.   }
  1614.  
  1615.   if (old_msize != x11_cmap_size)
  1616.   { new_map = (xaULONG *)malloc(x11_cmap_size * sizeof(xaULONG) );
  1617.     if (new_map == 0) TheEnd1("X11_Make_Nice_CHDR: map malloc err");
  1618.     FREE(old_map,0x401); old_cmap=0;
  1619.     chdr->msize = x11_cmap_size;
  1620.     chdr->map = new_map;
  1621.   }
  1622.   
  1623.   DEBUG_LEVEL2 fprintf(stderr,"X11_Make_Nice_CHDR: \n");
  1624.   chdr->moff = chdr->coff = 0;
  1625.   for(i=0;i<x11_cmap_size;i++)
  1626.   { xaULONG r,g,b;
  1627.     r = chdr->cmap[i].red   = defs[i].red; 
  1628.     g = chdr->cmap[i].green = defs[i].green; 
  1629.     b = chdr->cmap[i].blue  = defs[i].blue; 
  1630.     chdr->cmap[i].gray = (xaUSHORT)( ( (r * 11) + (g * 16) + (b * 5) ) >> 5 );
  1631.     chdr->map[i] = i;
  1632.     DEBUG_LEVEL2 fprintf(stderr," %d) <%x %x %x> %x\n",i,r,g,b,chdr->cmap[i].gray);
  1633.   }
  1634. }
  1635.  
  1636.  
  1637. int XA_Error_Handler(errDisp,event)
  1638. Display *errDisp;
  1639. XErrorEvent *event;
  1640. { char errbuff[255];
  1641.   if (x11_error_possible != 1) 
  1642.     XGetErrorText(errDisp,event->error_code, errbuff, 255);
  1643.   x11_error_possible = -1;
  1644.   return(0);
  1645. }
  1646.  
  1647.  
  1648. #ifdef XA_PETUNIA
  1649.  
  1650. void xa_remote_expose();
  1651.  
  1652. static void InitButtons();
  1653. static void InitButtonsTypes();
  1654. static void InitScrolls();
  1655. static void GetButtonColors();
  1656. static void DrawRemote();
  1657. static void DrawButton();
  1658. static void DrawScroll();
  1659. static xaULONG InButtonQuery();
  1660. static void AdjustScroll();
  1661. static xaLONG WhichButton();
  1662.  
  1663.  
  1664.  
  1665. /* Make xa_buttons.h */
  1666.  
  1667. typedef struct
  1668. {
  1669.   int width;
  1670.   int height;
  1671.   unsigned char *hi_bitmap;
  1672.   unsigned char *lo_bitmap;
  1673.   Pixmap hi;
  1674.   Pixmap lo;
  1675. } BUTTON_TYPE;
  1676.  
  1677. /** Buttons ***/
  1678. #include "buttons/but_quad10_hi.xbm"
  1679. #include "buttons/but_quad10_lo.xbm"
  1680. #include "buttons/but_quad16_hi.xbm"
  1681. #include "buttons/but_quad16_lo.xbm"
  1682. #include "buttons/but_rtri10_hi.xbm"
  1683. #include "buttons/but_rtri10_lo.xbm"
  1684. #include "buttons/but_ltri10_hi.xbm"
  1685. #include "buttons/but_ltri10_lo.xbm"
  1686. #include "buttons/but_rstp16_hi.xbm"
  1687. #include "buttons/but_rstp16_lo.xbm"
  1688. #include "buttons/but_lstp16_hi.xbm"
  1689. #include "buttons/but_lstp16_lo.xbm"
  1690. #include "buttons/but_plus16_hi.xbm"
  1691. #include "buttons/but_plus16_lo.xbm"
  1692. #include "buttons/but_dash16_hi.xbm"
  1693. #include "buttons/but_dash16_lo.xbm"
  1694. #include "buttons/but_sond16_hi.xbm"
  1695. #include "buttons/but_sond16_lo.xbm"
  1696. #include "buttons/but_next16_hi.xbm"
  1697. #include "buttons/but_next16_lo.xbm"
  1698. #include "buttons/but_prev16_hi.xbm"
  1699. #include "buttons/but_prev16_lo.xbm"
  1700. #include "buttons/but_circ16_hi.xbm"
  1701. #include "buttons/but_circ16_lo.xbm"
  1702. #include "buttons/but_vol56_lo.xbm"
  1703. #include "buttons/but_vol56_hi.xbm"
  1704.  
  1705. /** Scrollbars */
  1706. #include "buttons/bar_6x4_lo.xbm"
  1707. #include "buttons/bar_6x4_hi.xbm"
  1708.  
  1709. /** Decals ***/
  1710. #include "buttons/txt_exit.xbm"
  1711. #include "buttons/txt_auup.xbm"
  1712. #include "buttons/txt_audn.xbm"
  1713.  
  1714. #define BUTTON_TYPE_QUAD16       0
  1715. #define BUTTON_TYPE_RTRI16       1
  1716. #define BUTTON_TYPE_LTRI16       2
  1717. #define BUTTON_TYPE_RSTP16       3
  1718. #define BUTTON_TYPE_LSTP16       4
  1719. #define BUTTON_TYPE_PLUS16       5
  1720. #define BUTTON_TYPE_DASH16       6
  1721. #define BUTTON_TYPE_SOND16       7
  1722. #define BUTTON_TYPE_QUAD10       8
  1723. #define BUTTON_TYPE_NEXT16       9
  1724. #define BUTTON_TYPE_PREV16      10
  1725. #define BUTTON_TYPE_CIRC16      11
  1726. #define BUTTON_TYPE_VOL56       12
  1727.  
  1728.  
  1729. #define NUM_BUTTON_TYPES 13
  1730. BUTTON_TYPE button_types[] =    {
  1731.         { but_quad16_hi_width, but_quad16_hi_height,
  1732.           but_quad16_hi_bits, but_quad16_lo_bits, 0, 0 },
  1733.         { but_rtri10_hi_width, but_rtri10_hi_height,
  1734.           but_rtri10_hi_bits, but_rtri10_lo_bits, 0, 0 },
  1735.         { but_ltri10_hi_width, but_ltri10_hi_height,
  1736.           but_ltri10_hi_bits, but_ltri10_lo_bits, 0, 0 },
  1737.         { but_rstp16_hi_width, but_rstp16_hi_height,
  1738.           but_rstp16_hi_bits, but_rstp16_lo_bits, 0, 0 },
  1739.         { but_lstp16_hi_width, but_lstp16_hi_height,
  1740.           but_lstp16_hi_bits, but_lstp16_lo_bits, 0, 0 },
  1741.         { but_plus16_hi_width, but_plus16_hi_height,
  1742.           but_plus16_hi_bits, but_plus16_lo_bits, 0, 0 },
  1743.         { but_dash16_hi_width, but_dash16_hi_height,
  1744.           but_dash16_hi_bits, but_dash16_lo_bits, 0, 0 },
  1745.         { but_sond16_hi_width, but_sond16_hi_height,
  1746.           but_sond16_hi_bits, but_sond16_lo_bits, 0, 0 },
  1747.         { but_quad10_hi_width, but_quad10_hi_height,
  1748.           but_quad10_hi_bits, but_quad10_lo_bits, 0, 0 },
  1749.         { but_next16_hi_width, but_next16_hi_height,
  1750.           but_next16_hi_bits, but_next16_lo_bits, 0, 0 },
  1751.         { but_prev16_hi_width, but_prev16_hi_height,
  1752.           but_prev16_hi_bits, but_prev16_lo_bits, 0, 0 },
  1753.         { but_circ16_hi_width, but_circ16_hi_height,
  1754.           but_circ16_hi_bits, but_circ16_lo_bits, 0, 0 },
  1755.         { but_vol56_hi_width, but_vol56_hi_height,
  1756.           but_vol56_hi_bits, but_vol56_lo_bits, 0, 0 },
  1757.                                 };
  1758.  
  1759. #define BUTTON_STATE_OFF    0x0000
  1760. #define BUTTON_STATE_ON        0x0001
  1761.  
  1762. #define BUTTON_STATE_FIXED    0x0100
  1763. #define BUTTON_STATE_AON    0x0100
  1764.  
  1765. #define BUTTON_STATE_SEL      0x0200
  1766. #define BUTTON_STATE_SELON    0x0200
  1767. #define BUTTON_STATE_SELOFF    0x0201
  1768.  
  1769. #define BUTTON_STATE_FSEL     0x0400
  1770.  
  1771. /* redefine into Colors */
  1772. static int button_back,button_lo,button_main,button_hi;
  1773.  
  1774.  
  1775. typedef struct
  1776. { xaLONG type;
  1777.   xaULONG xpos, ypos;
  1778.   xaULONG state;
  1779.   void (*func)();
  1780.   xaULONG width, height;
  1781.   unsigned char *bitmap;
  1782.   Pixmap  pmap;
  1783.   xaLONG scroll;
  1784. } BUTTON;
  1785.  
  1786. /* These are for toggle functions implemented later below */
  1787. #define BUTTON_PLAYPREV 1
  1788. #define BUTTON_PLAYSTOP 2
  1789. #define BUTTON_PLAYNEXT 3
  1790. #define BUTTON_AUDIO    12
  1791. #define BUTTON_SPEED    9
  1792. #define BUTTON_VOLBAR    14
  1793.  
  1794.  
  1795. /* POD Eventually come up with a more elegant way of defining this */
  1796. #define REMOTE_HEIGHT (4 + 16 + 4 + 16 + 4 + 16 + 4 + 20 + 4 )
  1797. #define REMOTE_WIDTH  (4 + 16 + 4 + 10 + 4 + 10 + 4 + 10 + 4 + 16 + 4 )
  1798.  
  1799. #define NUM_BUTTONS 15
  1800. BUTTON buttons[] =      {
  1801.         { BUTTON_TYPE_PREV16,  4,  4 ,BUTTON_STATE_OFF, xanim_step_prev_action,
  1802.                 0, 0, 0, 0, -1 },
  1803.         { BUTTON_TYPE_LTRI16, 24,  4 ,BUTTON_STATE_OFF, xact_playprev,
  1804.                 0, 0, 0, 0, -1 },
  1805.         { BUTTON_TYPE_QUAD10, 38,  4 ,BUTTON_STATE_OFF, xact_playstop,
  1806.                 0, 0, 0, 0, -1 },
  1807.         { BUTTON_TYPE_RTRI16, 52,  4 ,BUTTON_STATE_ON, xact_playnext,
  1808.                 0, 0, 0, 0, -1 },
  1809.         { BUTTON_TYPE_NEXT16, 66,  4 ,BUTTON_STATE_OFF, xanim_step_next_action,
  1810.                 0, 0, 0, 0, -1 },
  1811.  
  1812.         { BUTTON_TYPE_LSTP16,  11, 24 ,BUTTON_STATE_OFF, xanim_prev_anim_action,
  1813.                 0, 0, 0, 0, -1 },
  1814.         { BUTTON_TYPE_QUAD16,  31, 24 ,BUTTON_STATE_OFF, xanim_quit_action,
  1815.                 txt_exit_width, txt_exit_height, txt_exit_bits, 0, -1 },
  1816.         { BUTTON_TYPE_RSTP16,  51, 24 ,BUTTON_STATE_OFF, xanim_next_anim_action,
  1817.                 0, 0, 0, 0, -1 },
  1818.  
  1819.         { BUTTON_TYPE_DASH16, 11, 44 ,BUTTON_STATE_OFF,xanim_slower_action,
  1820.                 0, 0, 0, 0, 0},
  1821.         { BUTTON_TYPE_CIRC16, 31, 44 ,BUTTON_STATE_ON, xanim_speed_reset_action,
  1822.                 0, 0, 0, 0, -1 },
  1823.         { BUTTON_TYPE_PLUS16, 51, 44 ,BUTTON_STATE_OFF,xanim_faster_action,
  1824.                 0, 0, 0, 0, -1 },
  1825.  
  1826.         { BUTTON_TYPE_SOND16, 11, 64 ,BUTTON_STATE_OFF, xanim_dec_audio_5,
  1827.                 txt_audn_width, txt_audn_height, txt_audn_bits, 0, -1 },
  1828.         { BUTTON_TYPE_SOND16, 31, 64 ,BUTTON_STATE_ON, xanim_mute_audio,
  1829.                 0, 0, 0, 0, -1 },
  1830.         { BUTTON_TYPE_SOND16, 51, 64 ,BUTTON_STATE_OFF, xanim_inc_audio_5,
  1831.                 txt_auup_width, txt_auup_height, txt_auup_bits, 0, -1 },
  1832.         { BUTTON_TYPE_VOL56 , 72, 26 ,BUTTON_STATE_AON, xanim_set_volume,
  1833.                 0, 0, 0, 0, 0 },
  1834.                         };
  1835.  
  1836.  
  1837. static void xanim_set_volume(w,event,but)
  1838. Widget w;
  1839. XEvent *event;
  1840. BUTTON *but;
  1841. { XButtonEvent *xbut = (XButtonEvent *)event;
  1842.   xaLONG len, pos, new_vol;
  1843.  
  1844.   /* border of scroll bar is 2 pixels */
  1845.   len = button_types[ but->type ].height - 4;
  1846.   pos = len - (xbut->y - (but->ypos + 2));
  1847.   if (pos < 0) pos = 0;
  1848.   new_vol = (XA_AUDIO_MAXVOL * pos) / len;
  1849.   if (new_vol > XA_AUDIO_MAXVOL) new_vol = XA_AUDIO_MAXVOL;
  1850.   vaudiof->volume = new_vol;
  1851.   vaudiof->newvol = xaTRUE;
  1852.   XA_AUDIO_SET_VOLUME(vaudiof->volume);
  1853. #ifdef XA_REMOTE_CONTROL
  1854.   XA_Remote_Adj_Volume(vaudiof->volume,XA_AUDIO_MAXVOL);
  1855. #endif
  1856. }
  1857.  
  1858. typedef struct
  1859. {
  1860.   xaULONG type;        /* 0 vert 1 horiz */
  1861.   xaULONG cur;
  1862.   xaULONG xpos, ypos;
  1863.   xaULONG length;
  1864.   xaULONG width, height;
  1865.   unsigned char *lo_bitmap;
  1866.   unsigned char *hi_bitmap;
  1867.   Pixmap  lo;
  1868.   Pixmap  hi;
  1869. } SCROLLBAR;
  1870.  
  1871.  
  1872.  
  1873. #define SCROLLBAR_VOLUME 0
  1874.  
  1875. #define NUM_SCROLLBARS 1
  1876. static SCROLLBAR scrollbars[] = {
  1877.     { 0, 38, 73, 28, 48, bar_6x4_hi_width, bar_6x4_hi_height,
  1878.       bar_6x4_lo_bits, bar_6x4_hi_bits, 0, 0 },
  1879.         };
  1880.  
  1881. static void remote_btn1dn(), remote_btn1up();
  1882.  
  1883. #define REMOTE_ACTIONTABLE_SIZE 2
  1884. XtActionsRec remote_actionTable[] = {
  1885.         {"RemBtn1Dn", remote_btn1dn},
  1886.         {"RemBtn1Up", remote_btn1up},
  1887. };
  1888.  
  1889.  
  1890. String   Remote_Translation =
  1891.   "<Expose>:            Expose()\n\
  1892.    <Btn1Down>:          RemBtn1Dn()\n\
  1893.    <Btn1Up>:            RemBtn1Up()\n\
  1894.    <Key>1:              DecAudio5()\n\
  1895.    <Key>2:              DecAudio1()\n\
  1896.    <Key>3:              IncAudio1()\n\
  1897.    <Key>4:              IncAudio5()\n\
  1898.    <Key>8:              SpeakerTog()\n\
  1899.    <Key>9:              HDPhoneTog()\n\
  1900.    <Key>p:        PingPong()\n\
  1901.    <Key>s:              AudioMute()\n\
  1902.    <Key>q:              Quit()\n\
  1903.    <Key>w:              Resize()\n\
  1904.    <Key>F:              InstallCmap()\n\
  1905.    <Key>z:              RealizeRemote()\n\
  1906.    <Key>g:              StopCmap()\n\
  1907.    <Key>r:              RestoreCmap()\n\
  1908.    <Key>-:              Slower()\n\
  1909.    <Key>=:              Faster()\n\
  1910.    <Key>0:              SpeedReset()\n\
  1911.    <Key>.:              StepNext()\n\
  1912.    <Key>comma:          StepPrev()\n\
  1913.    <Key>greater:        NextAnim()\n\
  1914.    <Key>less:           PrevAnim()\n\
  1915.    <Key>/:              StepNextInt()\n\
  1916.    <Key>m:              StepPrevInt()\n\
  1917.    <Key>space:          RunStop()";
  1918.  
  1919.  
  1920. /* PETUNIA */
  1921. void XA_Create_Remote(wg,remote_flag)
  1922. Widget wg;
  1923. xaLONG remote_flag;
  1924. { xaLONG n;
  1925.   Arg arglist[20];
  1926.   XWMHints xwm_hints;
  1927.  
  1928.   XtAppAddActions(theContext, remote_actionTable, REMOTE_ACTIONTABLE_SIZE);
  1929.  
  1930.   GetButtonColors(0);
  1931.  
  1932.   n = 0;
  1933. #ifdef XtNvisual
  1934.   XtSetArg(arglist[n], XtNvisual, theVisual); n++;
  1935. #endif
  1936.   XtSetArg(arglist[n], XtNcolormap, theCmap); n++;
  1937.   XtSetArg(arglist[n], XtNdepth, x11_depth); n++;
  1938.   XtSetArg(arglist[n], XtNforeground, button_main); n++;
  1939.   XtSetArg(arglist[n], XtNbackground, button_back); n++;
  1940.   XtSetArg(arglist[n], XtNborderColor, button_main); n++;
  1941.   XtSetArg(arglist[n], XtNwidth, REMOTE_WIDTH); n++;
  1942.   XtSetArg(arglist[n], XtNheight, REMOTE_HEIGHT); n++;
  1943.   XtSetArg(arglist[n], XtNx, XA_REMW_XPOS); n++;
  1944.   XtSetArg(arglist[n], XtNy, XA_REMW_YPOS); n++;
  1945.   XtSetArg(arglist[n], XtNmaxWidth, REMOTE_WIDTH); n++;
  1946.   XtSetArg(arglist[n], XtNmaxHeight, REMOTE_HEIGHT); n++;
  1947.  
  1948.   XtSetArg(arglist[n], XtNtranslations,
  1949.                         XtParseTranslationTable(Remote_Translation)); n++;
  1950.  
  1951.   remote_widget = XtCreatePopupShell("Control",topLevelShellWidgetClass,
  1952.                             wg,arglist,n);
  1953.  
  1954.   XtRealizeWidget(remote_widget);
  1955.   remoteW = XtWindow(remote_widget);
  1956.  
  1957.   { xaULONG gc_mask = 0;
  1958.     XGCValues gc_init;
  1959.     gc_init.function = GXcopy;                          gc_mask |= GCFunction;
  1960.     gc_init.foreground = button_main; gc_mask |= GCForeground;
  1961.     gc_init.background = button_back; gc_mask |= GCBackground;
  1962.     gc_init.graphics_exposures = False;         gc_mask |= GCGraphicsExposures;
  1963.     remoteGC  = XCreateGC(theDisp,remoteW,gc_mask,&gc_init);
  1964.   }
  1965.   xwm_hints.input = True;
  1966.   xwm_hints.flags = InputHint;
  1967.   XSetWMHints(theDisp,remoteW,&xwm_hints);
  1968.   XSync(theDisp,False);
  1969.  
  1970.   InitButtonsTypes(button_types,NUM_BUTTON_TYPES);
  1971.   InitButtons(buttons,NUM_BUTTONS);
  1972.   InitScrolls(scrollbars,NUM_SCROLLBARS);
  1973.  
  1974.   /* THIS IS VERY IMPORTANT AND IS TO DELAY STARTUP UNTIL AN EXPOSE EVENT
  1975.    * HAPPENS so everything is realized and mapped before animation starts.
  1976.    * xa_remote_ready is set to xaTRUE in the xa_remote_expose routine.
  1977.    */
  1978.   XtAddRawEventHandler(remote_widget, ExposureMask, False, 
  1979.                         xa_remote_expose, NULL);
  1980.  
  1981.   /******** REALIZE THE WIDGET *******/
  1982.   if (remote_flag == xaTRUE) XA_Realize_Remote(remote_widget);
  1983.   else xa_remote_ready = xaTRUE;
  1984. }
  1985.  
  1986. /* 
  1987.  * uses global last_widget 
  1988.  */
  1989. void XA_Realize_Remote(remote)
  1990. Widget remote;
  1991. {
  1992.   xa_remote_realized = xaTRUE;
  1993.   XtRealizeWidget(remote_widget);
  1994.   remoteW = XtWindow(remote_widget);
  1995.   XSync(theDisp,False);
  1996.   while(XtIsRealized(remote)==False) XSync(theDisp,False);
  1997.  
  1998.   { xaULONG gc_mask = 0;
  1999.     XGCValues gc_init;
  2000.     gc_init.function = GXcopy;                          gc_mask |= GCFunction;
  2001.     gc_init.foreground = button_main; gc_mask |= GCForeground;
  2002.     gc_init.background = button_back; gc_mask |= GCBackground;
  2003.     gc_init.graphics_exposures = False;         gc_mask |= GCGraphicsExposures;
  2004.     remoteGC  = XCreateGC(theDisp,remoteW,gc_mask,&gc_init);
  2005.   }
  2006.   { XWMHints xwm_hints;
  2007.     xwm_hints.input = True;
  2008.     xwm_hints.flags = InputHint;
  2009.     XSetWMHints(theDisp,remoteW,&xwm_hints);
  2010.     XSync(theDisp,False);
  2011.   }
  2012.   XMapWindow(theDisp,remoteW);
  2013.   XRaiseWindow(theDisp, remoteW );
  2014.   XSetWindowColormap(theDisp, remoteW, theCmap); 
  2015.   GetButtonColors(xa_chdr_now);
  2016.   DrawRemote(buttons,NUM_BUTTONS);
  2017. }
  2018.  
  2019. void XA_Unrealize_Remote(remote)
  2020. Widget remote;
  2021. {
  2022.   XSync(theDisp,False);
  2023.   XtPopdown(remote);
  2024.   XSync(theDisp,False);
  2025.   XtUnrealizeWidget(remote);
  2026.   XSync(theDisp,False);
  2027.   while(XtIsRealized(remote)==True) XSync(theDisp,False);
  2028.   xa_remote_realized = xaFALSE;
  2029. }
  2030.  
  2031.  
  2032. /* Event Handler */
  2033. void xa_remote_expose(wg, closure, event, notused)
  2034. Widget          wg;        XtPointer    closure;
  2035. XEvent        *event;        Boolean        *notused;
  2036. { xa_remote_ready = xaTRUE;
  2037.   GetButtonColors(xa_chdr_now);
  2038.   DrawRemote(buttons,NUM_BUTTONS);
  2039. }
  2040.  
  2041.  
  2042. static int button_wait = 0;
  2043.  
  2044. static void PetuniaButtonsUp()
  2045. { int i;
  2046.   button_wait = 0;
  2047.   for(i=0;i<NUM_BUTTONS;i++)
  2048.   { if (buttons[i].state & BUTTON_STATE_SEL)
  2049.         { buttons[i].state &= ~BUTTON_STATE_SEL;
  2050.           DrawButton(&buttons[i]);
  2051.         }
  2052.     if (buttons[i].state & BUTTON_STATE_FSEL)
  2053.         { buttons[i].state &= ~BUTTON_STATE_FSEL; }
  2054.   }
  2055. }
  2056.  
  2057. /* This stuff is to make sure the buttons are held down for X amount
  2058.  * of milliseconds so the user gets to see the button being pressed.
  2059.  * Otherwise on fast machines, they may not see it at all.
  2060.  */
  2061. void PetuniaButtonWait(client_data,id)
  2062. void *client_data;
  2063. void *id;
  2064. {
  2065.   button_wait++;  if (button_wait >= 3) PetuniaButtonsUp();
  2066. }
  2067.  
  2068.  
  2069. ACTION_PROC(remote_btn1dn)
  2070. { XButtonEvent *xbut = (XButtonEvent *)event;
  2071.   int but;
  2072.  
  2073.   if (button_wait) return;  /* Too Soon */
  2074.  
  2075.   but = WhichButton(buttons,NUM_BUTTONS,xbut->x,xbut->y);
  2076.   if ( (but >= 0) && (but < NUM_BUTTONS) )
  2077.   { if (buttons[but].state & BUTTON_STATE_FIXED)
  2078.     { buttons[but].state |= BUTTON_STATE_FSEL;
  2079.     }
  2080.     else
  2081.     { buttons[but].state |= BUTTON_STATE_SEL; 
  2082.       DrawButton( &buttons[but] );
  2083.     }
  2084.     button_wait = 1;
  2085.     XtAppAddTimeOut(theContext,50,(XtTimerCallbackProc)PetuniaButtonWait,NULL);
  2086.  
  2087.   }
  2088. }
  2089.  
  2090. ACTION_PROC(remote_btn1up)
  2091. { XButtonEvent *xbut = (XButtonEvent *)event;
  2092.   int but = WhichButton(buttons,NUM_BUTTONS,xbut->x,xbut->y);
  2093.   if ((but >= 0) && (but < NUM_BUTTONS))
  2094.   { if (buttons[but].state & BUTTON_STATE_SEL)
  2095.     { 
  2096.       if (buttons[but].func)  buttons[but].func(w,event,params,num_params);
  2097.     }
  2098.     else if (buttons[but].state & BUTTON_STATE_FSEL)
  2099.     {
  2100.       if (buttons[but].func)  buttons[but].func(w,event,&buttons[but]);
  2101.     }
  2102.   }
  2103.   button_wait++;  if (button_wait >= 3) PetuniaButtonsUp();
  2104. }
  2105.  
  2106. /***************************************
  2107.  * Find closet color in chdr, but NOT for monochrome displays
  2108.  *  r,g,b  8 bits each.
  2109.  *******************************/
  2110. xaULONG PetuniaGetColor(r,g,b,chdr)
  2111. xaULONG r,g,b;
  2112. XA_CHDR *chdr;
  2113. { if (x11_display_type & XA_X11_TRUE) return(X11_Get_True_Color(r,g,b,8));
  2114.   else if ((chdr) || (xa_chdr_first))
  2115.   { XA_CHDR *tchdr = (chdr)?(chdr):(xa_chdr_first);
  2116.     /* using xaFALSE for GrayScale?? */
  2117.     return( CMAP_Find_Closest(tchdr->cmap,tchdr->csize,r,g,b,8,8,8,xaTRUE) );
  2118.   }
  2119.   else
  2120.   { XColor col;        
  2121.     col.red   = r; col.green = g; col.blue  = b;
  2122.     col.flags = DoRed | DoGreen | DoBlue;
  2123.     XAllocColor(theDisp,theCmap,&col);
  2124.     return( (xaULONG)(col.pixel) );
  2125.   }
  2126. }
  2127.  
  2128. static void GetButtonColors(chdr)
  2129. XA_CHDR *chdr;
  2130. { if (x11_display_type == XA_MONOCHROME)
  2131.   { button_main = button_back = BlackPixel(theDisp,theScreen);
  2132.     button_hi = button_lo = WhitePixel(theDisp,theScreen);
  2133.   }
  2134.   else
  2135.   { button_back = PetuniaGetColor(0x00,0x00,0x00,chdr);
  2136.     button_lo   = PetuniaGetColor(0x60,0x60,0x60,chdr);
  2137.     button_main = PetuniaGetColor(0xa8,0xa8,0xa8,chdr);
  2138.     button_hi   = PetuniaGetColor(0xd0,0xd0,0xd0,chdr);
  2139.   }
  2140. }
  2141.  
  2142.  
  2143. /*
  2144.  * Use remoteW, remoteGC
  2145.  *
  2146.  *
  2147.  *
  2148.  */
  2149. static void DrawRemote(buttons,num)
  2150. BUTTON *buttons;
  2151. xaULONG num;
  2152. { int i;
  2153.  
  2154.   XSetClipMask(theDisp,remoteGC,None);
  2155.   XSetForeground(theDisp,remoteGC,button_main);
  2156.   XFillRectangle(theDisp,remoteW,remoteGC,0,0,REMOTE_WIDTH,REMOTE_HEIGHT);
  2157.   for(i=0; i < num; i++) DrawButton( &buttons[i] );
  2158. }
  2159.  
  2160.  
  2161. static void InitButtonsTypes(button_types,num)
  2162. BUTTON_TYPE *button_types;
  2163. xaULONG num;
  2164. { xaULONG i;
  2165.  
  2166.   for(i=0; i < num; i++)
  2167.   { if (button_types[i].width)
  2168.     { button_types[i].hi = XCreatePixmapFromBitmapData(theDisp, remoteW, 
  2169.     (char *)button_types[i].hi_bitmap,
  2170.     (int)button_types[i].width, (int)button_types[i].height,0x01,0x00,1);
  2171.       button_types[i].lo = XCreatePixmapFromBitmapData(theDisp, remoteW, 
  2172.     (char *)button_types[i].lo_bitmap,
  2173.     (int)button_types[i].width, (int)button_types[i].height,0x01,0x00,1);
  2174.     }
  2175.   }
  2176. }
  2177.  
  2178. /**** Make sure remoteW exists at this point */
  2179. static void InitButtons(buttons,num)
  2180. BUTTON *buttons;
  2181. xaULONG num;
  2182. { xaULONG i;
  2183.   for(i=0; i < num; i++)
  2184.   { if (buttons[i].bitmap)
  2185.     { buttons[i].pmap = XCreatePixmapFromBitmapData(theDisp, remoteW, 
  2186.     (char *)buttons[i].bitmap,
  2187.     (int)buttons[i].width, (int)buttons[i].height,0x01,0x00,1);
  2188.     }
  2189.   }
  2190. }
  2191.  
  2192. static void InitScrolls(scrolls,num)
  2193. SCROLLBAR *scrolls;
  2194. xaULONG num;
  2195. { xaULONG i;
  2196.  
  2197.   for(i=0; i < num; i++)
  2198.   { 
  2199.     scrolls[i].hi = XCreatePixmapFromBitmapData(theDisp, remoteW, 
  2200.     (char *)scrolls[i].hi_bitmap,
  2201.     (int)scrolls[i].width, (int)scrolls[i].height,0x01,0x00,1);
  2202.     scrolls[i].lo = XCreatePixmapFromBitmapData(theDisp, remoteW, 
  2203.     (char *)scrolls[i].lo_bitmap,
  2204.     (int)scrolls[i].width, (int)scrolls[i].height,0x01,0x00,1);
  2205.   }
  2206. }
  2207.  
  2208.  
  2209. static void DrawButton(button)
  2210. BUTTON *button;
  2211. { xaULONG type,x,y,width,height;
  2212.   int hi, lo; 
  2213.  
  2214.   if (button == 0) return;
  2215.   type = button->type;
  2216.   x = button->xpos;            y = button->ypos;
  2217.   width  = button_types[type].width;    height = button_types[type].height;
  2218.  
  2219.   if (button->state == BUTTON_STATE_OFF) { hi = button_hi; lo = button_lo; }
  2220.   else { hi = button_lo; lo = button_hi; }
  2221.  
  2222.   XSetClipOrigin(theDisp,remoteGC,x,y);
  2223.     /** If SubButton erase area first **/
  2224.   if (button->scroll >= 0)
  2225.   { XSetForeground(theDisp,remoteGC,button_main);
  2226.     XSetClipMask(theDisp,remoteGC,None);
  2227.     XFillRectangle(theDisp,remoteW,remoteGC,
  2228.                 (int)x,(int)y,(int)width,(int)height);
  2229.   }
  2230.     /** Low Color **/
  2231.   if (button_types[type].lo)
  2232.   { XSetForeground(theDisp,remoteGC,lo);
  2233.     XSetClipMask(theDisp,remoteGC,button_types[type].lo);
  2234.     XFillRectangle(theDisp,remoteW,remoteGC,
  2235.                 (int)x,(int)y,(int)width,(int)height);
  2236.   }
  2237.     /** Hi Color **/
  2238.   if (button_types[type].hi)
  2239.   { XSetForeground(theDisp,remoteGC,hi);
  2240.     XSetClipMask(theDisp,remoteGC,button_types[type].hi);
  2241.     XFillRectangle(theDisp,remoteW,remoteGC,
  2242.                 (int)x,(int)y,(int)width,(int)height);
  2243.   }
  2244.     /** Text Color **/
  2245.   if (button->pmap)
  2246.   { if (x11_display_type == XA_MONOCHROME)
  2247.             XSetForeground(theDisp,remoteGC,button_hi);
  2248.     else        XSetForeground(theDisp,remoteGC,button_back);
  2249.     XSetClipMask(theDisp,remoteGC,button->pmap);
  2250.     XFillRectangle(theDisp,remoteW,remoteGC,
  2251.             (int)x,(int)y,(int)button->width,(int)button->height);
  2252.   }
  2253.   if (button->scroll >= 0) DrawScroll( &scrollbars[button->scroll] );
  2254.   XSync(theDisp,False);
  2255. }
  2256.  
  2257. static void DrawScroll(scroll)
  2258. SCROLLBAR *scroll;
  2259. { xaULONG x,y,width,height;
  2260.  
  2261.   if (scroll == 0) return;
  2262.   if (scroll->type == 0) { x = scroll->xpos;        y = scroll->cur; }
  2263.   else             { x = scroll->cur;        y = scroll->ypos; }
  2264.  
  2265.   width  = scroll->width;    height = scroll->height;
  2266.  
  2267.   XSetClipOrigin(theDisp,remoteGC,x,y);
  2268.     /** Low Color **/
  2269.   if (scroll->lo)
  2270.   { XSetForeground(theDisp,remoteGC,button_lo);
  2271.     XSetClipMask(theDisp,remoteGC,scroll->lo);
  2272.     XFillRectangle(theDisp,remoteW,remoteGC,
  2273.                 (int)x,(int)y,(int)width,(int)height);
  2274.   }
  2275.     /** Hi Color **/
  2276.   if (scroll->hi)
  2277.   { XSetForeground(theDisp,remoteGC,button_hi);
  2278.     XSetClipMask(theDisp,remoteGC,scroll->hi);
  2279.     XFillRectangle(theDisp,remoteW,remoteGC,
  2280.                 (int)x,(int)y,(int)width,(int)height);
  2281.   }
  2282.   XSync(theDisp,False);
  2283. }
  2284.  
  2285. /* ret xaTRUE if in button
  2286.  *     xaFALSE if not
  2287.  */
  2288. static xaULONG InButtonQuery(button,x,y)
  2289. BUTTON *button;
  2290. int x,y;
  2291. { BUTTON_TYPE  *btype; if (button == 0) return(xaFALSE);
  2292.   if (button->type >= NUM_BUTTON_TYPES) return(xaFALSE);
  2293.   btype = &button_types[ button->type ];
  2294.   if ((x < button->xpos) || (y < button->ypos)) return(xaFALSE);
  2295.   if (x > (button->xpos + btype->width)) return(xaFALSE);
  2296.   if (y > (button->ypos + btype->height)) return(xaFALSE);
  2297. /*POD TODO: separate active region of button */
  2298.   return(xaTRUE);
  2299. }
  2300.  
  2301.  
  2302. static xaLONG WhichButton(buttons,num,x,y)
  2303. BUTTON *buttons;
  2304. xaULONG num;
  2305. int x,y;
  2306. { int i;
  2307.   for(i=0; i<num; i++) if (InButtonQuery(&buttons[i],x,y)==xaTRUE) return(i);
  2308.   return(-1);
  2309. }
  2310.  
  2311. static void AdjustScroll(sidx, val, scale)
  2312. xaULONG sidx;
  2313. xaULONG val, scale;
  2314. { SCROLLBAR *scroll; xaULONG pos;
  2315.   if (sidx >= NUM_SCROLLBARS) return;
  2316.   if (scale == 0) return; 
  2317.   scroll = &scrollbars[sidx];
  2318.   if (val > scale) val = scale; 
  2319.   pos = (val * scroll->length) / scale;
  2320.  
  2321.   if (scroll->type == 0) scroll->cur = (scroll->ypos + scroll->length) - pos;
  2322.   else             scroll->cur =  scroll->xpos + pos;
  2323.  
  2324. }
  2325.  
  2326.  
  2327. void XA_Remote_Play_Common(prev,stop,next)  
  2328. xaULONG prev,stop,next;
  2329. { buttons[BUTTON_PLAYPREV].state = prev;
  2330.   buttons[BUTTON_PLAYSTOP].state = stop;
  2331.   buttons[BUTTON_PLAYNEXT].state = next;
  2332.   DrawButton(&buttons[BUTTON_PLAYPREV]);
  2333.   DrawButton(&buttons[BUTTON_PLAYSTOP]);
  2334.   DrawButton(&buttons[BUTTON_PLAYNEXT]);
  2335. }
  2336.  
  2337. void XA_Remote_PlayPrev()  
  2338.  { XA_Remote_Play_Common(BUTTON_STATE_ON, BUTTON_STATE_OFF, BUTTON_STATE_OFF); }
  2339. void XA_Remote_PlayStop()  
  2340.  { XA_Remote_Play_Common(BUTTON_STATE_OFF, BUTTON_STATE_ON, BUTTON_STATE_OFF); }
  2341. void XA_Remote_PlayNext()  
  2342.  { XA_Remote_Play_Common(BUTTON_STATE_OFF, BUTTON_STATE_OFF, BUTTON_STATE_ON); }
  2343. void XA_Remote_StepPrev() { XA_Remote_PlayStop(); }
  2344. void XA_Remote_StepNext() { XA_Remote_PlayStop(); }
  2345.  
  2346. void XA_Remote_Pause()      { XA_Remote_PlayStop(); }
  2347.  
  2348. void XA_Remote_AudioOff()
  2349. { buttons[BUTTON_AUDIO].state = BUTTON_STATE_ON;
  2350.   DrawButton(&buttons[BUTTON_AUDIO]);
  2351. }
  2352. void XA_Remote_AudioOn()
  2353. { buttons[BUTTON_AUDIO].state = BUTTON_STATE_OFF;
  2354.   DrawButton(&buttons[BUTTON_AUDIO]);
  2355. }
  2356. void XA_Remote_SpeedNorm()
  2357. { buttons[BUTTON_SPEED].state = BUTTON_STATE_OFF;
  2358.   DrawButton(&buttons[BUTTON_SPEED]);
  2359. }
  2360. void XA_Remote_SpeedDiff()
  2361. { buttons[BUTTON_SPEED].state = BUTTON_STATE_ON;
  2362.   DrawButton(&buttons[BUTTON_SPEED]);
  2363. }
  2364. void XA_Remote_Adj_Volume(vol,maxvol)
  2365. xaULONG vol,maxvol;
  2366. { AdjustScroll(SCROLLBAR_VOLUME,vol,maxvol);
  2367.   DrawButton(&buttons[BUTTON_VOLBAR]);
  2368. }
  2369. void XA_Remote_ColorUpdate(chdr)
  2370. XA_CHDR *chdr;
  2371. {
  2372.   GetButtonColors(chdr);
  2373.   DrawRemote(buttons,NUM_BUTTONS);
  2374. }
  2375.  
  2376. void XA_Remote_Free()
  2377. { int i;
  2378.   for(i=0; i< NUM_BUTTON_TYPES; i++)
  2379.   { if (button_types[i].hi)
  2380.     { XFreePixmap(theDisp,button_types[i].hi); button_types[i].hi = 0; }
  2381.     if (button_types[i].lo)
  2382.     { XFreePixmap(theDisp,button_types[i].lo); button_types[i].lo = 0; }
  2383.   }
  2384.   for(i=0; i< NUM_BUTTONS; i++)
  2385.   { if (buttons[i].pmap)
  2386.     { XFreePixmap(theDisp,buttons[i].pmap); buttons[i].pmap = 0; }
  2387.   }
  2388.   for(i=0; i< NUM_SCROLLBARS; i++)
  2389.   { if (scrollbars[i].hi)
  2390.     { XFreePixmap(theDisp,scrollbars[i].hi); scrollbars[i].hi = 0; }
  2391.     if (scrollbars[i].lo)
  2392.     { XFreePixmap(theDisp,scrollbars[i].lo); scrollbars[i].lo = 0; }
  2393.   }
  2394. }
  2395.  
  2396.  
  2397. #else
  2398. #ifdef XA_REMOTE_CONTROL
  2399. /****************************************************************************
  2400.  *  XA_Create_Remote with non-portable, troublesome, silly Widgets.
  2401.  *  Schedules to be removed with haste.
  2402.  ****************************************************************************/
  2403. void xa_remote_expose();
  2404.  
  2405. #include "BM_step_prev.xbm"
  2406. #include "BM_play.xbm"
  2407. #include "BM_step_next.xbm"
  2408. #include "BM_next.xbm"
  2409. #include "BM_quit.xbm"
  2410. #include "BM_prev.xbm"
  2411. #include "BM_slower.xbm"
  2412. #include "BM_speed1.xbm"
  2413. #include "BM_faster.xbm"
  2414. #include "BM_vol_dn.xbm"
  2415. #include "BM_vol_off.xbm"
  2416. #include "BM_vol_up.xbm"
  2417. #include "BM_back.xbm"
  2418. #include "BM_stop.xbm"
  2419. #include "BM_vol_on.xbm"
  2420. #include "BM_fuzz.xbm"
  2421.  
  2422. #define BM_NUMBER 16
  2423. #define BM_STPP        0
  2424. #define BM_PLAY        1
  2425. #define BM_STPN        2
  2426. #define BM_NEXT        3
  2427. #define BM_QUIT        4
  2428. #define BM_PREV        5
  2429. #define BM_SLOW        6
  2430. #define BM_NORM        7
  2431. #define BM_FAST        8
  2432. #define BM_BACK        12
  2433. #define BM_STOP        13
  2434. #define BM_FUZZ        15
  2435.  
  2436. #ifdef XA_AUDIO
  2437. #define BM_VDOWN    9
  2438. #define BM_VOFF        10
  2439. #define BM_VUP        11
  2440. #define BM_VON         14
  2441. #else
  2442. #define BM_VDOWN    15
  2443. #define BM_VOFF        15
  2444. #define BM_VUP        15
  2445. #define BM_VON         15
  2446. #endif
  2447.  
  2448. static Pixmap BM_pmap[BM_NUMBER] = { 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0 };
  2449.  
  2450. static int BM_width[] 
  2451.         = {BM_step_prev_width,BM_play_width,BM_step_next_width,
  2452.         BM_next_width,BM_quit_width,BM_prev_width,BM_slower_width,
  2453.         BM_speed1_width,BM_faster_width,BM_vol_dn_width,
  2454.         BM_vol_off_width,BM_vol_up_width,BM_back_width,
  2455.         BM_stop_width,BM_vol_on_width,BM_fuzz_width};
  2456. static int BM_height[] 
  2457.         = {BM_step_prev_height,BM_play_height,BM_step_next_height,
  2458.         BM_next_height,BM_quit_height,BM_prev_height,BM_slower_height,
  2459.         BM_speed1_height,BM_faster_height,BM_vol_dn_height,
  2460.         BM_vol_off_height,BM_vol_up_height,BM_back_height,
  2461.         BM_stop_height,BM_vol_on_height,BM_fuzz_height};
  2462. static unsigned char *BM_bits[] 
  2463.         = {BM_step_prev_bits,BM_play_bits,BM_step_next_bits,
  2464.         BM_next_bits,BM_quit_bits,BM_prev_bits,BM_slower_bits,
  2465.         BM_speed1_bits,BM_faster_bits,BM_vol_dn_bits,
  2466.         BM_vol_off_bits,BM_vol_up_bits,BM_back_bits,
  2467.         BM_stop_bits,BM_vol_on_bits,BM_fuzz_bits};
  2468.  
  2469.  
  2470. /****** ATHENA DEFINES **********/
  2471. #ifdef XA_ATHENA
  2472. #define XA_FORM_CLASS    formWidgetClass
  2473. #define XA_BUTTON_CLASS    commandWidgetClass
  2474.  
  2475. #define XA_REMOTE_TOPFORM(arg,n)    {}
  2476. #define XA_REMOTE_BOTTOMFORM(arg,n) {}
  2477. #define XA_REMOTE_LEFTFORM(arg,n)   {}
  2478. #define XA_REMOTE_RIGHTFORM(arg,n)  {}
  2479. #define XA_REMOTE_TOPWIDGET(arg,n,the_w) {XtSetArg(arg[n],XtNfromVert,the_w); n++;}
  2480. #define XA_REMOTE_LEFTWIDGET(arg,n,the_w) {XtSetArg(arg[n],XtNfromHoriz,the_w); n++;}
  2481.  
  2482. #define XA_REMOTE_PIXMAP(arg,n,pixmap)    { \
  2483.  XtSetArg(arg[n],XtNbitmap, pixmap); n++; }
  2484.  
  2485. #endif  /******** END OF ATHENA **********/
  2486.  
  2487. /****** MOTIF DEFINES **********/
  2488. #ifdef XA_MOTIF
  2489. #define XA_FORM_CLASS    xmFormWidgetClass
  2490. #define XA_BUTTON_CLASS    xmPushButtonWidgetClass
  2491.  
  2492. #define XA_REMOTE_TOPFORM(arg,n)    {XtSetArg(arg[n],XmNtopAttachment,XmATTACH_FORM); n++;}
  2493. #define XA_REMOTE_BOTTOMFORM(arg,n) {XtSetArg(arg[n],XmNbottomAttachment,XmATTACH_FORM); n++;}
  2494. #define XA_REMOTE_LEFTFORM(arg,n)   {XtSetArg(arg[n],XmNleftAttachment,XmATTACH_FORM); n++;}
  2495. #define XA_REMOTE_RIGHTFORM(arg,n)  {XtSetArg(arg[n],XmNrightAttachment,XmATTACH_FORM); n++;}
  2496.  
  2497. #define XA_REMOTE_TOPWIDGET(arg,n,the_w)    { \
  2498.   XtSetArg(arg[n],XmNtopAttachment,XmATTACH_WIDGET); n++; \
  2499.   XtSetArg(arg[n],XmNtopWidget,the_w); n++;    }
  2500.  
  2501. #define XA_REMOTE_LEFTWIDGET(arg,n,the_w)    { \
  2502.   XtSetArg(arg[n],XmNleftAttachment,XmATTACH_WIDGET); n++; \
  2503.   XtSetArg(arg[n],XmNleftWidget,the_w); n++;    }
  2504.  
  2505. #define XA_REMOTE_PIXMAP(arg,n,pixmap)    { \
  2506.  XtSetArg(arg[n],XmNlabelPixmap, pixmap); n++; \
  2507.  XtSetArg(arg[n],XmNlabelType,XmPIXMAP); n++;    }
  2508. #endif  /******** END OF MOTIF **********/
  2509.  
  2510.  
  2511. void XA_Create_Remote(wg,remote_flag)
  2512. Widget wg;
  2513. xaLONG remote_flag;
  2514. { int i,n,nb,nc,foregnd,backgnd;
  2515.   Widget form,w,oldw;
  2516.   Arg arglist[20];
  2517.   Window t_window;
  2518.  
  2519. /* Query Black and White */
  2520.   if (x11_display_type == XA_MONOCHROME)
  2521.   { foregnd = WhitePixel(theDisp,theScreen);
  2522.     backgnd = BlackPixel(theDisp,theScreen);
  2523.   }
  2524.   else if (x11_display_type & XA_X11_TRUE)
  2525.   { backgnd = X11_Get_True_Color(0,0,0,8);
  2526.     foregnd = X11_Get_True_Color(255,255,255,8);
  2527.   }
  2528.   else if (xa_chdr_first)
  2529.   { XA_CHDR *chdr = xa_chdr_first;
  2530.    backgnd = CMAP_Find_Closest(chdr->cmap,chdr->csize,0,0,0,8,8,8,xaTRUE);
  2531.    foregnd = CMAP_Find_Closest(chdr->cmap,chdr->csize,255,255,255,8,8,8,xaTRUE);
  2532.    i = 2;
  2533.   }
  2534.   else
  2535.   { foregnd = WhitePixel(theDisp,theScreen);
  2536.     backgnd = BlackPixel(theDisp,theScreen);
  2537.   }
  2538.  
  2539.  if (x11_verbose_flag == xaTRUE)
  2540.     fprintf(stderr,"foregnd = %x backgnd = %x\n",foregnd,backgnd);
  2541.  
  2542.  for(i=0; i < BM_NUMBER; i++)
  2543.  {
  2544.    BM_pmap[i] = XCreatePixmapFromBitmapData(theDisp,mainW,(char *)(BM_bits[i]),
  2545.             BM_width[i],BM_height[i],foregnd,backgnd,x11_depth);
  2546.  }
  2547.  
  2548.  
  2549.  
  2550.   nb = 0;
  2551. #ifdef XtNvisual
  2552.   XtSetArg(arglist[nb], XtNvisual, theVisual); nb++;
  2553. #endif
  2554.   XtSetArg(arglist[nb], XtNcolormap, theCmap); nb++;
  2555.   XtSetArg(arglist[nb], XtNdepth, x11_depth); nb++;
  2556.   XtSetArg(arglist[nb], XtNforeground, foregnd); nb++;
  2557.   XtSetArg(arglist[nb], XtNbackground, backgnd); nb++;
  2558.   XtSetArg(arglist[nb], XtNborderColor, foregnd); nb++;
  2559.   XtSetArg(arglist[nb], XtNx, XA_REMW_XPOS); nb++;
  2560.   XtSetArg(arglist[nb], XtNy, XA_REMW_YPOS); nb++;
  2561.  
  2562.   XtSetArg(arglist[nb], XtNtranslations,
  2563.                         XtParseTranslationTable(Translation)); nb++;
  2564.  
  2565.   remote_widget = XtCreatePopupShell("Control",topLevelShellWidgetClass,wg,arglist,nb);
  2566.   form = XtCreateManagedWidget("form",XA_FORM_CLASS,remote_widget,arglist,nb);
  2567.  
  2568.   t_window = mainW;
  2569.   /************* TOP ROW: ***/
  2570.   nc = nb; w = XtCreateManagedWidget("stepPrevButton",XA_BUTTON_CLASS, form,NULL,0);
  2571.   XA_REMOTE_TOPFORM(arglist,nc);
  2572.   n = nc;
  2573.   XA_REMOTE_LEFTFORM(arglist,n);
  2574.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_STPP]);
  2575.   XtSetValues(w,arglist,n); oldw = w;
  2576.   XtOverrideTranslations(w, 
  2577.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: StepPrev()"));
  2578.  
  2579.   n = nc; play_widget = XtCreateManagedWidget("toggleButton",XA_BUTTON_CLASS,form,NULL,0);
  2580.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2581.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_STOP]);
  2582.   XtSetValues(play_widget,arglist,n); oldw = play_widget;
  2583.   XtOverrideTranslations(play_widget, 
  2584.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: RunStop()"));
  2585.  
  2586.   n = nc; w = XtCreateManagedWidget("stepNextButton",XA_BUTTON_CLASS,form,NULL,0);
  2587.   XA_REMOTE_RIGHTFORM(arglist,n);
  2588.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2589.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_STPN]);
  2590.   XtSetValues(w,arglist,n); oldw = w;
  2591.   XtOverrideTranslations(w, 
  2592.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: StepNext()"));
  2593.   /************** MIDDLE ROW: **********/
  2594.   nc = nb; w = XtCreateManagedWidget("prevAnimButton",XA_BUTTON_CLASS,form,NULL,0);
  2595.   XA_REMOTE_TOPWIDGET(arglist,nc,oldw);
  2596.   n = nc;
  2597.   XA_REMOTE_LEFTFORM(arglist,n);
  2598.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_PREV]);
  2599.   XtSetValues(w,arglist,n); oldw = w;
  2600.   XtOverrideTranslations(w, 
  2601.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: PrevAnim()"));
  2602.  
  2603.   n = nc; w = XtCreateManagedWidget("quitButton",XA_BUTTON_CLASS,form,NULL,0);
  2604.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2605.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_QUIT]);
  2606.   XtSetValues(w,arglist,n); oldw = w;
  2607.   XtOverrideTranslations(w, 
  2608.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: Quit()"));
  2609.  
  2610.   n = nc; w = XtCreateManagedWidget("nextAnimButton",XA_BUTTON_CLASS,form,NULL,0);
  2611.   XA_REMOTE_RIGHTFORM(arglist,n);
  2612.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2613.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_NEXT]);
  2614.   XtSetValues(w,arglist,n); oldw = w;
  2615.   XtOverrideTranslations(w, 
  2616.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: NextAnim()"));
  2617.   /*************** BOTTOM ROW: ********/
  2618.   nc = nb; w = XtCreateManagedWidget("slowerButton",XA_BUTTON_CLASS,form,NULL,0);
  2619.   XA_REMOTE_TOPWIDGET(arglist,nc,oldw);
  2620.   n = nc;
  2621.   XA_REMOTE_LEFTFORM(arglist,n);
  2622.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_SLOW]);
  2623.   XtSetValues(w,arglist,n); oldw = w;
  2624.   XtOverrideTranslations(w, 
  2625.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: Slower()"));
  2626.  
  2627.   n = nc; norm_widget = XtCreateManagedWidget("speedResetButton",XA_BUTTON_CLASS,form,NULL,0);
  2628.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2629.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_FUZZ]);
  2630.   XtSetValues(norm_widget,arglist,n); oldw = norm_widget;
  2631.   XtOverrideTranslations(norm_widget, 
  2632.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: SpeedReset()"));
  2633.  
  2634.   n = nc; w = XtCreateManagedWidget("fasterButton",XA_BUTTON_CLASS,form,NULL,0);
  2635.   XA_REMOTE_RIGHTFORM(arglist,n);
  2636.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2637.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_FAST]);
  2638.   XtSetValues(w,arglist,n); oldw = w;
  2639.   XtOverrideTranslations(w, 
  2640.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: Faster()"));
  2641.   /********* AUDIO VERY BOTTOM ROW: ****/
  2642.   nc = nb; w = XtCreateManagedWidget("decAudioButton",XA_BUTTON_CLASS,form,NULL,0);
  2643.   XA_REMOTE_TOPWIDGET(arglist,nc,oldw);
  2644.   XA_REMOTE_BOTTOMFORM(arglist,nc);
  2645.   n = nc;
  2646.   XA_REMOTE_LEFTFORM(arglist,n);
  2647.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_VDOWN]);
  2648.   XtSetValues(w,arglist,n); oldw = w;
  2649.   XtOverrideTranslations(w, 
  2650.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: DecAudio5()"));
  2651.  
  2652.   n = nc; audio_widget = XtCreateManagedWidget("audioMuteButton",XA_BUTTON_CLASS,form,NULL,0);
  2653.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2654.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_VOFF]);
  2655.   XtSetValues(audio_widget,arglist,n); oldw = audio_widget;
  2656.   XtOverrideTranslations(audio_widget, 
  2657.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: AudioMute()"));
  2658.  
  2659.   n = nc; last_widget = XtCreateManagedWidget("incAudioButton",XA_BUTTON_CLASS,form,NULL,0);
  2660.   XA_REMOTE_RIGHTFORM(arglist,n);
  2661.   XA_REMOTE_LEFTWIDGET(arglist,n,oldw);
  2662.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[BM_VUP]);
  2663.   XtSetValues(last_widget,arglist,n); oldw = last_widget;
  2664.   XtOverrideTranslations(last_widget, 
  2665.         XtParseTranslationTable("<Btn1Down>,<Btn1Up>: IncAudio5()"));
  2666.  
  2667.  
  2668.  
  2669.   /* THIS IS VERY IMPORTANT AND IS TO DELAY STARTUP UNTIL AN EXPOSE EVENT
  2670.    * HAPPENS so everything is realized and mapped before animation starts.
  2671.    * xa_remote_ready is set to xaTRUE in the xa_remote_expose routine.
  2672.    */
  2673.   XtAddRawEventHandler(last_widget, ExposureMask, False, xa_remote_expose, NULL);
  2674.   /******** REALIZE THE WIDGET *******/
  2675.   if (remote_flag == xaTRUE) XA_Realize_Remote(remote_widget);
  2676.   else xa_remote_ready = xaTRUE;
  2677. }
  2678.  
  2679. void XA_Realize_Remote(remote)
  2680. Widget remote;
  2681. {
  2682.   xa_remote_realized = xaTRUE;
  2683.   XtPopup(remote,XtGrabNone);
  2684.   XSync(theDisp,False);
  2685.   while(XtIsRealized(remote)==False) XSync(theDisp,False);
  2686.   while(XtIsRealized(last_widget)==False) XSync(theDisp,False);
  2687.   XRaiseWindow(theDisp, XtWindow(remote) );
  2688. }
  2689.  
  2690. void XA_Unrealize_Remote(remote)
  2691. Widget remote;
  2692. {
  2693.   XSync(theDisp,False);
  2694.   XtPopdown(remote);
  2695.   XSync(theDisp,False);
  2696.   XtUnrealizeWidget(remote);
  2697.   XSync(theDisp,False);
  2698.   while(XtIsRealized(remote)==True) XSync(theDisp,False);
  2699.   xa_remote_realized = xaFALSE;
  2700. }
  2701.  
  2702. /* Change pixmap of a button */
  2703. void XA_Remote_Change(widg,button)
  2704. Widget widg;
  2705. int button;
  2706. { Arg arglist[5];
  2707.   int n = 0;
  2708.   XA_REMOTE_PIXMAP(arglist,n,BM_pmap[button]);
  2709.   XtSetValues(widg,arglist,n);
  2710. }
  2711.  
  2712. /* Event Handler */
  2713. void xa_remote_expose(wg, closure, event, notused)
  2714. Widget          wg;        XtPointer    closure;
  2715. XEvent        *event;        Boolean        *notused;
  2716. { xa_remote_ready = xaTRUE;
  2717. }
  2718.  
  2719. /* convenience function so xanim.c code can change play button during
  2720.  * pauses. */
  2721. void XA_Remote_Pause()       { XA_Remote_Change(play_widget,BM_PLAY); }
  2722. void XA_Remote_PlayNext()  { XA_Remote_Change(play_widget,BM_PLAY); }
  2723. void XA_Remote_PlayPrev()  { XA_Remote_Change(play_widget,BM_BACK); }
  2724. void XA_Remote_PlayStop()  { XA_Remote_Change(play_widget,BM_STOP); }
  2725. void XA_Remote_StepNext()  { XA_Remote_Change(play_widget,BM_PLAY); }
  2726. void XA_Remote_StepPrev()  { XA_Remote_Change(play_widget,BM_BACK); }
  2727. void XA_Remote_AudioOff()  { XA_Remote_Change(audio_widget,BM_VOFF);}
  2728. void XA_Remote_AudioOn()   { XA_Remote_Change(audio_widget,BM_VON); }
  2729. void XA_Remote_SpeedNorm() { XA_Remote_Change(norm_widget,BM_NORM); }
  2730. void XA_Remote_SpeedDiff() { XA_Remote_Change(norm_widget,BM_FUZZ); }
  2731. void XA_Remote_Adj_Volume(vol,maxvol)
  2732. xaULONG vol,maxvol;
  2733. { xaULONG i = vol * maxvol; /* do nothing */
  2734. }
  2735.  
  2736. void XA_Remote_Free()
  2737. { int i;
  2738.  for(i=0; i < BM_NUMBER; i++) 
  2739.    if (BM_pmap[i]) { XFreePixmap(theDisp,BM_pmap[i]); BM_pmap[i] = 0; }
  2740. }
  2741.  
  2742. #endif
  2743. #endif
  2744.  
  2745. void XA_Free_CMAP()
  2746. {
  2747.   if (theCmap && (theCmap != DefaultColormap(theDisp,theScreen)) )
  2748.             { XFreeColormap(theDisp, theCmap); theCmap = 0; }
  2749. }
  2750.