home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d3xx / d386 / xlispstat.lha / XLispStat / src3.lzh / UNIX / X11graph.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-30  |  90.5 KB  |  3,170 lines
  1. /* X11graph - X11 support for XLISP-STAT                               */
  2. /* XLISP-STAT 2.1 Copyright (c) 1990, by Luke Tierney                  */
  3. /* Additions to Xlisp 2.1, Copyright (c) 1989 by David Michael Betz    */
  4. /* You may give out copies of this software; for conditions see the    */
  5. /* file COPYING included with this distribution.                       */
  6.  
  7. #include <X11/Xlib.h>
  8. #include <X11/Xutil.h>
  9. #include <X11/Xos.h>
  10. #include <X11/cursorfont.h>
  11. #include <X11/keysym.h>
  12. #include <X11/Xatom.h>
  13. #include <sys/types.h>
  14. #include <sys/times.h>
  15.  
  16. #include "xlisp.h"
  17. #include "StGWWindow.h"
  18. #include "StX11options.h"
  19.  
  20. #define nil 0L
  21.  
  22. extern char *progname, buf[];
  23. extern LVAL s_true, sk_close, s_go_away;
  24.  
  25. extern LVAL integer_list_2();
  26. static StX11ObScrollAction();
  27.  
  28. /**************************************************************************/
  29. /**                                                                      **/
  30. /**                            Global Variables                          **/
  31. /**                                                                      **/
  32. /**************************************************************************/
  33.  
  34. /* Global display and screen  variables for use in Xlib calls */
  35. static struct {
  36.   Display *dpy;
  37.   int screen;
  38.   int has_windows;
  39. } StX11Globals;
  40.  
  41. XContext EventContext, ObjectContext, CloseContext, MenuContext, 
  42.   Button1Context, Button2Context, ThumbContext, TextCursorContext,
  43.   WRefConContext, ListFieldContext, ScrollActionContext;
  44. Cursor MenuCursor, ArrowCursor, IBeamCursor;
  45.  
  46. static int pointer_button_down = FALSE;
  47.  
  48. /**************************************************************************/
  49. /**                                                                      **/
  50. /**                       Globals Access Functions                       **/
  51. /**                                                                      **/
  52. /**************************************************************************/
  53.  
  54. Display *StX11Display() { return(StX11Globals.dpy); }
  55. StX11Screen() { return(StX11Globals.screen); }
  56.  
  57. /**************************************************************************/
  58. /**                                                                      **/
  59. /**                       Initialization Functions                       **/
  60. /**                                                                      **/
  61. /**************************************************************************/
  62.  
  63. static x_error_handler(dpy, err)
  64.      Display *dpy;
  65.      XErrorEvent *err;
  66. {
  67.   char msg[80];
  68.  
  69.   XGetErrorText(dpy, err->error_code, msg, 80);
  70.   fprintf(stderr, "X error code %s\n", msg);
  71.   xlfail("You may want to save what you can and exit.");
  72. }
  73.  
  74. StInitGraphics()
  75. {
  76.   char *display_name = NULL;
  77.  
  78.   /* connect to X server */
  79.   if ((StX11Globals.dpy = XOpenDisplay(display_name)) == NULL) {
  80.     fprintf(stderr, "%s: can't connect to X server %s\n", 
  81.         progname, XDisplayName(display_name));
  82.     StX11Globals.has_windows = FALSE;
  83.     return;
  84.   }
  85.   else StX11Globals.has_windows = TRUE;
  86.  
  87.   /* get context ids for objects and callbacks */
  88.   ObjectContext =  XUniqueContext();
  89.   EventContext = XUniqueContext();
  90.   CloseContext = XUniqueContext();
  91.   MenuContext = XUniqueContext();
  92.   Button1Context = XUniqueContext();
  93.   Button2Context = XUniqueContext();
  94.   ThumbContext = XUniqueContext();
  95.   TextCursorContext = XUniqueContext();
  96.   WRefConContext = XUniqueContext();
  97.   ListFieldContext = XUniqueContext();
  98.   ScrollActionContext = XUniqueContext();
  99.  
  100.   /* get the default screen and the font to use */
  101.   StX11Globals.screen = DefaultScreen(StX11Globals.dpy);
  102.   
  103.   /* initialize other modules */
  104.   StX11InitMenus();
  105.   StX11InitDialogs();
  106.   StX11InitGW();
  107.  
  108.   XSetErrorHandler (x_error_handler);
  109.  
  110.   MakeCursors();
  111. }
  112.  
  113. static MakeCursors()
  114. {
  115.   Display *dpy = StX11Display();
  116.  
  117.   ArrowCursor = XCreateFontCursor(dpy, XC_left_ptr);
  118.   IBeamCursor = XCreateFontCursor(dpy, XC_xterm);
  119. }
  120.  
  121. StX11Finish() 
  122. { 
  123.   Display *dpy = StX11Display();
  124.  
  125.   if (StHasWindows()) {
  126.     XFreeCursor(dpy, ArrowCursor);
  127.     XFreeCursor(dpy, IBeamCursor);
  128.     
  129.     StX11FinishMenus();
  130.     StX11FinishDialogs();
  131.     StX11FinishGW();
  132.     XCloseDisplay(dpy); 
  133.   }
  134. }
  135.  
  136. static upcase(str)
  137.      char *str;
  138. {
  139.   for (; *str != '\0'; ++str)
  140.     if (islower(*str))
  141.       *str = toupper(*str);
  142. }
  143.  
  144. is_option_on(s)
  145.      char *s;
  146. {
  147.   strcpy(buf, s);
  148.   upcase(buf);
  149.   return((strcmp(buf, "ON")==0) || (strcmp(buf,"YES")==0)
  150.      || (strcmp(buf,"1")==0) || (strcmp(buf,"TRUE") == 0));
  151. }
  152.  
  153. /**************************************************************************/
  154. /**                                                                      **/
  155. /**                       Event Polling Functions                        **/
  156. /**                                                                      **/
  157. /**************************************************************************/
  158.  
  159. StPollEvent()
  160. {
  161.   Display *dpy = StX11Display();
  162.   XEvent report;
  163.   int (*callback)();
  164.   
  165.   if (StHasWindows() && XEventsQueued(dpy, QueuedAfterFlush) > 0) {
  166.     XNextEvent(dpy, &report);
  167.     if (XFindContext(dpy, report.xany.window, EventContext, &callback) == 0
  168.     && callback != nil)
  169.       (*callback)(report, FALSE);
  170.     if (report.type == MappingNotify) XRefreshKeyboardMapping(&report);
  171.   }
  172.   do_idle_actions();
  173. }
  174.  
  175. StProcessEvent(dpy, report)
  176.      Display *dpy;
  177.      XEvent report;
  178. {
  179.   int (*callback)();
  180.   
  181.   if (XFindContext(dpy, report.xany.window, EventContext, &callback) == 0
  182.       && callback != nil)
  183.     (*callback)(report, FALSE);
  184.   if (report.type == MappingNotify) XRefreshKeyboardMapping(&report);
  185. }
  186.  
  187. /* If no events are pending this function enters a select that blocks  */
  188. /* until X input is available or new input occurs on stdin. It returns */
  189. /* TRUE if the block is broken by character input to sdtin, otherwise  */
  190. /* it returns FALSE.                                                   */
  191. /*
  192. /* It is not clear how well this will work on non BSD systems.         */
  193. StBlockForInput()
  194. {
  195.   Display *dpy = StX11Display();
  196.   int readmask, result;
  197.  
  198.   if (! any_idle_tasks()
  199.       && (! StHasWindows() || XEventsQueued(dpy, QueuedAfterFlush) == 0)) {
  200.     readmask = (StHasWindows()) ? ((1 << ConnectionNumber(dpy)) | (1 << 0))
  201.                                 : (1 << 0);
  202.     result=select(16, &readmask, nil, nil, (struct timeval *) nil);
  203.     return((readmask & (1 <<0)) ? TRUE :FALSE);
  204.   }
  205.   else return(FALSE);
  206. }
  207.  
  208. /**************************************************************************/
  209. /**                                                                      **/
  210. /**                    Screen Information Functions                      **/
  211. /**                                                                      **/
  212. /**************************************************************************/
  213.  
  214. StScreenHasColor()
  215. {
  216.   Display *dpy = StX11Display();
  217.   int screen = StX11Screen();
  218.  
  219.   /* 
  220.    * This only checks for the depth; it does not distinguish between
  221.    * gray-scale monitors and true color. It is not clear whether
  222.    * this is the right decision or not. The usual hack of looking at
  223.    * the visual class seems kind of gross.
  224.    */
  225.   if (StHasWindows()) return((DefaultDepth(dpy, screen) > 1) ? TRUE : FALSE);
  226.   else return(FALSE);
  227. }
  228.  
  229. StGetScreenSize(width, height)
  230.     int *width, *height;
  231. {
  232.   Display *dpy = StX11Display();
  233.   int screen = StX11Screen();
  234.  
  235.   if (StHasWindows()) {
  236.     if (width != nil) *width = DisplayWidth(dpy, screen);
  237.     if (height != nil) *height = DisplayHeight(dpy, screen);
  238.   }
  239.   else {
  240.     if (width != nil) *width = 0;
  241.     if (height != nil) *height = 0;
  242.   }
  243. }
  244.  
  245. StHasWindows() { return (StX11Globals.has_windows); }
  246.  
  247. StFlushGraphics()
  248. {
  249.   Display *dpy = StX11Display();
  250.   XFlush(dpy);
  251. }
  252.  
  253. /**************************************************************************/
  254. /**                                                                      **/
  255. /**                       Simple Window Functions                        **/
  256. /**                                                                      **/
  257. /**************************************************************************/
  258.  
  259. StWSetTitle(win, title)
  260.      Window win;
  261.      char *title;
  262. {
  263.   Display *dpy = StX11Display();
  264.  
  265.   XStoreName(dpy, win, title);
  266. }
  267.  
  268. StHideWindow(win)
  269.      Window win;
  270. {
  271.   Display *dpy = StX11Display();
  272.  
  273.   XUnmapWindow(dpy, win);
  274. }
  275.  
  276. StShowWindow(win)
  277.      Window win;
  278. {
  279.   Display *dpy = StX11Display();
  280.  
  281.   /* XMapSubwindows(dpy, win); */
  282.   XMapRaised(dpy, win);
  283.   XFlush(dpy);
  284. }
  285.  
  286. SetWRefCon(w, rc)
  287.      Window w;
  288.      long rc;
  289. {
  290.   Display *dpy = StX11Display();
  291.  
  292.   if (XSaveContext(dpy, w, WRefConContext, (XContext) rc) != 0)
  293.     xlfail("could not install WRefCon");
  294. }
  295.  
  296. GetWRefCon(w)
  297.      Window w;
  298. {
  299.   Display *dpy = StX11Display();
  300.   int rc;
  301.  
  302.   if (XFindContext(dpy, w, WRefConContext, &rc) == 0) return(rc);
  303.   else return(nil);
  304. }
  305.  
  306. /**************************************************************************/
  307. /**************************************************************************/
  308. /**                                                                      **/
  309. /**                        Graph Window Functions                        **/
  310. /**                                                                      **/
  311. /**************************************************************************/
  312. /**************************************************************************/
  313.  
  314. /**************************************************************************/
  315. /**                                                                      **/
  316. /**                         Graph Window Globls                          **/
  317. /**                                                                      **/
  318. /**************************************************************************/
  319.  
  320. static int use_fast_lines, use_fast_symbols, motion_sync, do_clipping,
  321.   use_icccm, wait_for_map;
  322.  
  323. static unsigned int gw_border_width;
  324. static unsigned long GWBorderColor;
  325.  
  326. static char *GraphFontName = "9x15";
  327. static XFontStruct *GraphFont;
  328.  
  329. # define ScrollWidth 20
  330.  
  331. static int buffering = FALSE;
  332. static int bufflevel = 0;
  333. static Pixmap WorkPort, CharPM;
  334. static GC CharGC, CharEraseGC;
  335. static GC copy_gc;   /* used to deal with the cfb clipping bug in R3 */
  336. GC ResizeGC;
  337.  
  338. typedef struct {
  339.   long Object;                                /* elements of window_data */
  340.   int idleOn, frontOnly;                      /* elements of window_data */
  341.   int mouse_x, mouse_y;                       /* elements of window_data */
  342.   Window window, panel;
  343.   int (*FreeMem)();
  344.   ColorCode backColor, drawColor;
  345.   int canvasWidth, canvasHeight;
  346.   int lineType, drawMode, lineWidth;
  347.   long RefCon;
  348.   int use_color;
  349.   int hasHscroll, hasVscroll, view_h, view_v;
  350.   int v_scroll_inc[2], h_scroll_inc[2];
  351.   Window hscroll, vscroll;
  352.   int initialized;
  353.   int symbolMode;
  354.   int cursor;
  355.   int clip_left, clip_top, clip_width, clip_height;
  356.   int clipped;
  357.   int frame_width, frame_height;
  358.   GC gc, erase_gc, xor_gc;
  359.   int go_away, has_menu_button;
  360. } StGWWinInfo;
  361.  
  362. static unsigned long get_color();
  363.  
  364. extern LVAL slot_value(), mklist();
  365. extern LVAL s_true;
  366.  
  367. static Atom wm_delete_window, wm_protocols;
  368.  
  369. /**************************************************************************/
  370. /**                                                                      **/
  371. /**               Graph Window Initialization and Cleanup                **/
  372. /**                                                                      **/
  373. /**************************************************************************/
  374.  
  375. /* 
  376.    This is a hack to figure out what color to use for xor drawing. The
  377.    idea is to check where white and black differ and look at the result
  378.    of xor'ing black on white. If the result is not white, black should
  379.    work as a drawing color in xor mode. Otherwise use white.
  380. */
  381.  
  382. static unsigned long xor_color(index)
  383.      int index;
  384. {
  385.   Display *dpy = StX11Display();
  386.   int screen = StX11Screen();
  387.   unsigned long mask, white, black;
  388.  
  389.   black = BlackPixel(dpy, screen);
  390.   white = WhitePixel(dpy, screen);
  391.   mask = black ^ white;  /* mask where black and white differ */
  392.   
  393.   if ((white ^ black) != white & mask) return(black);
  394.   else return(white);
  395. }
  396.  
  397. StX11InitGW()
  398. {
  399.   Display *dpy = StX11Display();
  400.   int screen = StX11Screen();
  401.   XGCValues values;
  402.   unsigned long valuemask;
  403.   int font_height, font_width;
  404.   char *font;
  405.   char *option;
  406.  
  407.   MakeColors();
  408.  
  409.   gw_border_width = 1;
  410.   GWBorderColor = BlackPixel(dpy, screen);
  411.  
  412.   /**** fast line drawing - use line width 0 for speed. ****/
  413.   option = XGetDefault(dpy, "xlisp", "graph.fastlines");
  414.   if (option == NULL) use_fast_lines = USE_FAST_LINES_DEFAULT;
  415.   else use_fast_lines = is_option_on(option);
  416.  
  417.   /**** fast symbols - draw them with DrawPoints instead of as Pixmaps ****/
  418.   option = XGetDefault(dpy, "xlisp", "graph.fastsymbols");
  419.   if (option == NULL) use_fast_symbols = USE_FAST_SYMBOLS_DEFAULT;
  420.   else use_fast_symbols = is_option_on(option);
  421.  
  422.   /**** use XSync calls within mouse motion events (no button) ****/
  423.   option = XGetDefault(dpy, "xlisp", "graph.motionsync");
  424.   if (option == NULL) motion_sync = MOTION_SYNC_DEFAULT;
  425.   else motion_sync = is_option_on(option);
  426.  
  427.   /**** use clipping calls (don't work on pmax?) ****/
  428.   option = XGetDefault(dpy, "xlisp", "graph.doclipping");
  429.   if (option == NULL) do_clipping = DO_CLIPPING_DEFAULT;
  430.   else do_clipping = is_option_on(option);
  431.  
  432.   /**** try to be more ICCCM-compliant - may help in OpenLook ****/
  433.   option = XGetDefault(dpy, "xlisp", "graph.icccm");
  434.   if (option == NULL) use_icccm = USE_ICCCM_DEFAULT;
  435.   else use_icccm = is_option_on(option);
  436.  
  437.   /**** wait for MapNotify event in initial draw - may help or hurt ****/
  438.   option = XGetDefault(dpy, "xlisp", "graph.waitformap");
  439.   if (option == NULL) wait_for_map = WAIT_FOR_MAP_DEFAULT;
  440.   else wait_for_map = is_option_on(option);
  441.  
  442.   font = (char *) XGetDefault(dpy, "xlisp", "graph.font");
  443.   if (font == NULL) font = GraphFontName;
  444.   if ((GraphFont = XLoadQueryFont(dpy, font)) == NULL) {
  445.     fprintf(stderr, "xlisp: Can't open %s font\n", font);
  446.     if ((GraphFont = XLoadQueryFont(dpy, GraphFontName)) == NULL) {
  447.       fprintf(stderr, "xlisp: Can't open %s font\n", GraphFontName);
  448.       exit(-1);
  449.     }
  450.   }
  451.   valuemask = 0; /* ignore XGCValues and use defaults */
  452.   CharGC = XCreateGC(dpy, RootWindow(dpy, screen), valuemask, &values);
  453.   XSetFont(dpy, CharGC, GraphFont->fid);
  454.   XSetForeground(dpy, CharGC, BlackPixel(dpy, screen));
  455.   XSetBackground(dpy, CharGC, WhitePixel(dpy, screen));
  456.   CharEraseGC = XCreateGC(dpy, RootWindow(dpy, screen), valuemask, &values);
  457.   XSetFont(dpy, CharEraseGC, GraphFont->fid);
  458.   XSetForeground(dpy, CharEraseGC, WhitePixel(dpy, screen));
  459.   XSetBackground(dpy, CharEraseGC, WhitePixel(dpy, screen));
  460.   valuemask = 0;
  461.   values.function = GXxor;
  462.   ResizeGC = XCreateGC(dpy, RootWindow(dpy, screen), valuemask, &values);
  463.   XSetFunction(dpy, ResizeGC, GXxor);
  464.   XSetForeground(dpy, ResizeGC, xor_color(1));
  465.   XSetBackground(dpy, ResizeGC, WhitePixel(dpy, screen));
  466.  
  467.  
  468.   font_height = GraphFont->max_bounds.ascent + GraphFont->max_bounds.descent;
  469.   font_width = GraphFont->max_bounds.width;
  470.   CharPM = XCreatePixmap(dpy, RootWindow(dpy, screen),
  471.              font_width, font_height, DefaultDepth(dpy, screen));
  472.  
  473.   /* the following is used to deal with the cfb clipping bug in R3 */
  474.   valuemask = 0; /* ignore XGCValues and use defaults */
  475.   copy_gc = XCreateGC(dpy, RootWindow(dpy, screen), valuemask, &values);
  476.  
  477.   MakeWorkPort();
  478.   MakeSymbols();
  479.   MakeGraphCursors();
  480.  
  481.   wm_protocols = XInternAtom (dpy, "WM_PROTOCOLS", FALSE);
  482.   wm_delete_window = XInternAtom(dpy, "WM_DELETE_WINDOW", FALSE);
  483. }
  484.  
  485. StX11FinishGW()
  486. {
  487.   Display *dpy = StX11Display();
  488.  
  489.   XUnloadFont(dpy, GraphFont->fid);
  490. #ifndef SERVER_COLOR_FREE_PROBLEM
  491.   FreeColors();
  492. #endif /* SERVER_COLOR_FREE_PROBLEM */
  493.   XFreeGC(dpy, CharGC);
  494.   XFreeGC(dpy, CharEraseGC);
  495.   XFreeGC(dpy, ResizeGC);
  496.   XFreePixmap(dpy, CharPM);
  497.   FreeSymbols();
  498.   FreeGraphCursors();
  499. }
  500.  
  501. LVAL xsx11_options()
  502. {
  503.   LVAL arg, result, next;
  504.   LVAL sk_fast_lines = xlenter(":FAST-LINES");
  505.   LVAL sk_fast_symbols = xlenter(":FAST-SYMBOLS");
  506.   LVAL sk_motion_sync = xlenter(":MOTION-SYNC");
  507.   LVAL sk_do_clipping = xlenter(":DO-CLIPPING");
  508.   LVAL sk_use_icccm = xlenter(":ICCCM");
  509.   LVAL sk_wait_for_map = xlenter(":WAIT-FOR-MAP");
  510.  
  511.   if (xlgetkeyarg(sk_fast_lines, &arg))
  512.     use_fast_lines = (arg != NIL) ? TRUE : FALSE;
  513.   if (xlgetkeyarg(sk_fast_symbols, &arg))
  514.     use_fast_symbols = (arg != NIL) ? TRUE : FALSE;
  515.   if (xlgetkeyarg(sk_motion_sync, &arg))
  516.     motion_sync = (arg != NIL) ? TRUE : FALSE;
  517.   if (xlgetkeyarg(sk_do_clipping, &arg))
  518.     do_clipping = (arg != NIL) ? TRUE : FALSE;
  519.   if (xlgetkeyarg(sk_use_icccm, &arg))
  520.     use_icccm = (arg != NIL) ? TRUE : FALSE;
  521.   if (xlgetkeyarg(sk_wait_for_map, &arg))
  522.     wait_for_map = (arg != NIL) ? TRUE : FALSE;
  523.  
  524.   result = mklist(12, NIL);
  525.   next = result;
  526.   rplaca(next, sk_fast_lines); next = cdr(next);
  527.   rplaca(next, (use_fast_lines) ? s_true : NIL); next = cdr(next);
  528.   rplaca(next, sk_fast_symbols); next = cdr(next);
  529.   rplaca(next, (use_fast_symbols) ? s_true : NIL); next = cdr(next);
  530.   rplaca(next, sk_motion_sync); next = cdr(next);
  531.   rplaca(next, (motion_sync) ? s_true : NIL); next = cdr(next);
  532.   rplaca(next, sk_do_clipping); next = cdr(next);
  533.   rplaca(next, (do_clipping) ? s_true : NIL); next = cdr(next);
  534.   rplaca(next, sk_use_icccm); next = cdr(next);
  535.   rplaca(next, (use_icccm) ? s_true : NIL); next = cdr(next);
  536.   rplaca(next, sk_wait_for_map); next = cdr(next);
  537.   rplaca(next, (wait_for_map) ? s_true : NIL); next = cdr(next);
  538.  
  539.   return(result);
  540. }
  541.  
  542. StX11UseICCCM() { return(use_icccm); }
  543.  
  544. /***********************************************************************/
  545. /**                                                                   **/
  546. /**             Constructing and Removing Graph Windows               **/
  547. /**                                                                   **/
  548. /***********************************************************************/
  549.  
  550. static LVAL window_object(dpy, w)
  551.      Display *dpy;
  552.      Window w;
  553. {
  554.   LVAL object;
  555.  
  556.   if (XFindContext(dpy, w, ObjectContext, &object) == 0 
  557.       && objectp(object))
  558.     return(object);
  559.   else return(NIL);
  560. }
  561.  
  562. static get_panel_size(gwinfo, width, height, pwidth, pheight)
  563.      StGWWinInfo *gwinfo;
  564.      int width, height, *pwidth, *pheight;
  565. {
  566.   height -= ClosePanelHeight();
  567.   if (gwinfo->hasHscroll) height -= ScrollWidth;
  568.   if (gwinfo->hasVscroll) width -= ScrollWidth;
  569.   if (pwidth != nil) *pwidth = width;
  570.   if (pheight != nil) *pheight = height;
  571. }
  572.  
  573. static make_new_gc(gwinfo)
  574.      StGWWinInfo *gwinfo;
  575. {
  576.   Display *dpy = StX11Display();
  577.   int screen = StX11Screen();
  578.   unsigned long valuemask;
  579.   XGCValues values;
  580.  
  581.   valuemask = GCFunction | GCLineWidth | GCLineStyle;
  582.   values.function = GXcopy;
  583.   if (gwinfo->lineWidth == 1 && use_fast_lines) values.line_width = 0;
  584.   else values.line_width = gwinfo->lineWidth;
  585.   values.line_style = (gwinfo->lineType == 0) ? LineSolid : LineOnOffDash;
  586.  
  587.   gwinfo->gc = XCreateGC(dpy, RootWindow(dpy, screen), valuemask, &values);
  588.   XSetFont(dpy, gwinfo->gc, GraphFont->fid);
  589.   XSetForeground(dpy, gwinfo->gc, get_color(gwinfo->drawColor));
  590.   XSetBackground(dpy, gwinfo->gc, get_color(gwinfo->backColor));
  591.  
  592.   valuemask = 0; /* ignore XGCValues and use defaults */
  593.   gwinfo->erase_gc = XCreateGC(dpy, RootWindow(dpy, screen), 
  594.                    valuemask, &values);
  595.   XSetFont(dpy, gwinfo->erase_gc, GraphFont->fid);
  596.   XSetForeground(dpy, gwinfo->erase_gc, get_color(gwinfo->backColor));
  597.   XSetBackground(dpy, gwinfo->erase_gc, get_color(gwinfo->backColor));
  598.  
  599.   valuemask = GCFunction | GCLineWidth | GCLineStyle;
  600.   values.function = GXxor;
  601.   gwinfo->xor_gc = XCreateGC(dpy, RootWindow(dpy, screen), 
  602.                    valuemask, &values);
  603.   XSetFont(dpy, gwinfo->xor_gc, GraphFont->fid);
  604.   XSetForeground(dpy, gwinfo->xor_gc, xor_color(gwinfo->backColor));
  605.   XSetBackground(dpy, gwinfo->xor_gc, get_color(gwinfo->backColor));
  606.  
  607.   set_gc_clip_regions(gwinfo);
  608. }
  609.  
  610. #define bufsize 20
  611. #define NO_CHARS 0
  612. #define IN_KEY 1
  613. #define IN_BUFFER 2
  614.  
  615. static do_key(report, dpy, win, object)
  616.      XEvent report;
  617.      Display *dpy;
  618.      Window win;
  619.      LVAL object;
  620. {
  621.   char buffer[bufsize];
  622.   KeySym keysym;
  623.   int count, result = NO_CHARS;
  624.   /*XComposeStatus compose;*/
  625.   char key;
  626.   int shift, opt, i;
  627.  
  628.   count = XLookupString(&report, buffer, bufsize, &keysym, nil /*&compose*/);
  629.   if (keysym == XK_Return || keysym == XK_KP_Enter || keysym == XK_Linefeed) {
  630.     result = IN_KEY;
  631.     key = '\n';
  632.   }
  633.   else if ((keysym >= XK_KP_Space && keysym <= XK_KP_9) 
  634.        || (keysym >= XK_space && keysym <= XK_asciitilde)) {
  635.     result = IN_BUFFER;
  636.   }
  637.   else if (keysym >= XK_Shift_L && keysym <= XK_Hyper_R)
  638.     ; /* do nothing because it is a modifier key */
  639.   else if (keysym >= XK_F1 && keysym <= XK_F35) {
  640.     result = IN_BUFFER;
  641.   }
  642.   else if (keysym == XK_BackSpace || keysym == XK_Delete) {
  643.     result = IN_KEY;
  644.     key = '\b';
  645.   }
  646.   else XBell(dpy, 100);
  647.  
  648.   if (result != NO_CHARS) {
  649.     shift = report.xkey.state & ShiftMask;
  650.     opt = report.xkey.state & ControlMask;
  651.  
  652.     if (result == IN_KEY) {
  653.       buffer[0] = key;
  654.       count = 1;
  655.     }
  656.     for (i = 0; i < count; i++)  StGWObDoKey(object, buffer[i], shift, opt);
  657.   }
  658. }
  659.  
  660. static do_motion(report, dpy, win, object)
  661.      XEvent report;
  662.      Display *dpy;
  663.      Window win;
  664.      LVAL object;
  665. {
  666.   StGWWinInfo *gwinfo = (StGWWinInfo *) StGWObWinInfo(object);
  667.   int x, y;
  668.  
  669.   if (XCheckWindowEvent(dpy, win, ButtonPressMask, &report)) {
  670.     do_button(report, dpy, win, object);
  671.   }
  672.   else {
  673.     /* compress motion events */
  674.     do {
  675.       x = report.xmotion.x + gwinfo->view_h;
  676.       y = report.xmotion.y + gwinfo->view_v;
  677.     } while (XCheckMaskEvent(dpy, PointerMotionMask, &report));
  678.  
  679.     /* only act if pointer has really moved */
  680.     if (x != gwinfo->mouse_x || y != gwinfo->mouse_y) {
  681.       gwinfo->mouse_x = x;
  682.       gwinfo->mouse_y = y;
  683.       StGWObDoMouse(object, x, y, MouseMove, (MouseClickModifier) 0);
  684.       if (motion_sync) XSync(dpy, FALSE);
  685.       else XFlush(dpy);
  686.     }
  687.   }
  688. }
  689.  
  690. static do_button(report, dpy, win, object)
  691.      XEvent report;
  692.      Display *dpy;
  693.      Window win;
  694.      LVAL object;
  695. {
  696.   StGWWinInfo *gwinfo = (StGWWinInfo *) StGWObWinInfo(object);
  697.   int x, y;
  698.   int extend, option, mods;
  699.  
  700.   extend = ShiftMask & report.xbutton.state;
  701.   option = ControlMask & report.xbutton.state;
  702.   mods = (int) ((extend) ? ExtendModifier : NoModifiers);
  703.   if (option) mods += 2;
  704.   x = report.xbutton.x + gwinfo->view_h;
  705.   y = report.xbutton.y + gwinfo->view_v;
  706.   gwinfo->mouse_x = x;
  707.   gwinfo->mouse_y = y;
  708.   StX11PressButton();
  709.   StGWObDoMouse(object, x, y, MouseClick, (MouseClickModifier) mods);
  710.   StX11ReleaseButton();
  711.   XSync(dpy, FALSE);
  712. }
  713.  
  714. static LVAL frame_handler(report, modal)
  715.      XEvent report;
  716.      int modal;
  717. {
  718.   Display *dpy = StX11Display();
  719.   StGWWinInfo *gwinfo;
  720.   LVAL object;
  721.   int width, height;
  722.  
  723.   if (modal) return(NIL);
  724.  
  725.   switch(report.type) {
  726.   case ConfigureNotify:
  727.     object = window_object(dpy, report.xany.window);
  728.     if (objectp(object) 
  729.     && (gwinfo = (StGWWinInfo *) StGWObWinInfo(object)) != nil
  730.     &&(gwinfo->frame_width != report.xconfigure.width
  731.        || gwinfo->frame_height != report.xconfigure.height)) {
  732.       gwinfo->frame_width = report.xconfigure.width;
  733.       gwinfo->frame_height = report.xconfigure.height;
  734.       get_panel_size(gwinfo, gwinfo->frame_width, gwinfo->frame_height,
  735.              &width, &height);
  736.       XResizeWindow(dpy, gwinfo->panel, width, height);
  737.       XMapWindow(dpy, gwinfo->panel);  
  738.       if (! gwinfo->hasVscroll) gwinfo->canvasHeight = height;
  739.       if (! gwinfo->hasHscroll) gwinfo->canvasWidth = width;
  740.       adjust_scroll_bars(gwinfo, TRUE);
  741.       gwinfo->initialized = TRUE;
  742.       StGWObResize(object);
  743.     }
  744.     break;
  745.   case Expose:  /* added to remap panel after resize on sun X11 (I hope) */
  746.     object = window_object(dpy, report.xany.window);
  747.     if (objectp(object) 
  748.     && (gwinfo = (StGWWinInfo *) StGWObWinInfo(object)) != nil) {
  749.       XMapWindow(dpy, gwinfo->panel);  
  750.     }
  751.     break;
  752.   case ClientMessage:
  753.     StX11HandleClientMessage(report);
  754.     break;
  755.   default:
  756.     break;
  757.   }
  758.   return(NIL);
  759. }
  760.  
  761. static LVAL panel_handler(report, modal)
  762.      XEvent report;
  763.      int modal;
  764. {
  765.   Display *dpy = StX11Display();
  766.   LVAL object;
  767.   Window win;
  768.  
  769.   if (modal) return(NIL);
  770.  
  771.   win = report.xany.window;
  772.   object = window_object(dpy, win);
  773.   if (objectp(object)) {
  774.     switch(report.type) {
  775.     case Expose:
  776.       if (report.xexpose.count == 0) StGWObRedraw(object);
  777.       break;
  778.     case KeyPress:    
  779.       do_key(report, dpy, win, object);
  780.       break;
  781.     case ButtonPress:
  782.       do_button(report, dpy, win, object);
  783.       break;
  784.     case MotionNotify:
  785.       do_motion(report, dpy, win, object);
  786.       break;
  787.     default:
  788.       break;
  789.     }
  790.   }
  791.   return(NIL);
  792. }
  793.  
  794. StX11HandleClientMessage(report)
  795.      XEvent report;
  796. {
  797.   Display *dpy = StX11Display();
  798.   LVAL object;
  799.  
  800.   /*
  801.    * This sends the :close message to windows with a go_away in response
  802.    * to a window manager delete mindow action (e.g. choosing the Quit
  803.    * item from an olwm frame menu).
  804.    */
  805.   if (report.xclient.data.l[0] == wm_delete_window) {
  806.     object = window_object(dpy, report.xany.window);
  807.     if (objectp(object) && slot_value(object, s_go_away) != NIL)
  808.       send_message(object, sk_close);
  809.     else SysBeep(10);
  810.   }
  811. }
  812.  
  813. StGWWinInfoSize() { return(sizeof(StGWWinInfo)); }
  814.  
  815. StGWInitWinInfo(object)
  816.      char *object;
  817. {
  818.   StGWWinInfo *gwinfo = (StGWWinInfo *) StGWObWinInfo((LVAL) object);
  819.  
  820.   gwinfo->Object = (long) object;
  821.   gwinfo->idleOn = FALSE;
  822.   gwinfo->window = nil;
  823.   gwinfo->panel = nil;
  824.   gwinfo->FreeMem = nil;
  825.   gwinfo->backColor = 0;
  826.   gwinfo->drawColor = 1;
  827.   gwinfo->canvasWidth = 0;
  828.   gwinfo->canvasHeight = 0;
  829.   gwinfo->lineType = 0;
  830.   gwinfo->drawMode = 0;
  831.   gwinfo->lineWidth = 1;
  832.   gwinfo->RefCon = nil;
  833.   gwinfo->use_color = FALSE;
  834.   gwinfo->hasHscroll = FALSE;
  835.   gwinfo->hasVscroll = FALSE;
  836.   gwinfo->view_h = 0;
  837.   gwinfo->view_v = 0;
  838.   gwinfo->v_scroll_inc[0] = 1; gwinfo->v_scroll_inc[1] = 50;
  839.   gwinfo->h_scroll_inc[0] = 1; gwinfo->h_scroll_inc[1] = 50;
  840.   gwinfo->hscroll = nil;
  841.   gwinfo->vscroll = nil;
  842.   gwinfo->cursor = 0;
  843.   gwinfo->clipped = FALSE;
  844.   gwinfo->clip_left = 0;
  845.   gwinfo->clip_top = 0;
  846.   gwinfo->clip_width = 0;
  847.   gwinfo->clip_height = 0;
  848.   gwinfo->frame_width = -1;
  849.   gwinfo->frame_height = -1;
  850.   gwinfo->gc = nil;
  851.   gwinfo->erase_gc = nil;
  852.   gwinfo->xor_gc = nil;
  853.   gwinfo->initialized = FALSE;
  854.   gwinfo->go_away = TRUE;
  855.   gwinfo->has_menu_button = TRUE;
  856. }
  857.  
  858. Window IViewWindowNew(object, is_GW)
  859.      char *object;
  860.      int is_GW;
  861. {
  862.   char *title;
  863.   int left, top, width, height, go_away, w_height, w_width;
  864.   StGWWinInfo *gwinfo;
  865.   Window win;
  866.   Display *dpy = StX11Display();
  867.   int screen = StX11Screen();
  868.   XSetWindowAttributes winattr;
  869.  
  870.   StGWGetAllocInfo(object, &title, &left, &top, &width, &height, &go_away);
  871.   if (title == nil || strlen(title) <= 0) title = "Graph Window";
  872.   
  873.   /* adjust for scroll bars also */
  874.   gwinfo = (StGWWinInfo *) StGWObWinInfo((LVAL) object);
  875.   w_height = height + ClosePanelHeight();
  876.   if (gwinfo->hasHscroll) height += ScrollWidth;
  877.   if (gwinfo->hasVscroll) width += ScrollWidth;
  878.   w_width = width;
  879.   
  880.   win = XCreateSimpleWindow(dpy, RootWindow(dpy, screen),
  881.                 left, top, w_width, w_height, gw_border_width,
  882.                 GWBorderColor, WhitePixel(dpy, screen));
  883.   XSelectInput(dpy, win, StructureNotifyMask);
  884.   StX11SetStandardHints(dpy, win);
  885.   StX11SetWindowClass(dpy, win);
  886.   SetWRefCon(win, (long) gwinfo);
  887.   gwinfo->window = win;
  888.   gwinfo->frame_width = -1;
  889.   gwinfo->frame_height = -1;
  890.   gwinfo->go_away = go_away;
  891.   gwinfo->initialized = FALSE;
  892.  
  893.   XStoreName(dpy, win, title);
  894.   StX11SetNormalHints(dpy, win, left, top, w_width, w_height);
  895.  
  896.   left = 0;
  897.   top = ClosePanelHeight();
  898.   get_panel_size(gwinfo, w_width, w_height, &width, &height);
  899.   gwinfo->panel = XCreateSimpleWindow(dpy, win,
  900.                       left, top, width, height,
  901.                       gw_border_width,
  902.                       GWBorderColor, 
  903.                       get_color(gwinfo->backColor));
  904.   winattr.win_gravity = UnmapGravity;
  905.   XSelectInput(dpy, gwinfo->panel, 
  906.            ExposureMask | KeyPressMask | PointerMotionMask | 
  907.            ButtonPressMask | ButtonReleaseMask);
  908.   XChangeWindowAttributes(dpy, gwinfo->panel, CWWinGravity, &winattr);
  909.   if (! gwinfo->hasVscroll) gwinfo->canvasHeight = height;
  910.   if (! gwinfo->hasHscroll) gwinfo->canvasWidth = width;
  911.            
  912.   if (go_away) InstallCloseButton(win, object);
  913.   InstallMenuButton(win, object);
  914.   make_new_gc(gwinfo);
  915.  
  916.   InstallScrollBar(win, object, 0, top + height, width, ScrollWidth,
  917.            &gwinfo->hscroll, StX11ObScrollAction);
  918.   InstallScrollBar(win, object, left + width, top, ScrollWidth, height, 
  919.            &gwinfo->vscroll, StX11ObScrollAction);
  920.  
  921.   if (XSaveContext(dpy, win, EventContext, (XContext) frame_handler) != 0)
  922.     xlfail("could not install event handler");
  923.   if (XSaveContext(dpy, win, ObjectContext, (XContext) object) != 0)
  924.     xlfail("could not install object in window");
  925.   if (XSaveContext(dpy, gwinfo->panel, EventContext, (XContext) panel_handler)
  926.       != 0)
  927.     xlfail("could not install event handler");
  928.   if (XSaveContext(dpy, gwinfo->panel, ObjectContext, (XContext) object) != 0)
  929.     xlfail("could not install object in window");
  930.  
  931.   if (is_GW) set_iview_window_address(win, object);
  932.   else set_iview_address(win, object);
  933.  
  934.   XDefineCursor(dpy, win, ArrowCursor);
  935.   StGWSetCursor(gwinfo, gwinfo->cursor);
  936.  
  937.   /* Display (map) the panel and buttons windows */
  938.   XMapSubwindows(dpy, win);
  939.  
  940.   gwinfo->mouse_x = -1;
  941.   gwinfo->mouse_y = -1;
  942.   return(win);
  943. }
  944.  
  945. StX11SetWindowClass(dpy, win)
  946.      Display *dpy;
  947.      Window win;
  948. {
  949.   XClassHint class_hints;
  950.   
  951.   class_hints.res_name  = progname;
  952.   class_hints.res_class = "xlisp";
  953.   XSetClassHint(dpy, win, &class_hints);
  954. }
  955.  
  956. StX11SetNormalHints(dpy, win, left, top, width, height)
  957.      Display *dpy;
  958.      Window win;
  959.      int left, top, width, height;
  960. {
  961.   XSizeHints hints;
  962.  
  963.   hints.x = left;
  964.   hints.y = top;
  965.   hints.width = width;
  966.   hints.height = height;
  967.   hints.flags = USPosition | USSize;
  968.   XSetNormalHints(dpy, win, &hints);
  969. }
  970.  
  971. StX11SetTransientHint(dpy, win)
  972.      Display *dpy;
  973.      Window win;
  974. {
  975.   int screen = StX11Screen();
  976.  
  977.   XSetTransientForHint(dpy, win, RootWindow(dpy, screen));
  978. }
  979.  
  980. StX11SetStandardHints(dpy, w)
  981.      Display *dpy;
  982.      Window w;
  983. {
  984.   XWMHints hints;
  985.  
  986.   hints.input = TRUE;
  987.   hints.flags = InputHint;
  988.   XSetWMHints(dpy, w, &hints);
  989.  
  990.   /* 
  991.    * According to the ICCCM, placing the WM_DELETE_WINDOW atom in the
  992.    * protocols property tells a compliant window manager not to blast
  993.    * the application when a `delete window' action occurs (e.g. by
  994.    * choosing Quit from an olwm frame menu). Instead, a ClientMessage
  995.    * is generated. If the window is to have a go_away, the frame_handler
  996.    * sends the window the :close message in response to such an event.
  997.    */
  998.   XChangeProperty(dpy, w, wm_protocols, XA_ATOM, 32, PropModeReplace,
  999.           (unsigned char *) &wm_delete_window, 1);
  1000. }
  1001.  
  1002. /**************************************************************************/
  1003. /**                                                                      **/
  1004. /**                      Window Management Functions                     **/
  1005. /**                                                                      **/
  1006. /**************************************************************************/
  1007.  
  1008. StGWShowWindow(gwinfo)
  1009.      StGWWinInfo *gwinfo;
  1010. {
  1011.   Window w;
  1012.  
  1013.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  1014.   else {
  1015.     StShowWindow(w);
  1016.     if (! gwinfo->initialized) StGWInitialDraw(gwinfo);
  1017.   }
  1018. }
  1019.  
  1020. StGWRemove(gwinfo)
  1021.      StGWWinInfo *gwinfo;
  1022. {
  1023.   Window w;
  1024.   Display *dpy = StX11Display();
  1025.   
  1026.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  1027.   if (IViewInternalIsLinked(w)) IViewUnlinkWindow(w);
  1028.   StGWObDoClobber((LVAL) gwinfo->Object);
  1029.   if (gwinfo->FreeMem != nil) (*gwinfo->FreeMem)(w);
  1030.  
  1031.   if (XDeleteContext(dpy, w, EventContext) != 0)
  1032.     xlfail("cound not delete event context");
  1033.   if (XDeleteContext(dpy, w, ObjectContext) != 0)
  1034.     xlfail("cound not delete object context");
  1035.   if (XDeleteContext(dpy, gwinfo->panel, EventContext) != 0)
  1036.     xlfail("cound not delete event context");
  1037.   if (XDeleteContext(dpy, gwinfo->panel, ObjectContext) != 0)
  1038.     xlfail("cound not delete object context");
  1039.  
  1040.   if (gwinfo->gc != nil) XFreeGC(dpy, gwinfo->gc);
  1041.   gwinfo->gc = nil;
  1042.   if (gwinfo->erase_gc != nil) XFreeGC(dpy, gwinfo->erase_gc);
  1043.   gwinfo->erase_gc = nil;
  1044.   if (gwinfo->xor_gc != nil) XFreeGC(dpy, gwinfo->xor_gc);
  1045.   gwinfo->xor_gc = nil;
  1046.  
  1047.   DeleteScrollBar(gwinfo->vscroll);
  1048.   DeleteScrollBar(gwinfo->hscroll);
  1049.   gwinfo->vscroll = nil;
  1050.   gwinfo->hscroll = nil;
  1051.  
  1052.   gwinfo->window = nil;
  1053.   gwinfo->panel = nil;
  1054.   gwinfo->frame_width = -1;
  1055.   gwinfo->frame_height = -1;
  1056.   if (gwinfo->go_away) DeleteCloseButton(w);
  1057.   if (gwinfo->has_menu_button) DeleteMenuButton(w);
  1058.   XDestroyWindow(dpy, w);
  1059.   XFlush(dpy);
  1060.  
  1061.   if (XDeleteContext(dpy, w, WRefConContext) != 0)
  1062.     xlfail("could not delete WRefCon context");
  1063. }
  1064.  
  1065. StWSetLocation(w, left, top, frame)
  1066.      Window w;
  1067.      int left, top, frame;
  1068. {
  1069.   Display *dpy = StX11Display();
  1070.   XSizeHints hints;
  1071.   int width, height;
  1072.  
  1073.   /**** Should allow for borders. Assumes all windows have close ***/
  1074.   /**** panel (true except for modal dialogs)                    ***/
  1075.   if (! frame) top -= ClosePanelHeight();
  1076.   if (w != nil) {
  1077.     XMoveWindow(dpy, w, left, top);
  1078.     StWGetSize(w, &width, &height, TRUE);
  1079.     hints.x = left;
  1080.     hints.y = top;
  1081.     hints.width = width;
  1082.     hints.height = height;
  1083.     hints.flags = USPosition | USSize;
  1084.     XSetNormalHints(dpy, w, &hints);
  1085.     XFlush(dpy);
  1086.   }
  1087. }
  1088.  
  1089. StWGetLocation(w, left, top, frame)
  1090.      Window w;
  1091.      int *left, *top, frame;
  1092. {
  1093.   Display *dpy = StX11Display();
  1094.   Window root, child, *children, parent;
  1095.   int lx, ly, x, y, nch;
  1096.   unsigned int width, height, b_width, depth;
  1097.  
  1098.   /**** Should allow for borders. Assumes all windows have close ***/
  1099.   /**** panel (true except for madal dialogs)                    ***/
  1100.   if (w != nil) {
  1101.     XGetGeometry(dpy, w, &root, &lx, &ly, &width, &height, &b_width, &depth);
  1102.     XQueryTree(dpy, w, &root, &parent, &children, &nch);
  1103.     if (children != nil) XFree(children);
  1104.     XTranslateCoordinates(dpy, parent, root, lx, ly, &x, &y, &child);
  1105.     if (left != nil) *left = x;
  1106.     if (top != nil) *top = (frame) ? y : y + ClosePanelHeight();
  1107.   }
  1108.   else {
  1109.     if (left != nil) *left = 0;
  1110.     if (top != nil) *top = 0;
  1111.   }
  1112. }
  1113.  
  1114. StWSetSize(w, width, height, frame)
  1115.      Window w;
  1116.      int width, height;
  1117. {
  1118.   Display *dpy = StX11Display();
  1119.   StGWWinInfo *gwinfo;
  1120.   XSizeHints hints;
  1121.   int left, top;
  1122.  
  1123.   /**** Should allow for borders. Assumes all windows have close ***/
  1124.   /**** panel (true except for madal dialogs)                   ***/
  1125.   if ((gwinfo = (StGWWinInfo *) GetWRefCon(w)) != nil) {
  1126.     gwinfo->frame_width = -1;
  1127.     gwinfo->frame_height = -1;
  1128.   }
  1129.   if (! frame) height += ClosePanelHeight();
  1130.   if (w != nil) {
  1131.     XResizeWindow(dpy, w, width, height);
  1132.     StWGetLocation(w, &left, &top, TRUE);
  1133.     hints.x = left;
  1134.     hints.y = top;
  1135.     hints.width = width;
  1136.     hints.height = height;
  1137.     hints.flags = USPosition | USSize;
  1138.     XSetNormalHints(dpy, w, &hints);
  1139.     adjust_scroll_bars(gwinfo, TRUE);
  1140.     XFlush(dpy);
  1141.   }
  1142. }
  1143.  
  1144. StWGetSize(w, pwidth, pheight, frame)
  1145.      Window w;
  1146.      int *pwidth, *pheight;
  1147. {
  1148.   Display *dpy = StX11Display();
  1149.   Window root;
  1150.   int x, y;
  1151.   unsigned int width, height, b_width, depth;
  1152.   StGWWinInfo *gwinfo;
  1153.  
  1154.   /**** Should allow for borders. Assumes all windows have close ***/
  1155.   /**** panel (true except for madal dialogs)                    ***/
  1156.   if (w != nil) {
  1157.     if ((gwinfo = (StGWWinInfo *) GetWRefCon(w)) != nil
  1158.     && gwinfo->frame_width >= 0 && gwinfo->frame_height >= 0) {
  1159.       width = gwinfo->frame_width;
  1160.       height = gwinfo->frame_height;
  1161.       if (! frame) get_panel_size(gwinfo, width, height, &width, &height);
  1162.     }
  1163.     else {
  1164.       XGetGeometry(dpy, w, &root, &x, &y, &width, &height, &b_width, &depth);
  1165.       if (! frame) height -= ClosePanelHeight();
  1166.     }
  1167.     if (pwidth != nil) *pwidth = width;
  1168.     if (pheight != nil) *pheight = height;
  1169.   }
  1170.   else {
  1171.     if (pwidth != nil) *pwidth = 1;
  1172.     if (pheight != nil) *pheight = 1;
  1173.   }    
  1174. }
  1175.  
  1176. StGWSetSize(gwinfo, width, height, frame)
  1177.     StGWWinInfo *gwinfo;
  1178.     int width, height;
  1179. {
  1180.   Window w;
  1181.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  1182.   else StWSetSize(w, width, height, frame);
  1183. }
  1184.  
  1185. /**************************************************************************/
  1186. /**                                                                      **/
  1187. /**             Window State Access and Mutation Functions               **/
  1188. /**                                                                      **/
  1189. /**************************************************************************/
  1190.  
  1191. StGWUseColor(gwinfo)
  1192.      StGWWinInfo *gwinfo;
  1193. {
  1194.   if (gwinfo == nil) return(0);
  1195.   else return(gwinfo->use_color);
  1196. }
  1197.  
  1198. StGWCanvasWidth(gwinfo)
  1199.      StGWWinInfo *gwinfo;
  1200. {
  1201.   if (gwinfo == nil) return(0);
  1202.   else return(gwinfo->canvasWidth);
  1203. }
  1204.  
  1205. StGWCanvasHeight(gwinfo)
  1206.      StGWWinInfo *gwinfo;
  1207. {
  1208.   if (gwinfo == nil) return(0);
  1209.   else return(gwinfo->canvasHeight);
  1210. }
  1211.  
  1212. StGWLineType(gwinfo)
  1213.      StGWWinInfo *gwinfo;
  1214. {
  1215.   if (gwinfo == nil) return(0);
  1216.   else return(gwinfo->lineType);
  1217. }
  1218.  
  1219. StGWDrawMode(gwinfo)
  1220.      StGWWinInfo *gwinfo;
  1221. {
  1222.   if (gwinfo == nil) return(0);
  1223.   else return(gwinfo->drawMode);
  1224. }
  1225.  
  1226. StGWDrawColor(gwinfo)
  1227.      StGWWinInfo *gwinfo;
  1228. {
  1229.   if (gwinfo == nil) return(0);
  1230.   else return(gwinfo->drawColor);
  1231. }
  1232.  
  1233. StGWBackColor(gwinfo)
  1234.      StGWWinInfo *gwinfo;
  1235. {
  1236.   if (gwinfo == nil) return(0);
  1237.   else return(gwinfo->backColor);
  1238. }
  1239.  
  1240. StGWGetLineWidth(gwinfo, width)
  1241.      StGWWinInfo *gwinfo;
  1242.      int *width;
  1243. {
  1244.   if (gwinfo == nil) return;
  1245.   else if (width != nil) *width = gwinfo->lineWidth;
  1246. }
  1247.  
  1248. StGWGetViewRect(gwinfo, left, top, width, height)
  1249.      StGWWinInfo *gwinfo;
  1250.      int *left, *top, *width, *height;
  1251. {
  1252.   if (gwinfo == nil) return;
  1253.   if (gwinfo->window != nil) {
  1254.     StWGetSize(gwinfo->window, width, height, FALSE);
  1255.     if (left != nil) *left = gwinfo->view_h;
  1256.     if (top != nil) *top = gwinfo->view_v;
  1257.   }
  1258.   else {
  1259.     if (left != nil) *left = 0;
  1260.     if (top != nil) *top = 0;
  1261.     if (width != nil) *width = gwinfo->canvasWidth;
  1262.     if (height != nil) *height = gwinfo->canvasHeight;
  1263.   }
  1264. }
  1265.  
  1266. StGWIdleOn(gwinfo)
  1267.      StGWWinInfo *gwinfo;
  1268. {
  1269.   if (gwinfo == nil) return(FALSE);
  1270.   else return(gwinfo->idleOn);
  1271. }
  1272.  
  1273. StGWSetIdleOn(gwinfo, on)
  1274.         StGWWinInfo *gwinfo;
  1275.         int on;
  1276. {
  1277.   if (gwinfo != nil) gwinfo->idleOn = on;
  1278. }
  1279.  
  1280. StGWSetDrawMode(gwinfo, mode)
  1281.      StGWWinInfo *gwinfo;
  1282.      int mode;
  1283. {
  1284.   if (gwinfo != nil && gwinfo->drawMode != mode)
  1285.     gwinfo->drawMode = mode;
  1286. }
  1287.  
  1288. StGWSetLineWidth(gwinfo, width)
  1289.      StGWWinInfo *gwinfo;
  1290.      int width;
  1291. {
  1292.   XGCValues values;
  1293.  
  1294.   if (width < 0) width = 0;
  1295.   if (gwinfo != nil && gwinfo->lineWidth != width) {
  1296.     gwinfo->lineWidth = width;
  1297.     if (width == 1 && use_fast_lines) width = 0;
  1298.     values.line_width = width;
  1299.     if (gwinfo->gc != nil)
  1300.       XChangeGC(StX11Display(), gwinfo->gc, GCLineWidth, &values);
  1301.     if (gwinfo->xor_gc != nil)
  1302.       XChangeGC(StX11Display(), gwinfo->xor_gc, GCLineWidth, &values);
  1303.   }
  1304. }
  1305.  
  1306. StGWSetLineType(gwinfo, type)
  1307.      StGWWinInfo *gwinfo;
  1308.      int type;
  1309. {
  1310.   XGCValues values;
  1311.  
  1312.   if (gwinfo != nil && gwinfo->lineType != type) {
  1313.     gwinfo->lineType = type;
  1314.     values.line_style = (type == 0) ? LineSolid : LineOnOffDash;
  1315.     if (gwinfo->gc != nil)
  1316.       XChangeGC(StX11Display(), gwinfo->gc, GCLineStyle, &values);
  1317.     if (gwinfo->xor_gc != nil)
  1318.       XChangeGC(StX11Display(), gwinfo->xor_gc, GCLineStyle, &values);
  1319.   }
  1320. }
  1321.  
  1322. StGWSetDrawColor(gwinfo, index) 
  1323.      StGWWinInfo *gwinfo;
  1324.      int index;
  1325. {
  1326.   if (index < 0) index = 1;
  1327.   if (gwinfo != nil && gwinfo->drawColor != index) {
  1328.     gwinfo->drawColor = index;
  1329.     if (gwinfo->gc != nil)
  1330.       XSetForeground(StX11Display(), gwinfo->gc, get_color(gwinfo->drawColor));
  1331.   }
  1332. }
  1333.  
  1334. StGWSetBackColor(gwinfo, index)
  1335.      StGWWinInfo *gwinfo;
  1336.      int index;
  1337. {
  1338.   if (index < 0) index = 0;
  1339.   if (gwinfo != nil && gwinfo->backColor != index) {
  1340.     gwinfo->backColor = index;
  1341.     if (gwinfo->gc != nil)
  1342.       XSetBackground(StX11Display(), gwinfo->gc, get_color(gwinfo->backColor));
  1343.     if (gwinfo->xor_gc != nil)
  1344.       XSetBackground(StX11Display(), gwinfo->xor_gc, 
  1345.              xor_color(gwinfo->backColor));
  1346.     if (gwinfo->erase_gc != nil) {
  1347.       XSetForeground(StX11Display(), gwinfo->erase_gc, 
  1348.              get_color(gwinfo->backColor));
  1349.       XSetBackground(StX11Display(), gwinfo->erase_gc, 
  1350.              get_color(gwinfo->backColor));
  1351.     }
  1352.   }
  1353. }
  1354.  
  1355. StGWReverseColors(gwinfo)
  1356.      StGWWinInfo *gwinfo;
  1357. {
  1358.   ColorCode backColor, drawColor;
  1359.   
  1360.   if (gwinfo == nil) return;
  1361.   backColor = StGWBackColor(gwinfo);
  1362.   drawColor = StGWDrawColor(gwinfo);
  1363.   if (backColor != drawColor) {
  1364.     StGWSetBackColor(gwinfo, drawColor);
  1365.     StGWSetDrawColor(gwinfo, backColor);
  1366.     StGWObRedraw((LVAL) gwinfo->Object);
  1367.   }
  1368. }
  1369.       
  1370. StGWSetUseColor(gwinfo, use)
  1371.      StGWWinInfo *gwinfo;
  1372.      int use;
  1373. {
  1374.   if (gwinfo != nil && gwinfo->use_color != use) {
  1375.     gwinfo->use_color = use; 
  1376.     /*** do something with plane masks??? ***/
  1377.   }
  1378. }
  1379.  
  1380. /**************************************************************************/
  1381. /**                                                                      **/
  1382. /**                           Drawing Functions                          **/
  1383. /**                                                                      **/
  1384. /**************************************************************************/
  1385.  
  1386. static Drawable get_drawable(gwinfo)
  1387.      StGWWinInfo *gwinfo;
  1388. {
  1389.   if (gwinfo == nil) return(nil);
  1390.   else if (buffering) return(WorkPort);
  1391.   else return(gwinfo->panel);
  1392. }
  1393.  
  1394. # define is_allocated(gwinfo) ((gwinfo) != nil && (gwinfo)->gc != nil)
  1395. # define draw_gc(gwinfo) \
  1396.   ((gwinfo)->drawMode == 0) ? (gwinfo)->gc : (gwinfo)->xor_gc
  1397.  
  1398. #define NUMTEST 100
  1399.  
  1400. StGWDrawPoint(gwinfo, x, y)
  1401.      StGWWinInfo *gwinfo;
  1402.      int x, y;
  1403. {
  1404.   Display *dpy = StX11Display();
  1405.   XDrawPoint(dpy, get_drawable(gwinfo), draw_gc(gwinfo),
  1406.          x - gwinfo->view_v, y - gwinfo->view_v);
  1407. }
  1408.   
  1409. StGWDrawLine(gwinfo, x1, y1, x2, y2)
  1410.      StGWWinInfo *gwinfo;
  1411.      int x1, y1, x2, y2;
  1412. {
  1413.   Display *dpy = StX11Display();
  1414.  
  1415.   if (is_allocated(gwinfo))
  1416.     XDrawLine(dpy, get_drawable(gwinfo), draw_gc(gwinfo), 
  1417.           x1 - gwinfo->view_h, y1 - gwinfo->view_v, 
  1418.           x2 - gwinfo->view_h, y2 - gwinfo->view_v);
  1419. }
  1420.  
  1421. StGWFrameRect(gwinfo, left, top, width, height)
  1422.      StGWWinInfo *gwinfo;
  1423.      int left, top, width, height;
  1424. {
  1425.   Display *dpy = StX11Display();
  1426.  
  1427.   if (is_allocated(gwinfo))
  1428.     XDrawRectangle(dpy, get_drawable(gwinfo), draw_gc(gwinfo),
  1429.            left - gwinfo->view_h, top - gwinfo->view_v,
  1430.            width - gwinfo->lineWidth, height - gwinfo->lineWidth);
  1431. }
  1432.  
  1433. static fill_rect(gwinfo, left, top, width, height, which)
  1434.      StGWWinInfo *gwinfo;
  1435.      int left, top, width, height, which;
  1436. {
  1437.   Display *dpy = StX11Display();
  1438.  
  1439.   if (is_allocated(gwinfo))
  1440.     XFillRectangle(dpy, get_drawable(gwinfo), 
  1441.            (which == 'P') ? gwinfo->gc : gwinfo->erase_gc,
  1442.                    left - gwinfo->view_h, top - gwinfo->view_v,
  1443.            width, height);
  1444. }
  1445.  
  1446. StGWPaintRect(gwinfo, left, top, width, height)
  1447.      StGWWinInfo *gwinfo;
  1448.      int left, top, width, height;
  1449. {
  1450.   fill_rect(gwinfo, left, top, width, height, 'P');
  1451. }
  1452.  
  1453. StGWEraseRect(gwinfo, left, top, width, height)
  1454.      StGWWinInfo *gwinfo;
  1455.      int left, top, width, height;
  1456. {
  1457.   fill_rect(gwinfo, left, top, width, height, 'E');
  1458. }
  1459.  
  1460. static draw_arc(gwinfo, left, top, width, height, angle1, angle2)
  1461.      StGWWinInfo *gwinfo;
  1462.      int left, top, width, height, angle1, angle2;
  1463. {
  1464.   Display *dpy = StX11Display();
  1465.  
  1466.   if (is_allocated(gwinfo))
  1467.     XDrawArc(dpy, get_drawable(gwinfo), draw_gc(gwinfo),
  1468.              left - gwinfo->view_h, top - gwinfo->view_v,
  1469.              width - gwinfo->lineWidth, height - gwinfo->lineWidth,
  1470.              angle1, angle2);
  1471. }
  1472.  
  1473. static fill_arc(gwinfo, left, top, width, height, angle1, angle2, which)
  1474.      StGWWinInfo *gwinfo;
  1475.      int left, top, width, height, angle1, angle2, which;
  1476. {
  1477.   Display *dpy = StX11Display();
  1478.  
  1479.   if (is_allocated(gwinfo))
  1480.     XFillArc(dpy, get_drawable(gwinfo), 
  1481.          (which == 'P') ? gwinfo->gc : gwinfo->erase_gc,
  1482.          left - gwinfo->view_h, top - gwinfo->view_v,
  1483.          width, height, angle1, angle2);
  1484. }
  1485.  
  1486. StGWFrameOval(gwinfo, left, top, width, height)
  1487.      StGWWinInfo *gwinfo;
  1488.      int left, top, width, height;
  1489. {
  1490.   draw_arc(gwinfo, left, top, width, height, 0, 360 * 64);
  1491. }
  1492.  
  1493. StGWPaintOval(gwinfo, left, top, width, height)
  1494.      StGWWinInfo *gwinfo;
  1495.      int left, top, width, height;
  1496. {
  1497.   fill_arc(gwinfo, left, top, width, height, 0, 360 * 64, 'P');
  1498. }
  1499.  
  1500. StGWEraseOval(gwinfo, left, top, width, height)
  1501.      StGWWinInfo *gwinfo;
  1502.      int left, top, width, height;
  1503. {
  1504.   fill_arc(gwinfo, left, top, width, height, 0, 360 * 64, 'E');
  1505. }
  1506.  
  1507. StGWFrameArc(gwinfo, left, top, width, height, a1, a2)
  1508.      StGWWinInfo *gwinfo;
  1509.      int left, top, width, height;
  1510.      double a1, a2;
  1511. {
  1512.   draw_arc(gwinfo, left, top, width, height, (int) a1 * 64, (int) a2 * 64);
  1513. }
  1514.  
  1515. StGWPaintArc(gwinfo, left, top, width, height, a1, a2)
  1516.      StGWWinInfo *gwinfo;
  1517.      int left, top, width, height;
  1518.      double a1, a2;
  1519. {
  1520.   fill_arc(gwinfo, left, top, width, height, 
  1521.        (int) a1 * 64, (int) a2 * 64, 'P');
  1522. }
  1523.  
  1524. StGWEraseArc(gwinfo, left, top, width, height, a1, a2)
  1525.      StGWWinInfo *gwinfo;
  1526.      int left, top, width, height;
  1527.      double a1, a2;
  1528. {
  1529.   fill_arc(gwinfo, left, top, width, height,
  1530.            (int) a1 * 64, (int) a2 * 64, 'E');
  1531. }
  1532.  
  1533. StGWFramePoly(gwinfo, n, p, from_origin)
  1534.         StGWWinInfo *gwinfo;
  1535.         int n, from_origin;
  1536.         short *p;
  1537. {
  1538.   Display *dpy = StX11Display();
  1539.   int i;
  1540.  
  1541.   if (is_allocated(gwinfo) && n > 1 && p != nil) {
  1542.     if (from_origin)
  1543.       for (i = 0; i < n; i++) {
  1544.     p[2 * i] -= gwinfo->view_h;
  1545.     p[2 * i + 1] -= gwinfo->view_v;
  1546.       }
  1547.     else {
  1548.       p[0] -= gwinfo->view_h;
  1549.       p[i] -= gwinfo->view_v;
  1550.     }
  1551.     XDrawLines(dpy, get_drawable(gwinfo), draw_gc(gwinfo), p, n,
  1552.            (from_origin) ? CoordModeOrigin : CoordModePrevious);
  1553.   }
  1554. }
  1555.  
  1556. static fill_poly(gwinfo, n, p, from_origin, which)
  1557.         StGWWinInfo *gwinfo;
  1558.         int n, from_origin, which;
  1559.         short *p;
  1560. {
  1561.   Display *dpy = StX11Display();
  1562.   int i;
  1563.  
  1564.   if (is_allocated(gwinfo) && n > 1 && p != nil) {
  1565.     if (from_origin)
  1566.       for (i = 0; i < n; i++) {
  1567.     p[2 * i] -= gwinfo->view_h;
  1568.     p[2 * i + 1] -= gwinfo->view_v;
  1569.       }
  1570.     else {
  1571.       p[0] -= gwinfo->view_h;
  1572.       p[i] -= gwinfo->view_v;
  1573.     }
  1574.     XFillPolygon(dpy, get_drawable(gwinfo), 
  1575.          (which == 'P') ? gwinfo->gc : gwinfo->erase_gc,
  1576.          p, n, Complex, 
  1577.          (from_origin) ? CoordModeOrigin : CoordModePrevious);
  1578.   }  
  1579. }
  1580.  
  1581. StGWPaintPoly(gwinfo, n, p, from_origin)
  1582.         StGWWinInfo *gwinfo;
  1583.         int n, from_origin;
  1584.         short *p;
  1585. {
  1586.   fill_poly(gwinfo, n, p, from_origin, 'P');
  1587. }
  1588.  
  1589. StGWErasePoly(gwinfo, n, p, from_origin)
  1590.         StGWWinInfo *gwinfo;
  1591.         int n, from_origin;
  1592.         short *p;
  1593. {
  1594.   fill_poly(gwinfo, n, p, from_origin, 'E');
  1595. }
  1596.  
  1597. /**************************************************************************/
  1598. /**                                                                      **/
  1599. /**                            Text Functions                            **/
  1600. /**                                                                      **/
  1601. /**************************************************************************/
  1602.  
  1603. StGWTextAscent(gwinfo)
  1604.      StGWWinInfo *gwinfo;
  1605. {
  1606.   return(GraphFont->max_bounds.ascent);
  1607. }
  1608.  
  1609. StGWTextDescent(gwinfo)
  1610.      StGWWinInfo *gwinfo;
  1611. {
  1612.   return(GraphFont->max_bounds.descent);
  1613. }
  1614.  
  1615. StGWTextWidth(gwinfo, text)
  1616.      StGWWinInfo *gwinfo;
  1617.      char *text;
  1618. {
  1619.   return((text != nil) ? XTextWidth(GraphFont, text, strlen(text)) : 0);
  1620. }
  1621.  
  1622. StGWDrawString(gwinfo, s, x, y)
  1623.      StGWWinInfo *gwinfo;
  1624.      char *s;
  1625.      int x, y;
  1626. {
  1627.   Display *dpy = StX11Display();
  1628.   
  1629.   if (is_allocated(gwinfo) && s != nil) {
  1630.     XDrawString(dpy, get_drawable(gwinfo), draw_gc(gwinfo),
  1631.         x - gwinfo->view_h, y - gwinfo->view_v, s, strlen(s));
  1632.   }
  1633. }
  1634.  
  1635. static draw_char_up(gwinfo, myChar, x, y)
  1636.      StGWWinInfo *gwinfo;
  1637.      char myChar;
  1638.      int x, y;
  1639. {
  1640.   Display *dpy = StX11Display();
  1641.   int screen = StX11Screen();
  1642.   unsigned long bp = BlackPixel(dpy, screen);
  1643.   int ascent = GraphFont->max_bounds.ascent;
  1644.   int width = GraphFont->max_bounds.width;
  1645.   int height = GraphFont->max_bounds.ascent + GraphFont->max_bounds.descent;
  1646.   Drawable d;
  1647.   XImage *xi;
  1648.   int i, j;
  1649.   static XPoint *p = nil;
  1650.   int n;
  1651.  
  1652.   if (p == nil) p = (XPoint *) StCalloc(width * height, sizeof(XPoint));
  1653.  
  1654.   if (is_allocated(gwinfo)) {
  1655.     XFillRectangle(dpy, CharPM, CharEraseGC, 0, 0, width, height);
  1656.     XDrawString(dpy, CharPM, CharGC, 0, ascent, &myChar, 1);
  1657.     xi = XGetImage(dpy, CharPM, 0, 0, width, height, AllPlanes, ZPixmap);
  1658.     d = get_drawable(gwinfo);
  1659.     for (i = 0, n = 0; i < width; i++)
  1660.       for (j = 0; j < height; j++)
  1661.     if (bp == XGetPixel(xi, i, j)) {
  1662.       p[n].x = x - ascent + j;
  1663.       p[n].y = y - i;
  1664.       n++;
  1665.     }
  1666.     XDrawPoints(dpy, d, draw_gc(gwinfo), p, n, CoordModeOrigin);
  1667.     XDestroyImage(xi);
  1668.   }
  1669. }
  1670.  
  1671. StGWDrawText(gwinfo, text, x, y, h, v)
  1672.      StGWWinInfo *gwinfo;
  1673.      char *text;
  1674.      int x, y, h, v;
  1675. {
  1676.   int FontAscent, string_width;
  1677.  
  1678.   FontAscent = StGWTextAscent(gwinfo);
  1679.   string_width = StGWTextWidth(gwinfo, text);
  1680.  
  1681.   if (v == 1) y += FontAscent;
  1682.   if (h == 1) x -= string_width / 2;
  1683.   if (h == 2) x -= string_width;
  1684.  
  1685.   StGWDrawString(gwinfo, text, x, y);
  1686. }
  1687.  
  1688. StGWDrawStringUp(gwinfo, s, x, y)
  1689.      StGWWinInfo *gwinfo;
  1690.      char *s;
  1691.      int x, y;
  1692. {
  1693.   char str[2];
  1694.   int n;
  1695.   
  1696.   str[1] = '\0';
  1697.   
  1698.   if (s == nil || gwinfo == nil) return;
  1699.  
  1700.   x -= gwinfo->view_h;
  1701.   y -= gwinfo->view_v;
  1702.   for (n = strlen(s); n > 0; n--, s++) {
  1703.       draw_char_up(gwinfo, *s, x, y);
  1704.       str[0] = *s;
  1705.       y -= StGWTextWidth(gwinfo, str);
  1706.   }
  1707. }
  1708.  
  1709. StGWDrawTextUp(gwinfo, text, x, y, h, v)
  1710.      StGWWinInfo *gwinfo;
  1711.      char *text;
  1712.      int x, y, h, v;
  1713. {
  1714.   int FontAscent, string_width;
  1715.  
  1716.   FontAscent = StGWTextAscent(gwinfo);
  1717.   string_width = StGWTextWidth(gwinfo, text);
  1718.  
  1719.   if (v == 1) x -= FontAscent;
  1720.   if (h == 1) y += string_width / 2;
  1721.   if (h == 2) y += string_width;
  1722.  
  1723.   StGWDrawStringUp(gwinfo, text, x, y);
  1724. }
  1725.  
  1726. /**************************************************************************/
  1727. /**                                                                      **/
  1728. /**                           Symbol Functions                           **/
  1729. /**                                                                      **/
  1730. /**************************************************************************/
  1731.  
  1732. #define NUMSYMBOLS 18
  1733. #define NUMFASTSYMBOLS 18
  1734. #define SYMROWS 5
  1735.  
  1736. typedef struct {
  1737.   int left, top, width, height;
  1738.   char image[SYMROWS];
  1739.   Pixmap pm;
  1740.   long refcon;
  1741. } Symbol;
  1742.  
  1743. typedef struct {
  1744.   XPoint *black, *white;
  1745.   int nblack, nwhite, bleft, btop, wleft, wtop;
  1746. } FastSymbol;
  1747.  
  1748. static Symbol Symbols[] = {
  1749.   {0, 0, 1, 1, {0x01, 0x00, 0x00, 0x00, 0x00}, nil, 0L}, /* dot */
  1750.   {0, 0, 2, 1, {0x03, 0x00, 0x00, 0x00, 0x00}, nil, 0L}, /* double dot */
  1751.   {1, 1, 2, 2, {0x03, 0x01, 0x00, 0x00, 0x00}, nil, 0L}, /* triple dot */
  1752.   {1, 1, 2, 2, {0x03, 0x03, 0x00, 0x00, 0x00}, nil, 0L}, /* quadruple dot */
  1753.   {2, 2, 4, 4, {0x06, 0x09, 0x09, 0x06, 0x00}, nil, 0L}, /* disk */
  1754.   {2, 2, 4, 4, {0x06, 0x0f, 0x0f, 0x06, 0x00}, nil, 0L},
  1755.   {3, 3, 5, 5, {0x04, 0x0a, 0x11, 0x0a, 0x04}, nil, 0L}, /* diamond */
  1756.   {3, 3, 5, 5, {0x04, 0x0e, 0x1f, 0x0e, 0x04}, nil, 0L},
  1757.   {3, 3, 5, 5, {0x04, 0x04, 0x1f, 0x04, 0x04}, nil, 0L}, /* cross */
  1758.   {3, 3, 5, 5, {0x0a, 0x1b, 0x00, 0x1b, 0x0a}, nil, 0L},
  1759.   {2, 2, 4, 4, {0x0f, 0x09, 0x09, 0x0f, 0x00}, nil, 0L}, /* square */
  1760.   {2, 2, 4, 4, {0x0f, 0x0f, 0x0f, 0x0f, 0x0f}, nil, 0L},
  1761.   {3, 3, 5, 5, {0x0e, 0x11, 0x11, 0x0a, 0x04}, nil, 0L}, /* wedge 1 */
  1762.   {3, 3, 5, 5, {0x0e, 0x1f, 0x1f, 0x0e, 0x04}, nil, 0L},
  1763.   {3, 3, 5, 5, {0x04, 0x0a, 0x11, 0x11, 0x0e}, nil, 0L}, /* wedge 2 */
  1764.   {3, 3, 5, 5, {0x04, 0x0e, 0x1f, 0x1f, 0x0e}, nil, 0L},
  1765.   {3, 3, 5, 5, {0x11, 0x0a, 0x04, 0x0a, 0x11}, nil, 0L}, /* X */
  1766.   {3, 3, 5, 5, {0x1b, 0x1b, 0x04, 0x1b, 0x1b}, nil, 0L}
  1767. };
  1768.  
  1769. static FastSymbol fast_syms[] = {
  1770.   {nil, nil,  0,  0, 0, 0, 0, 0},
  1771.   {nil, nil,  0,  0, 0, 0, 0, 0},
  1772.   {nil, nil,  0,  0, 0, 0, 0, 0},
  1773.   {nil, nil,  0,  0, 0, 0, 0, 0},
  1774.   {nil, nil,  8,  4, 1, 0, 1, 1},         /* disk */
  1775.   {nil, nil, 12,  0, 1, 0, 1, 1},
  1776.   {nil, nil,  8,  5, 2, 0, 2, 1},         /* diamond */
  1777.   {nil, nil, 13,  0, 2, 0, 0, 0},
  1778.   {nil, nil,  9, 12, 2, 0, 1, 0},         /* cross */
  1779.   {nil, nil, 12,  9, 1, 0, 2, 0},
  1780.   {nil, nil, 12,  4, 0, 0, 1, 1},         /* square */
  1781.   {nil, nil, 16,  0, 0, 0, 0, 0},
  1782.   {nil, nil, 10,  7, 1, 0, 1, 1},         /* wedge 1 */
  1783.   {nil, nil, 17,  0, 1, 0, 0, 0},
  1784.   {nil, nil, 10,  7, 2, 0, 2, 1},         /* wedge 2 */
  1785.   {nil, nil, 17,  0, 2, 0, 0, 0},
  1786.   {nil, nil,  9,  8, 0, 0, 1, 0},         /* X */
  1787.   {nil, nil, 17,  0, 0, 0, 0, 0}
  1788. };
  1789.  
  1790. /* disk */
  1791. static XPoint sym4black[] = {{0, 0}, {1, 0}, {-2, 1}, {3, 0},
  1792.                    {-3, 1}, {3, 0}, {-2, 1}, {1, 0}};
  1793. static XPoint sym4white[] = {{0, 0}, {1, 0}, {-1, 1}, {1, 0}};
  1794. static XPoint sym5black[] = {{0, 0}, {1, 0},
  1795.                                 {-2, 1}, {1, 0}, {1, 0}, {1, 0},
  1796.                 {-3, 1}, {1, 0}, {1, 0}, {1, 0},
  1797.                 {-2, 1}, {1, 0}};
  1798. static XPoint *sym5white = nil;
  1799.  
  1800. /* diamond */
  1801. static XPoint sym6black[] = {{0, 0}, {-1, 1}, {2, 0}, {-3, 1}, 
  1802.                    {4, 0}, {-3, 1}, {2, 0}, {-1, 1}};
  1803. static XPoint sym6white[] = {{0, 0}, {-1, 1}, {1, 0}, {1, 0}, {-1, 1}};
  1804. static XPoint sym7black[] = {{0, 0}, {-1, 1}, {1, 0}, {1, 0},
  1805.                    {-3, 1},  {1, 0}, {1, 0}, {1, 0}, {1, 0},
  1806.                    {-3, 1}, {1, 0}, {1, 0}, {-1, 1}};
  1807. static XPoint *sym7white = nil;
  1808.  
  1809. /* cross */
  1810. static XPoint sym8black[] = {{0, 0}, {0, 1}, {-2, 1}, {1, 0}, {1, 0}, 
  1811.                    {1, 0}, {1, 0}, {-2, 1}, {0, 1}};
  1812. static XPoint sym8white[] = {{0, 0}, {2, 0}, {-3, 1}, {1, 0},
  1813.                    {2, 0}, {1, 0}, {-4, 2}, {1, 0},
  1814.                    {2, 0}, {1, 0}, {-3, 1}, {2, 0}};
  1815. static XPoint sym9black[] = {{0, 0}, {2, 0}, {-3, 1}, {1, 0},
  1816.                                {2, 0}, {1, 0}, {-4, 2}, {1, 0},
  1817.                                {2, 0}, {1, 0}, {-3, 1}, {2, 0}};
  1818. static XPoint sym9white[] = {{0, 0}, {0, 1}, {-2, 1}, {1, 0}, {1, 0},
  1819.                    {1, 0}, {1, 0}, {-2, 1}, {0, 1}};
  1820.  
  1821. /* square */
  1822. static XPoint sym10black[] = {{0, 0}, {1, 0}, {1, 0}, {1, 0},
  1823.                 {-3, 1}, {3, 0}, {-3, 1}, {3, 0},
  1824.                 {-3, 1}, {1, 0}, {1, 0}, {1, 0}};
  1825. static XPoint sym10white[] = {{0, 0}, {1, 0}, {-1, 1}, {1, 0}};
  1826. static XPoint sym11black[] = {{0, 0}, {1, 0}, {1, 0}, {1, 0},
  1827.                 {-3, 1}, {1, 0}, {1, 0}, {1, 0},
  1828.                 {-3, 1}, {1, 0}, {1, 0}, {1, 0},
  1829.                 {-3, 1}, {1, 0}, {1, 0}, {1, 0}};
  1830. static XPoint *sym11white = nil;
  1831.  
  1832. /* wedge 1 */
  1833. static XPoint sym12black[] = {{0, 0}, {1, 0}, {1, 0}, {-3, 1}, {4, 0},
  1834.                 {-4, 1}, {4, 0}, {-3, 1}, {2, 0}, {-1, 1}};
  1835. static XPoint sym12white[] = {{0, 0}, {1, 0}, {1, 0}, {-2, 1}, {1, 0},
  1836.                 {1, 0}, {-1, 1}};
  1837. static XPoint sym13black[] = {{0, 0}, {1, 0}, {1, 0}, {-3, 1}, {1, 0}, {1, 0},
  1838.                 {1, 0}, {1, 0}, {-4, 1}, {1, 0}, {1, 0},
  1839.                 {1, 0}, {1, 0}, {-3, 1},  {1, 0}, {1, 0},
  1840.                 {-1, 1}};
  1841. static XPoint *sym13white = nil;
  1842.  
  1843. /* wedge 2 */
  1844. static XPoint sym14black[] = {{0, 0}, {-1, 1}, {2, 0}, {-3, 1}, {4, 0},
  1845.                 {-4, 1}, {4, 0}, {-3, 1},  {1, 0}, {1, 0}};
  1846. static XPoint sym14white[] = {{0, 0}, {-1, 1}, {1, 0}, {1, 0}, {-2, 1},
  1847.                 {1, 0}, {1, 0}};
  1848. static XPoint sym15black[] = {{0, 0}, {-1, 1}, {1, 0}, {1, 0}, {-3, 1},
  1849.                 {1, 0}, {1, 0}, {1, 0}, {1, 0}, {-4, 1},
  1850.                 {1, 0}, {1, 0}, {1, 0}, {1, 0}, {-3, 1},
  1851.                 {1, 0}, {1, 0}};
  1852. static XPoint *sym15white = nil;
  1853.  
  1854. /* X */
  1855. static XPoint sym16black[] = {{0, 0}, {4, 0}, {-3, 1}, {2, 0}, {-1, 1}, 
  1856.                 {-1, 1}, {2, 0}, {-3, 1}, {4, 0}};
  1857. static XPoint sym16white[] = {{0, 0}, {2, 0}, {-3, 1}, {4, 0}, {-4, 2}, {4, 0},
  1858.                 {-3, 1}, {2, 0}};
  1859. static XPoint sym17black[] = {{0, 0}, {1, 0}, {2, 0}, {1, 0}, {-4, 1}, {1, 0},
  1860.                 {2, 0}, {1, 0}, {-2, 1}, {-2, 1}, {1, 0}, 
  1861.                 {2, 0}, {1, 0}, {-4, 1}, {1, 0}, {2, 0}, 
  1862.                 {1, 0}};
  1863. static XPoint *sym17white = nil;
  1864.  
  1865. static MakeSymbols()
  1866. {
  1867.   Display *dpy = StX11Display();
  1868.   int screen = StX11Screen();
  1869.   int i;
  1870.  
  1871.   for (i = 0; i < NUMSYMBOLS; i++)
  1872.     Symbols[i].pm = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  1873.                       Symbols[i].image,
  1874.                       Symbols[i].width,
  1875.                       Symbols[i].height);
  1876.   
  1877.   fast_syms[4].white = sym4white;
  1878.   fast_syms[4].black = sym4black;
  1879.   fast_syms[5].white = sym5white;
  1880.   fast_syms[5].black = sym5black;
  1881.  
  1882.   fast_syms[6].white = sym6white;
  1883.   fast_syms[6].black = sym6black;
  1884.   fast_syms[7].white = sym7white;
  1885.   fast_syms[7].black = sym7black;
  1886.  
  1887.   fast_syms[8].white = sym8white;
  1888.   fast_syms[8].black = sym8black;
  1889.   fast_syms[9].white = sym9white;
  1890.   fast_syms[9].black = sym9black;
  1891.  
  1892.   fast_syms[10].white = sym10white;
  1893.   fast_syms[10].black = sym10black;
  1894.   fast_syms[11].white = sym11white;
  1895.   fast_syms[11].black = sym11black;
  1896.  
  1897.   fast_syms[12].white = sym12white;
  1898.   fast_syms[12].black = sym12black;
  1899.   fast_syms[13].white = sym13white;
  1900.   fast_syms[13].black = sym13black;
  1901.  
  1902.   fast_syms[14].white = sym14white;
  1903.   fast_syms[14].black = sym14black;
  1904.   fast_syms[15].white = sym15white;
  1905.   fast_syms[15].black = sym15black;
  1906.  
  1907.   fast_syms[16].white = sym16white;
  1908.   fast_syms[16].black = sym16black;
  1909.   fast_syms[17].white = sym17white;
  1910.   fast_syms[17].black = sym17black;
  1911. }
  1912.  
  1913. StGWSetSymRefCon(index, rc)
  1914.     unsigned int index;
  1915.     long rc;
  1916. {
  1917.   if (index < NUMSYMBOLS) Symbols[index].refcon = rc;
  1918. }
  1919.  
  1920. long StGWGetSymRefCon(index)
  1921.     unsigned int index;
  1922. {    
  1923.   if (index < NUMSYMBOLS) return(Symbols[index].refcon);
  1924.   else return(nil);
  1925. }
  1926.  
  1927. StGWGetSymbolSize(sym, width, height)
  1928.     int sym, *width, *height;
  1929. {
  1930.   *width = Symbols[sym].width;
  1931.   *height = Symbols[sym].height;
  1932. }
  1933.  
  1934. static FreeSymbols()
  1935. {
  1936.   Display *dpy = StX11Display();
  1937.   int i;
  1938.  
  1939.   for (i = 0; i < NUMSYMBOLS; i++) {
  1940.     if (Symbols[i].pm != nil) XFreePixmap(dpy, Symbols[i].pm);
  1941.   }
  1942. }
  1943.  
  1944. StGWDrawSymbol(gwinfo, sym, x, y)
  1945.      StGWWinInfo *gwinfo;
  1946.      unsigned int sym;
  1947.      int x, y;
  1948. {
  1949.   Display *dpy = StX11Display();
  1950.   
  1951.   if (use_fast_symbols && (sym < NUMFASTSYMBOLS) && is_allocated(gwinfo)) {
  1952.     cheat_syms(dpy, gwinfo, sym, x, y);
  1953.     return;
  1954.   }
  1955.   if (sym < NUMSYMBOLS && Symbols[sym].pm != nil && is_allocated(gwinfo)) {
  1956.     XCopyPlane(dpy, Symbols[sym].pm, get_drawable(gwinfo), draw_gc(gwinfo),
  1957.            0, 0, Symbols[sym].width, Symbols[sym].height,
  1958.            x - gwinfo->view_h - Symbols[sym].left, 
  1959.            y - gwinfo->view_v - Symbols[sym].top,
  1960.            1);
  1961.   }
  1962. }
  1963.  
  1964. static cheat_syms(dpy, gwinfo, sym, x, y)
  1965.      Display *dpy;
  1966.      StGWWinInfo *gwinfo;
  1967.      unsigned sym;
  1968.      int x, y;
  1969. {
  1970.   Drawable d;
  1971.   GC black_gc, white_gc;
  1972.   register int left, top;
  1973.  
  1974.   d = get_drawable(gwinfo);
  1975.   black_gc = draw_gc(gwinfo);
  1976.   white_gc = gwinfo->erase_gc;
  1977.   left = x - gwinfo->view_h - Symbols[sym].left;
  1978.   top = y - gwinfo->view_v - Symbols[sym].top;
  1979.  
  1980.   switch (sym) {
  1981.   case 0:
  1982.     XDrawPoint(dpy, d, black_gc, left, top);
  1983.     break;
  1984.   case 1:
  1985.     XDrawPoint(dpy, d, black_gc, left, top);
  1986.     XDrawPoint(dpy, d, black_gc, left + 1, top);
  1987.     break;
  1988.   case 2:
  1989.     XDrawPoint(dpy, d, black_gc, left, top);
  1990.     XDrawPoint(dpy, d, black_gc, left + 1, top);
  1991.     XDrawPoint(dpy, d, black_gc, left, top + 1);
  1992.     break;
  1993.   case 3:
  1994.     XDrawPoint(dpy, d, black_gc, left, top);
  1995.     XDrawPoint(dpy, d, black_gc, left + 1, top);
  1996.     XDrawPoint(dpy, d, black_gc, left, top + 1);
  1997.     XDrawPoint(dpy, d, black_gc, left + 1, top + 1);
  1998.     break;
  1999.   default:
  2000.     if (fast_syms[sym].nblack > 0) {
  2001.       fast_syms[sym].black[0].x = left + fast_syms[sym].bleft;
  2002.       fast_syms[sym].black[0].y = top + fast_syms[sym].btop;
  2003.       XDrawPoints(dpy, d, black_gc, 
  2004.           fast_syms[sym].black, fast_syms[sym].nblack,
  2005.           CoordModePrevious);
  2006.     }
  2007.     if (fast_syms[sym].nwhite > 0) {
  2008.       fast_syms[sym].white[0].x = left + fast_syms[sym].wleft;
  2009.       fast_syms[sym].white[0].y = top + fast_syms[sym].wtop;
  2010.       XDrawPoints(dpy, d, white_gc, 
  2011.           fast_syms[sym].white, fast_syms[sym].nwhite,
  2012.           CoordModePrevious);
  2013.     }
  2014.   }
  2015. }
  2016.  
  2017. StGWReplaceSymbol(gwinfo, oldsym, newsym, x, y)
  2018.      StGWWinInfo *gwinfo;
  2019.      unsigned oldsym, newsym;
  2020.      int x, y;
  2021. {
  2022.   int oldwidth, oldheight, newwidth, newheight;
  2023.   
  2024.   if (oldsym >= NUMSYMBOLS || newsym >= NUMSYMBOLS) return;
  2025.   
  2026.   StGWGetSymbolSize(oldsym, &oldwidth, &oldheight);
  2027.   StGWGetSymbolSize(newsym, &newwidth, &newheight);
  2028.   if (oldwidth > newwidth || oldheight > newheight)
  2029.     StGWEraseRect(gwinfo, x - Symbols[oldsym].left, y - Symbols[oldsym].top,
  2030.           oldwidth, oldheight);
  2031.   StGWDrawSymbol(gwinfo, newsym, x, y);
  2032. }
  2033.  
  2034. /**************************************************************************/
  2035. /**                                                                      **/
  2036. /**                         Buffering Functions                          **/
  2037. /**                                                                      **/
  2038. /**************************************************************************/
  2039.  
  2040. static MakeWorkPort()
  2041. {
  2042.   Display *dpy = StX11Display();
  2043.   int screen = StX11Screen();
  2044.   int width, height;
  2045.  
  2046.   width = DisplayWidth(dpy, screen);
  2047.   height = DisplayHeight(dpy, screen);
  2048.   WorkPort = XCreatePixmap(dpy, RootWindow(dpy, screen),
  2049.                width, height, DefaultDepth(dpy, screen));
  2050.  
  2051.   /* it is not clear whether this is the proper error check */
  2052.   if (WorkPort == nil) {
  2053.     fprintf(stderr, "work port allocation failed");
  2054.     exit(-1);
  2055.   }
  2056. }
  2057.  
  2058. StGWStartBuffering(gwinfo)
  2059.      StGWWinInfo *gwinfo;
  2060. {
  2061.   buffering = TRUE;
  2062.   bufflevel++;
  2063. }
  2064.  
  2065. StGWBufferToScreen(gwinfo, left, top, width, height)
  2066.      StGWWinInfo *gwinfo;
  2067.      int left, top, width, height;
  2068. {
  2069.   Display *dpy = StX11Display();
  2070.   GC gc;
  2071.  
  2072.   if (is_allocated(gwinfo)) {
  2073.     if (bufflevel > 0) bufflevel--;
  2074.     if (bufflevel > 0) return;
  2075.     if (! buffering) return;
  2076.     buffering = FALSE;
  2077.     left -= gwinfo->view_h;
  2078.     top -= gwinfo->view_v;
  2079.     
  2080.     /* some checking in case rectangle is bad */
  2081.     if (left < 0) width += left;
  2082.     if (top < 0) height += height;
  2083.     if (width < 0 || height < 0) return;
  2084.  
  2085.     /* the following is used to deal with the cfb clipping bug in R3 */
  2086.     /* gc = gwinfo->gc */
  2087.     gc = copy_gc;
  2088.  
  2089.     XCopyArea(dpy, WorkPort, gwinfo->panel, gc, left, top,
  2090.           width, height, left, top);
  2091.  
  2092.     XSync(dpy, FALSE);
  2093.   }
  2094. }
  2095.  
  2096. StGWResetBuffer()
  2097. {
  2098.   bufflevel = 0;
  2099.   buffering = FALSE;  
  2100. }
  2101.  
  2102. StGWDumpImage(gwinfo, file, scale)
  2103.      StGWWinInfo *gwinfo;
  2104.      FILE *file;
  2105.      double scale;
  2106. {
  2107.   Display *dpy = StX11Display();
  2108.   int screen = StX11Screen();
  2109.   int left, top, width, height;
  2110.   static XImage *xi = nil;
  2111.   unsigned long bc;
  2112.   int back_bit, fore_bit;
  2113.   int x, y, padright;
  2114.  
  2115.   if (scale <= 0) scale = 1.0;
  2116.   if (gwinfo == nil || gwinfo->window == nil || file == nil) return;
  2117.  
  2118.   /* clear image left from possibly interrupted previous call */
  2119.   if (xi != nil) XDestroyImage(xi);
  2120.  
  2121.   /* get the image into the buffer */
  2122.   StGWGetViewRect(gwinfo, &left, &top, &width, &height);
  2123.   StGWStartBuffering(gwinfo);
  2124.   StGWObRedraw((LVAL) gwinfo->Object);
  2125.   StGWResetBuffer();
  2126.  
  2127.   /* compute foreground and backgroung bit colors. Use white background */
  2128.   /* if the screen background is white, black otherwise.                */
  2129.   bc = get_color(gwinfo->backColor);
  2130.   back_bit = (bc == WhitePixel(dpy, screen)) ? 0 : 1;
  2131.   fore_bit = ! back_bit;
  2132.  
  2133.   /* Compute padding to round cols up to the nearest multiple of 8. */
  2134.   padright = ((width + 7) / 8) * 8 - width;
  2135.  
  2136.   /* read in the image a line at a time and write it out.               */
  2137.   /* The line at a time stuff may slow things down a little (probably   */
  2138.   /* not a lot, though) but it avoids huge allocations, especially on   */
  2139.   /* color screens. Taking 10 lines at a time would probably be better  */
  2140.   /* but this is simpler and seems to work.                             */
  2141.   psputinit(file, width, height, scale);
  2142.   for (y = 0; y < height; y++) {
  2143.     xi = XGetImage(dpy, WorkPort, 0, y, width, 1, AllPlanes, ZPixmap);
  2144.     if (xi == nil) StPerror("Could not allocate image");
  2145.     for (x = 0; x < width; x++)
  2146.       psputbit((bc == XGetPixel(xi, x, 0)) ? back_bit : fore_bit);
  2147.     for (x = 0; x < padright; x++)
  2148.       psputbit( 0 );
  2149.     XDestroyImage(xi);
  2150.     xi = nil;
  2151.   }
  2152.   psputrest();
  2153. }
  2154.  
  2155. /**************************************************************************/
  2156. /**                                                                      **/
  2157. /**                           Color Functions                            **/
  2158. /**                                                                      **/
  2159. /**************************************************************************/
  2160.  
  2161. # define NumBasicColors 8
  2162. # define MULTIPLIER 62535
  2163.  
  2164. static int NumColors;
  2165.  
  2166. typedef struct {
  2167.   int allocated;
  2168.   unsigned long value;
  2169.   long refcon;
  2170. } ctab_entry;
  2171.  
  2172. static ctab_entry *ctable;
  2173.  
  2174. extern char *realloc();
  2175.  
  2176. static allocate_named_color(dpy, screen, index, name)
  2177.      Display *dpy;
  2178.      int screen;
  2179.      int index;
  2180.      char *name;
  2181. {
  2182.   Colormap cmap = DefaultColormap(dpy, screen);
  2183.   XColor exact, color;
  2184.  
  2185.   if (StScreenHasColor()
  2186.       && XAllocNamedColor(dpy, cmap, name, &exact, &color) != 0) {
  2187.     ctable[index].allocated = TRUE;
  2188.     ctable[index].value = color.pixel;
  2189.   }
  2190.   else {
  2191.     ctable[index].allocated = FALSE;
  2192.     ctable[index].value = BlackPixel(dpy, screen);
  2193.   }
  2194. }
  2195.   
  2196. static MakeColors()
  2197. {
  2198.   Display *dpy = StX11Display();
  2199.   int screen = StX11Screen();
  2200.  
  2201.   NumColors = NumBasicColors;
  2202.   ctable = (ctab_entry *) StCalloc(NumColors, sizeof(ctab_entry));
  2203.  
  2204.   ctable[0].value = WhitePixel(dpy, screen);
  2205.   ctable[1].value = BlackPixel(dpy, screen);
  2206.   allocate_named_color(dpy, screen, 2, "red");
  2207.   allocate_named_color(dpy, screen, 3, "green");
  2208.   allocate_named_color(dpy, screen, 4, "blue");
  2209.   allocate_named_color(dpy, screen, 5, "cyan");
  2210.   allocate_named_color(dpy, screen, 6, "magenta");
  2211.   allocate_named_color(dpy, screen, 7, "yellow");
  2212. }
  2213.  
  2214. static FreeColors()
  2215. {
  2216.   Display *dpy = StX11Display();
  2217.   int screen = StX11Screen();
  2218.   Colormap cmap = DefaultColormap(dpy, screen);
  2219.   int i;
  2220.  
  2221.   for (i = 2; i < NumColors; i++)
  2222.     if (ctable[i].allocated)
  2223.       XFreeColors(dpy, cmap, &ctable[i].value, 1, 0);
  2224. }
  2225.  
  2226. StGWSetColRefCon(index, rc)
  2227.     unsigned int index;
  2228.     long rc;
  2229. {
  2230.   if (index < NumColors) ctable[index].refcon = rc;
  2231. }
  2232.  
  2233. long StGWGetColRefCon(index)
  2234.     unsigned int index;
  2235. {    
  2236.   if (index < NumColors) return(ctable[index].refcon);
  2237.   else return(nil);
  2238. }
  2239.  
  2240. static unsigned long get_color(index)
  2241.      ColorCode index;
  2242. {
  2243.   if (0 <= index && index < NumColors) return(ctable[index].value);
  2244.   else return(ctable[1].value);
  2245. }
  2246.  
  2247. StGWMakeColor(red, green, blue, refcon)
  2248.         double red, green, blue;
  2249.         long refcon;
  2250. {
  2251.   Display *dpy = StX11Display();
  2252.   int screen = StX11Screen();
  2253.   Colormap cmap = DefaultColormap(dpy, screen);
  2254.   XColor color;
  2255.   int index;
  2256.   char *temp;
  2257.  
  2258.   if (! StScreenHasColor()) return(-1);
  2259.  
  2260.   for (index = 0;
  2261.        index < NumColors && StGWGetColRefCon(index) != nil;
  2262.        index++);
  2263.   if (index >= NumColors) {
  2264.     temp = realloc(ctable, (NumColors + 1) * sizeof(ctab_entry));
  2265.     if (temp == nil) return(-1);
  2266.     ctable = (ctab_entry *) temp;
  2267.     NumColors++;
  2268.     ctable[index].allocated = FALSE;
  2269.     ctable[index].refcon = nil;
  2270.     ctable[index].value = BlackPixel(dpy, screen);
  2271.   }
  2272.   color.red = MULTIPLIER * red;
  2273.   color.green = MULTIPLIER * green;
  2274.   color.blue = MULTIPLIER * blue;
  2275.   if (XAllocColor(dpy, cmap, &color) == 0) return(-1);
  2276.   else {
  2277.     ctable[index].allocated = TRUE;
  2278.     ctable[index].refcon = refcon;
  2279.     ctable[index].value = color.pixel;
  2280.     return(index);
  2281.   }
  2282. }
  2283.  
  2284. StGWFreeColor(index)
  2285.         unsigned int index;
  2286. {
  2287.   Display *dpy = StX11Display();
  2288.   int screen = StX11Screen();
  2289.   Colormap cmap = DefaultColormap(dpy, screen);
  2290.  
  2291.   if (index >= NumBasicColors && index < NumColors) {
  2292.     XFreeColors(dpy, cmap, &ctable[index].value, 1, 0);
  2293.     ctable[index].allocated = FALSE;
  2294.     ctable[index].refcon = nil;
  2295.     ctable[index].value = BlackPixel(dpy, screen);
  2296.   }
  2297.   else StPerror("can't free standard color");
  2298. }
  2299.  
  2300. LVAL xsparse_color()
  2301. {
  2302.   Display *dpy = StX11Display();
  2303.   int screen = StX11Screen();
  2304.   Colormap cmap = DefaultColormap(dpy, screen);
  2305.   char *string;
  2306.   XColor color;
  2307.   LVAL result;
  2308.  
  2309.   string = (char *) getstring(xlgastring());
  2310.   xllastarg();
  2311.  
  2312.   if (XParseColor(dpy, cmap, string, &color) == 0) result = NIL;
  2313.   else {
  2314.     xlsave1(result);
  2315.     result = consa(cvflonum((FLOTYPE) ((double) color.blue) / MULTIPLIER));
  2316.     result = cons(cvflonum((FLOTYPE) ((double) color.green) / MULTIPLIER),
  2317.           result);
  2318.     result = cons(cvflonum((FLOTYPE) ((double) color.red) / MULTIPLIER),
  2319.                   result);
  2320.     xlpop();
  2321.   }
  2322.   return(result);
  2323. }
  2324.  
  2325. /**************************************************************************/
  2326. /**                                                                      **/
  2327. /**                          Cursor Functions                            **/
  2328. /**                                                                      **/
  2329. /**************************************************************************/
  2330.  
  2331. #define NumBasicCursors 9
  2332. static int NumCursors;
  2333.  
  2334. typedef struct {
  2335.   Cursor curs;
  2336.   long refcon;
  2337. } cursor_entry;
  2338.  
  2339. static cursor_entry *curstab;
  2340.  
  2341. #define brush_width 16
  2342. #define brush_height 16
  2343. #define brush_x_hot 10
  2344. #define brush_y_hot 0
  2345. static char brush_bits[] = {
  2346.   0xfe, 0x0f, 0x54, 0x15, 0xa8, 0x2a, 0x08, 0x20, 0xf8, 0x3f, 0x08, 0x20,
  2347.   0x08, 0x20, 0x08, 0x20, 0xf8, 0x3f, 0x40, 0x04, 0x40, 0x04, 0x40, 0x04,
  2348.   0x40, 0x05, 0x40, 0x05, 0x40, 0x04, 0x80, 0x03};
  2349. #define brush_mask_width 16
  2350. #define brush_mask_height 16
  2351. static char brush_mask_bits[] = {
  2352.    0xfe, 0x0f, 0xfc, 0x1f, 0xf8, 0x3f, 0xf8, 0x3f, 0xf8, 0x3f, 0xf8, 0x3f,
  2353.    0xf8, 0x3f, 0xf8, 0x3f, 0xf8, 0x3f, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07,
  2354.    0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0x80, 0x03};
  2355. static Pixmap BrushPM, BrushMaskPM;
  2356.  
  2357. #define hand_width 16
  2358. #define hand_height 16
  2359. #define hand_x_hot 8
  2360. #define hand_y_hot 0
  2361. static char hand_bits[] = {
  2362.   0x00, 0x01, 0xc0, 0x06, 0xa0, 0x1a, 0xa0, 0x2a, 0xa0, 0x2a, 0xa0, 0x2a,
  2363.   0xa2, 0x2a, 0x25, 0x20, 0x29, 0x20, 0x32, 0x20, 0x04, 0x20, 0x08, 0x20,
  2364.   0x10, 0x20, 0x20, 0x20, 0xc0, 0x3f, 0x00, 0x00};
  2365. #define hand_mask_width 16
  2366. #define hand_mask_height 16
  2367. static char hand_mask_bits[] = {
  2368.   0x00, 0x01, 0xc0, 0x07, 0xe0, 0x1f, 0xe0, 0x3f, 0xe0, 0x3f, 0xe0, 0x3f,
  2369.   0xe2, 0x3f, 0xe7, 0x3f, 0xef, 0x3f, 0xfe, 0x3f, 0xfc, 0x3f, 0xf8, 0x3f,
  2370.   0xf0, 0x3f, 0xe0, 0x3f, 0xc0, 0x3f, 0x00, 0x00};
  2371. static Pixmap HandPM, HandMaskPM;
  2372.  
  2373. #define finger_width 16
  2374. #define finger_height 16
  2375. #define finger_x_hot 6
  2376. #define finger_y_hot 0
  2377. static char finger_bits[] = {
  2378.   0x40, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x00, 0xa0, 0x05, 0xa0, 0x1a,
  2379.   0xb0, 0x2a, 0x28, 0x20, 0x24, 0x20, 0x24, 0x20, 0x04, 0x20, 0x08, 0x20,
  2380.   0x10, 0x20, 0x20, 0x20, 0xc0, 0x3f, 0x00, 0x00};
  2381. #define finger_mask_width 16
  2382. #define finger_mask_height 16
  2383. static char finger_mask_bits[] = {
  2384.   0x40, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0xe0, 0x05, 0xe0, 0x1f,
  2385.   0xf0, 0x3f, 0xf8, 0x3f, 0xfc, 0x3f, 0xfc, 0x3f, 0xfc, 0x3f, 0xf8, 0x3f,
  2386.   0xf0, 0x3f, 0xe0, 0x3f, 0xc0, 0x3f, 0x00, 0x00};
  2387. static Pixmap FingerPM, FingerMaskPM;
  2388.  
  2389. static MakeGraphCursors()
  2390. {
  2391.   Display *dpy = StX11Display();
  2392.   int screen = StX11Screen();
  2393.   Colormap cmap = DefaultColormap(dpy, screen);
  2394.   XColor black, white;
  2395.  
  2396.   NumCursors = NumBasicCursors;
  2397.   curstab = (cursor_entry *) StCalloc(NumCursors, sizeof(cursor_entry));
  2398.  
  2399.   /*** should check for errors here ***/
  2400.   XParseColor(dpy, cmap, "white", &white);
  2401.   XParseColor(dpy, cmap, "black", &black);
  2402.  
  2403.   curstab[ARROW_CURSOR].curs = nil;
  2404.   curstab[WATCH_CURSOR].curs = XCreateFontCursor(dpy, XC_watch);
  2405.   curstab[CROSS_CURSOR].curs = XCreateFontCursor(dpy, XC_cross);
  2406.  
  2407.   BrushPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2408.                  brush_bits, brush_width, brush_height);
  2409.   BrushMaskPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2410.                       brush_mask_bits, 
  2411.                       brush_mask_width, brush_mask_height);
  2412.   curstab[BRUSH_CURSOR].curs = XCreatePixmapCursor(dpy, BrushPM, BrushMaskPM,
  2413.                            &black, &white,
  2414.                            brush_x_hot, brush_y_hot);
  2415.   XFreePixmap(dpy, BrushPM);
  2416.   XFreePixmap(dpy, BrushMaskPM);
  2417.  
  2418.   HandPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2419.                  hand_bits, hand_width, hand_height);
  2420.   HandMaskPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2421.                      hand_mask_bits, 
  2422.                      hand_mask_width, hand_mask_height);
  2423.   curstab[HAND_CURSOR].curs = XCreatePixmapCursor(dpy, HandPM, HandMaskPM,
  2424.                           &black, &white,
  2425.                           hand_x_hot, hand_y_hot);
  2426.   XFreePixmap(dpy, HandPM);
  2427.   XFreePixmap(dpy, HandMaskPM);
  2428.  
  2429.   FingerPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2430.                    finger_bits, finger_width, finger_height);
  2431.   FingerMaskPM = XCreateBitmapFromData(dpy, RootWindow(dpy, screen),
  2432.                        finger_mask_bits, 
  2433.                        finger_mask_width, finger_mask_height);
  2434.   curstab[FINGER_CURSOR].curs = 
  2435.     XCreatePixmapCursor(dpy, FingerPM, FingerMaskPM,
  2436.             &black, &white, finger_x_hot, finger_y_hot);
  2437.   XFreePixmap(dpy, FingerPM);
  2438.   XFreePixmap(dpy, FingerMaskPM);
  2439. }
  2440.  
  2441. static FreeGraphCursors()
  2442. {
  2443.   Display *dpy = StX11Display();
  2444.   int i;
  2445.  
  2446.   for (i = NumBasicCursors; i < NumCursors; i++)
  2447.     if (curstab[i].curs != nil)
  2448.       XFreeCursor(dpy, curstab[i].curs);
  2449. }
  2450.  
  2451. StGWSetCursRefCon(index, rc)
  2452.     unsigned int index;
  2453.     long rc;
  2454. {
  2455.   if (index < NumCursors) curstab[index].refcon = rc;
  2456. }
  2457.  
  2458. long StGWGetCursRefCon(index)
  2459.     unsigned int index;
  2460. {    
  2461.   if (index < NumCursors) return(curstab[index].refcon);
  2462.   else return(nil);
  2463. }
  2464.  
  2465. StGWSetCursor(gwinfo, cursor) 
  2466.      StGWWinInfo *gwinfo;
  2467.      int cursor;
  2468. {
  2469.   Display *dpy = StX11Display();
  2470.  
  2471.   if (cursor < 0) cursor = 0;
  2472.   if (gwinfo != nil) {
  2473.     gwinfo->cursor = cursor;
  2474.     if (gwinfo->panel != nil) {
  2475.       if (cursor < NumCursors && curstab[cursor].curs != nil)
  2476.     XDefineCursor(dpy, gwinfo->panel, curstab[cursor].curs);
  2477.       else XDefineCursor(dpy, gwinfo->panel, ArrowCursor);
  2478.     }
  2479.   }
  2480. }
  2481.  
  2482. StGWCursor(gwinfo)
  2483.     StGWWinInfo *gwinfo;
  2484. {
  2485.   if (gwinfo == nil) return(ARROW_CURSOR);
  2486.   return(gwinfo->cursor);
  2487. }
  2488.  
  2489. /* This routine is adapted from the code in Jef Poskanzer's pbm package. */
  2490. static Pixmap make_pixmap(width, height, image)
  2491.      int width, height;
  2492.      char *image;
  2493. {
  2494.   Display *dpy = StX11Display();
  2495.   int screen = StX11Screen();
  2496.   int row_bytes, i, j, bit, val;
  2497.   char *data;
  2498.   Pixmap pm;
  2499.  
  2500.   row_bytes = (width % 8 == 0) ? width / 8 : width / 8 + 1;
  2501.  
  2502.   if (height * row_bytes <= 0) return(nil);
  2503.   data = StCalloc(height * row_bytes, 1);
  2504.   if (data == nil) return(nil);
  2505.  
  2506.   for (i = 0; i < height; i++) {
  2507.     for (j = 0, val = 0; j < 8 * row_bytes; j++) {
  2508.       bit = (j < width) ? image[i * width + j] : 0;
  2509.       if (bit) val += 1 << (j % 8);
  2510.       if (j % 8 == 7) {
  2511.     data[i * row_bytes + j / 8] = val;
  2512.     val = 0;
  2513.       }
  2514.     }
  2515.   }
  2516.   pm = XCreateBitmapFromData(dpy, RootWindow(dpy, screen), 
  2517.                  data, width, height);
  2518.  
  2519.   StFree(data);
  2520.   return(pm);
  2521. }
  2522.   
  2523. StGWMakeCursor(n, image, mask, h, v, refcon)
  2524.      unsigned int n, h, v;
  2525.      char *image, *mask;
  2526.      long refcon;
  2527. {
  2528.   Display *dpy = StX11Display();
  2529.   int screen = StX11Screen();
  2530.   Colormap cmap = DefaultColormap(dpy, screen);
  2531.   int index;
  2532.   char *temp;
  2533.   Pixmap CursPM, MaskPM;
  2534.   XColor black, white;
  2535.  
  2536.   if (XParseColor(dpy, cmap, "white", &white) == 0) return(-1);
  2537.   if (XParseColor(dpy, cmap, "black", &black) == 0) return(-1);
  2538.  
  2539.   if (image == nil) return(-1);
  2540.   for (index = 0;
  2541.        index < NumCursors && StGWGetCursRefCon(index) != nil;
  2542.        index++);
  2543.     if (index >= NumCursors) {
  2544.     temp = realloc(curstab, (NumCursors + 1) * sizeof(cursor_entry));
  2545.     if (temp == nil) return(-1);
  2546.     curstab = (cursor_entry *) temp;
  2547.     NumCursors++;
  2548.     curstab[index].curs = nil;
  2549.     curstab[index].refcon = nil;
  2550.   }
  2551.   if (curstab[index].curs != nil) XFreeCursor(dpy, curstab[index].curs);
  2552.   
  2553.   if (h >= n) h = n - 1;
  2554.   if (v >= n) v = n - 1;
  2555.   CursPM = make_pixmap(n, n, image);
  2556.   MaskPM = (mask != nil) ? make_pixmap(n, n, image) : None;
  2557.  
  2558.   if (CursPM != nil && (mask == nil || MaskPM != nil)) {
  2559.     curstab[index].curs = XCreatePixmapCursor(dpy, CursPM, MaskPM,
  2560.                           &black, &white, h, v);
  2561.     curstab[index].refcon = refcon;
  2562.   }
  2563.   else index = -1;
  2564.  
  2565.   if (CursPM != nil) XFreePixmap(dpy, CursPM);
  2566.   if (mask != nil && MaskPM != nil) XFreePixmap(dpy, MaskPM);
  2567.  
  2568.   return(index);
  2569. }
  2570.  
  2571. StGWMakeResCursor(name, num, refcon)
  2572.      char *name;
  2573.      int num;
  2574.      long refcon;
  2575. { 
  2576.   Display *dpy = StX11Display();
  2577.   int screen = StX11Screen();
  2578.   Colormap cmap = DefaultColormap(dpy, screen);
  2579.   int index, width, height, v, h;
  2580.   char *temp, *mname;
  2581.   Pixmap CursPM, MaskPM;
  2582.   XColor black, white;
  2583.  
  2584.   for (index = 0;
  2585.        index < NumCursors && StGWGetCursRefCon(index) != nil;
  2586.        index++);
  2587.     if (index >= NumCursors) {
  2588.     temp = realloc(curstab, (NumCursors + 1) * sizeof(cursor_entry));
  2589.     if (temp == nil) return(-1);
  2590.     curstab = (cursor_entry *) temp;
  2591.     NumCursors++;
  2592.     curstab[index].curs = nil;
  2593.     curstab[index].refcon = nil;
  2594.   }
  2595.   if (curstab[index].curs != nil) XFreeCursor(dpy, curstab[index].curs);
  2596.   
  2597.   if (name != nil) {
  2598.     mname = (moreargs()) ? (char *) getstring(xlgastring()) : nil;
  2599.  
  2600.     if (XParseColor(dpy, cmap, "white", &white) == 0) return(-1);
  2601.     if (XParseColor(dpy, cmap, "black", &black) == 0) return(-1);
  2602.  
  2603.     if (XReadBitmapFile(dpy, RootWindow(dpy, screen), name, 
  2604.             &width, &height, &CursPM, &h, &v) != BitmapSuccess)
  2605.       xlfail("can't read bitmap file");
  2606.     if (h >= width) h = width - 1; if (h < 0) h = 0;
  2607.     if (v >= height) v = height - 1; if (v < 0) v = 0;
  2608.  
  2609.     if (mname != nil) {
  2610.       if (XReadBitmapFile(dpy, RootWindow(dpy, screen), mname,
  2611.               &width, &height, &MaskPM, 0, 0) != BitmapSuccess) {
  2612.     XFreePixmap(dpy, CursPM);
  2613.     xlfail("can't read mask file");
  2614.       }
  2615.     }
  2616.     else MaskPM = None;
  2617.  
  2618.     curstab[index].curs = XCreatePixmapCursor(dpy, CursPM, MaskPM,
  2619.                           &black, &white, h, v);
  2620.     curstab[index].refcon = refcon;
  2621.  
  2622.     XFreePixmap(dpy, CursPM);
  2623.     if (MaskPM != None) XFreePixmap(dpy, MaskPM);
  2624.   }
  2625.   else {
  2626.     if (num < 0 || num > 127) index = -1;
  2627.     else {
  2628.       curstab[index].curs = XCreateFontCursor(dpy, num);
  2629.       if (curstab[index].curs != nil) curstab[index].refcon = refcon;
  2630.       else index = -1;
  2631.     }
  2632.   }
  2633.   return(index);
  2634. }
  2635.  
  2636. StGWFreeCursor(index)
  2637.     unsigned int index;
  2638. {
  2639.   Display *dpy = StX11Display();
  2640.  
  2641.   if (index < NumCursors && index >= NumBasicCursors) {
  2642.     if (curstab[index].curs != nil)
  2643.       XFreeCursor(dpy, curstab[index].curs);
  2644.     curstab[index].curs = nil;
  2645.     curstab[index].refcon = nil;
  2646.   }
  2647.   else StPerror("can't free standard cursor");
  2648. }
  2649.  
  2650. LVAL xsbest_cursor_size()
  2651. {
  2652.   Display *dpy = StX11Display();
  2653.   int screen = StX11Screen();
  2654.   int width, height, rwidth, rheight;
  2655.  
  2656.   if (moreargs()) {
  2657.     width = getfixnum(xlgafixnum());
  2658.     height = getfixnum(xlgafixnum());
  2659.   }
  2660.   else {
  2661.     width = 16;
  2662.     height = 16;
  2663.   }
  2664.   xllastarg();
  2665.  
  2666.   XQueryBestCursor(dpy, RootWindow(dpy, screen), 
  2667.            width, height, &rwidth, &rheight);
  2668.   return(integer_list_2(rwidth, rheight));
  2669. }
  2670.  
  2671. LVAL xsbitmap_from_file() { xlfail("not supported"); }
  2672.  
  2673. /**************************************************************************/
  2674. /**                                                                      **/
  2675. /**                         Bitmap Functions                             **/
  2676. /**                                                                      **/
  2677. /**************************************************************************/
  2678.  
  2679. StGWDrawBitmap(gwinfo, left, top, width, height, image)
  2680.      StGWWinInfo *gwinfo;
  2681.      int left, top, width, height;
  2682.      char *image;
  2683. {
  2684.   Display *dpy = StX11Display();
  2685.   Pixmap PM;
  2686.  
  2687.   PM = make_pixmap(width, height, image);
  2688.   if (PM != nil) {
  2689.     XCopyPlane(dpy, PM, get_drawable(gwinfo), draw_gc(gwinfo),
  2690.                0, 0, width, height,
  2691.            left - gwinfo->view_h, top - gwinfo->view_v, 1);
  2692.     XFreePixmap(dpy, PM);
  2693.   }
  2694. }
  2695.  
  2696. /**************************************************************************/
  2697. /**                                                                      **/
  2698. /**                        Button Down Action                            **/
  2699. /**                                                                      **/
  2700. /**************************************************************************/
  2701.  
  2702. StX11PressButton()   { pointer_button_down = TRUE; }
  2703. StX11ReleaseButton() { pointer_button_down = FALSE; }
  2704. StX11ButtonIsDown()  { return(pointer_button_down); }
  2705.  
  2706. StGWWhileButtonDown(gwinfo, action, motionOnly)
  2707.     StGWWinInfo *gwinfo;
  2708.     int (*action)(), motionOnly;
  2709. {
  2710.   Display *dpy = StX11Display();
  2711.   XEvent report;
  2712.   Window win;
  2713.   int x, y;
  2714.   int moved;
  2715.  
  2716.   if (StX11ButtonIsDown() && is_allocated(gwinfo)) {
  2717.     win = gwinfo->window;
  2718.     while (! XCheckMaskEvent(dpy, ButtonReleaseMask, &report)) {
  2719.       x = gwinfo->mouse_x;
  2720.       y = gwinfo->mouse_y;
  2721.       while (XCheckMaskEvent(dpy, ButtonMotionMask, &report)) {
  2722.     x = report.xmotion.x + gwinfo->view_h;
  2723.     y = report.xmotion.y + gwinfo->view_v;
  2724.       }
  2725.       moved = (gwinfo->mouse_x != x || gwinfo->mouse_y != y) ? TRUE : FALSE;
  2726.       if (moved || ! motionOnly) {
  2727.     if (action != nil) (*action)(win, x, y);
  2728.     if (moved) XSync(dpy, FALSE);
  2729.       }
  2730.       gwinfo->mouse_x = x;
  2731.       gwinfo->mouse_y = y;
  2732.     }
  2733.   }
  2734. }
  2735.  
  2736. /**************************************************************************/
  2737. /**                                                                      **/
  2738. /**                          Clipping Functions                          **/
  2739. /**                                                                      **/
  2740. /**************************************************************************/
  2741.  
  2742. StGWGetClipRect(gwinfo, a, b, c, d) 
  2743.      StGWWinInfo *gwinfo;
  2744.      int *a, *b,*c, *d;
  2745. {
  2746.   if (gwinfo != nil) {
  2747.     if (a != nil) *a = gwinfo->clip_left;
  2748.     if (b != nil) *b = gwinfo->clip_top;
  2749.     if (c != nil) *c = gwinfo->clip_width;
  2750.     if (d != nil) *d = gwinfo->clip_height;
  2751.   }
  2752.   return(gwinfo->clipped);
  2753. }
  2754.  
  2755. static set_gc_clip_regions(gwinfo)
  2756.      StGWWinInfo *gwinfo;
  2757. {
  2758.   Display *dpy = StX11Display();
  2759.   XRectangle r;
  2760.   
  2761.   if (! do_clipping) return;
  2762.  
  2763.   if (gwinfo->clipped) {
  2764.     r.x = gwinfo->clip_left - gwinfo->view_h;
  2765.     r.y = gwinfo->clip_top - gwinfo->view_v;
  2766.     r.width = gwinfo->clip_width;
  2767.     r.height = gwinfo->clip_height;
  2768.     XSetClipRectangles(dpy, gwinfo->gc, 0, 0, &r, 1, Unsorted);
  2769.     XSetClipRectangles(dpy, gwinfo->erase_gc, 0, 0, &r, 1, Unsorted);
  2770.     XSetClipRectangles(dpy, gwinfo->xor_gc, 0, 0, &r, 1, Unsorted);
  2771.   }
  2772.   else {
  2773.     XSetClipMask(dpy, gwinfo->gc, None);
  2774.     XSetClipMask(dpy, gwinfo->erase_gc, None);
  2775.     XSetClipMask(dpy, gwinfo->xor_gc, None);
  2776.   }
  2777. }
  2778.  
  2779. StGWSetClipRect(gwinfo, clipped, left, top, width, height)
  2780.         StGWWinInfo *gwinfo;
  2781.         int clipped, left, top, width, height;
  2782. {
  2783.   if (gwinfo != nil) {
  2784.     gwinfo->clipped = clipped;
  2785.     if (clipped) {
  2786.       gwinfo->clip_left = left;
  2787.       gwinfo->clip_top = top;
  2788.       gwinfo->clip_width = width;
  2789.       gwinfo->clip_height = height;
  2790.     }
  2791.     if (gwinfo->gc != nil) set_gc_clip_regions(gwinfo);
  2792.   }
  2793. }
  2794.  
  2795. /**************************************************************************/
  2796. /**                                                                      **/
  2797. /**                             Idle Action                              **/
  2798. /**                                                                      **/
  2799. /**************************************************************************/
  2800.  
  2801. extern LVAL s_hardware_objects, s_hardware_address, xlenv, xlfenv;
  2802.  
  2803. #define IDLE_FREQUENCY 15
  2804.  
  2805. static is_allocated_graph(object)
  2806.      LVAL object;
  2807. {
  2808.   return(valid_iview_window_address(slot_value(object, s_hardware_address)));
  2809. }
  2810.  
  2811. static LVAL entry_object(entry)
  2812.      LVAL entry;
  2813. {
  2814.   if (consp(entry) && consp(cdr(entry)) && consp(cdr(cdr(entry))))
  2815.     return(car(cdr(cdr(entry))));
  2816.   else return(NIL);
  2817. }
  2818.  
  2819. static do_idle_actions()
  2820. {
  2821.   LVAL object, list = getvalue(s_hardware_objects);
  2822.   StGWWinInfo *gwinfo;
  2823.   static int count = IDLE_FREQUENCY;
  2824.  
  2825.   if (count > 0) count--;
  2826.   else {
  2827.     count = IDLE_FREQUENCY;
  2828.     for (; consp(list); list = cdr(list)) {
  2829.       object = entry_object(car(list));
  2830.       if (is_allocated_graph(object)) {
  2831.     gwinfo = (StGWWinInfo *) StGWObWinInfo(object);
  2832.     if (gwinfo != nil && gwinfo->idleOn) StGWObDoIdle(object);
  2833.       }
  2834.     }
  2835.     background_tasks();
  2836.   }
  2837. }
  2838.  
  2839. static background_tasks()
  2840. {
  2841.   LVAL task, queue, oldenv, oldfenv;
  2842.     
  2843.   queue = getvalue(xlenter("*EVENT-QUEUE*"));
  2844.   if (consp(queue)) {
  2845.   
  2846.     /* set the lexical environment to null */
  2847.     xlstkcheck(2);
  2848.     xlsave(oldenv);
  2849.     xlsave(oldfenv);
  2850.     oldenv = xlenv; xlenv = NIL;
  2851.     oldfenv = xlfenv; xlfenv = NIL;
  2852.  
  2853.     task = car(queue);
  2854.     setvalue(xlenter("*EVENT-QUEUE*"), cdr(queue));
  2855.     xleval(task);
  2856.  
  2857.     /* reset the environment */
  2858.     xlenv = oldenv;
  2859.     xlfenv = oldfenv;
  2860.     xlpopn(2);
  2861.   }
  2862. }
  2863.  
  2864. static any_idle_tasks()
  2865. {
  2866.   LVAL object, list = getvalue(s_hardware_objects);
  2867.   LVAL queue = getvalue(xlenter("*EVENT-QUEUE*"));
  2868.   StGWWinInfo *gwinfo;
  2869.  
  2870.   if (consp(queue)) return(TRUE);
  2871.  
  2872.   for (; consp(list); list = cdr(list)) {
  2873.     object = entry_object(car(list));
  2874.     if (is_allocated_graph(object)) {
  2875.       gwinfo = (StGWWinInfo *) StGWObWinInfo(object);
  2876.       if (gwinfo != nil && gwinfo->idleOn) return(TRUE);
  2877.     }
  2878.   }
  2879.   return(FALSE);
  2880. }  
  2881.  
  2882. /**************************************************************************/
  2883. /**                                                                      **/
  2884. /**                       Miscellaneous Functions                        **/
  2885. /**                                                                      **/
  2886. /**************************************************************************/
  2887.  
  2888. StGWSetRefCon(gwinfo, x)
  2889.      StGWWinInfo *gwinfo;
  2890.      long x;
  2891. {
  2892.   if (gwinfo == nil) return;
  2893.   else gwinfo->RefCon = x;
  2894. }
  2895.  
  2896. long StGWGetRefCon(gwinfo)
  2897.      StGWWinInfo *gwinfo;
  2898. {
  2899.   if (gwinfo == nil) return(nil);
  2900.   else return(gwinfo->RefCon);
  2901. }
  2902.  
  2903. StGWSetObject(gwinfo, x)
  2904.      StGWWinInfo *gwinfo;
  2905.      long x;
  2906. {
  2907.   if (gwinfo == nil) return;
  2908.   else gwinfo->Object = x;
  2909. }
  2910.  
  2911. long IViewWindowGetObject(w)
  2912.      Window w;
  2913. {
  2914.   StGWWinInfo *gwinfo = (StGWWinInfo *) GetWRefCon(w);
  2915.   if (gwinfo == nil) return(nil);
  2916.   else return(gwinfo->Object);
  2917. }
  2918.  
  2919. char *IViewWindowWinInfo(w)
  2920.     Window w;
  2921. {
  2922.   return((w != nil) ? (char *) GetWRefCon(w) : nil);
  2923. }
  2924.  
  2925. StGWSetFreeMem(gwinfo, FreeMem)
  2926.      StGWWinInfo *gwinfo;
  2927.      int (*FreeMem)();
  2928. {
  2929.   if (gwinfo == nil) return;
  2930.   else gwinfo->FreeMem = FreeMem;
  2931. }
  2932.  
  2933. StGWInitialDraw(gwinfo)
  2934.      StGWWinInfo *gwinfo;
  2935. {
  2936.   int width, height;
  2937.   XEvent report;
  2938.   Display *dpy = StX11Display();
  2939.  
  2940.   if (is_allocated(gwinfo) && ! gwinfo->initialized) {
  2941.     if (wait_for_map) {
  2942.       do {
  2943.     XNextEvent(dpy, &report);
  2944.     StProcessEvent(dpy, report);
  2945.       } while (report.xany.window != gwinfo->window
  2946.            || report.type != MapNotify);
  2947.     }
  2948.     StWGetSize(gwinfo->window, &width, &height, FALSE);
  2949.     if (! gwinfo->hasVscroll) gwinfo->canvasHeight = height;
  2950.     if (! gwinfo->hasHscroll) gwinfo->canvasWidth = width;
  2951.     adjust_scroll_bars(gwinfo, TRUE);
  2952.  
  2953.     StGWObResize((LVAL) gwinfo->Object);
  2954.     StGWObRedraw((LVAL) gwinfo->Object);
  2955.     gwinfo->initialized = TRUE;
  2956.   }
  2957. }
  2958.  
  2959. /**************************************************************************/
  2960. /**                                                                      **/
  2961. /**                       Window Scrolling Functions                     **/
  2962. /**                                                                      **/
  2963. /**************************************************************************/
  2964.  
  2965. static StX11ObScrollAction(object, s, which, x, y)
  2966.      LVAL object;
  2967.      Window s;
  2968.      int which, x, y;
  2969. {
  2970.   StGWWinInfo *gwinfo = (StGWWinInfo *) StGWObWinInfo(object);
  2971.   int is_h_scroll, val, max, page, width, height, pos, v, h, inc;
  2972.  
  2973.   if (is_allocated(gwinfo)) {
  2974.     StWGetSize(gwinfo->window, &width, &height, FALSE);
  2975.     is_h_scroll = (s == gwinfo->hscroll) ? TRUE : FALSE;
  2976.     val = (is_h_scroll) ? gwinfo->view_h : gwinfo->view_v;
  2977.     max = (is_h_scroll) ? gwinfo->canvasWidth : gwinfo->canvasHeight;
  2978.     page = (is_h_scroll) ? width : height;
  2979.     pos = (is_h_scroll) ? x : y;
  2980.     inc = (is_h_scroll) ? gwinfo->h_scroll_inc[1] : gwinfo->v_scroll_inc[1];
  2981.     
  2982.     switch (which) {
  2983.     case 'M':
  2984.       val = (page > 0) ? ((double) pos / (double) page) * max : val;
  2985.       break;
  2986.     case 'L': val += inc; break;
  2987.     case 'R': val -= inc; break;
  2988.     }
  2989.  
  2990.     h = (is_h_scroll) ? val : gwinfo->view_h;
  2991.     v = (is_h_scroll) ? gwinfo->view_v : val;
  2992.     StGWSetScroll(gwinfo, h, v, FALSE);
  2993.     StGWObRedraw(object);
  2994.   }
  2995. }
  2996.   
  2997. static adjust_scroll_bars(gwinfo, adjust_showing)
  2998.      StGWWinInfo *gwinfo;
  2999.      int adjust_showing;
  3000. {
  3001.   int width, height, top;
  3002.  
  3003.   StWGetSize(gwinfo->window, &width, &height, FALSE);
  3004.   
  3005.   if (adjust_showing) {
  3006.     top = ClosePanelHeight();
  3007.     if (gwinfo->hasVscroll)
  3008.       ShowScrollBar(gwinfo->vscroll, width, top, ScrollWidth, height);
  3009.     else HideScrollBar(gwinfo->vscroll);
  3010.     if (gwinfo->hasHscroll)
  3011.       ShowScrollBar(gwinfo->hscroll, 0, top + height, width, ScrollWidth);
  3012.     else HideScrollBar(gwinfo->hscroll);
  3013.   }
  3014.   
  3015.   gwinfo->view_h = max(0, min(gwinfo->view_h, gwinfo->canvasWidth - width));
  3016.   gwinfo->view_v = max(0, min(gwinfo->view_v, gwinfo->canvasHeight - height));
  3017.   if (gwinfo->hasVscroll) 
  3018.     AdjustScrollBar(gwinfo->vscroll, 
  3019.             gwinfo->view_v, height, gwinfo->canvasHeight);
  3020.   if (gwinfo->hasHscroll)
  3021.     AdjustScrollBar(gwinfo->hscroll,
  3022.                     gwinfo->view_h, width, gwinfo->canvasWidth);
  3023. }
  3024.  
  3025.      
  3026. static set_has_scroll(gwinfo, which, has, size)
  3027.         StGWWinInfo *gwinfo;
  3028.         int which, has, size;
  3029. {
  3030.   Display *dpy = StX11Display();
  3031.   int view_size, old_has, width, height;
  3032.  
  3033.   if (is_allocated(gwinfo)) {
  3034.     if (has && size <= 0) StPerror("size must be positive");
  3035.  
  3036.     old_has = (which == 'H') ? gwinfo->hasHscroll : gwinfo->hasVscroll;
  3037.     if (which == 'H') gwinfo->hasHscroll = has;
  3038.     else gwinfo->hasVscroll = has;
  3039.     
  3040.     if (has) {
  3041.       if (which == 'H') {
  3042.     if (! old_has) gwinfo->canvasHeight -= ScrollWidth;
  3043.     gwinfo->canvasWidth = size;
  3044.     StGWGetViewRect(gwinfo, nil, nil, &view_size, nil);
  3045.       }
  3046.       else {
  3047.     if (! old_has) gwinfo->canvasWidth -= ScrollWidth;
  3048.     gwinfo->canvasHeight = size;
  3049.     StGWGetViewRect(gwinfo, nil, nil, nil, &view_size);
  3050.       }
  3051.     }
  3052.     else {
  3053.       if (which == 'H') {
  3054.     StGWGetViewRect(gwinfo, nil, nil, &gwinfo->canvasWidth, nil);
  3055.     if (old_has) gwinfo->canvasHeight += ScrollWidth;
  3056.     StGWSetScroll(gwinfo, 0, gwinfo->view_v, TRUE);
  3057.       }
  3058.       else {
  3059.     StGWGetViewRect(gwinfo, nil, nil, nil, &gwinfo->canvasHeight);
  3060.     if (old_has) gwinfo->canvasWidth += ScrollWidth;
  3061.     StGWSetScroll(gwinfo, gwinfo->view_h, 0, TRUE);
  3062.       }
  3063.     }
  3064.     StWGetSize(gwinfo->window, &width, &height, FALSE);
  3065.     XResizeWindow(dpy, gwinfo->panel, width, height);
  3066.     XFlush(dpy);
  3067.     set_gc_clip_regions(gwinfo);
  3068.     adjust_scroll_bars(gwinfo, TRUE);
  3069.     StGWObResize((LVAL) gwinfo->Object);
  3070.   }
  3071. }
  3072.  
  3073. StGWSetHasHscroll(gwinfo, has, size)
  3074.     StGWWinInfo *gwinfo;
  3075.     int has, size;
  3076. {
  3077.   set_has_scroll(gwinfo, 'H', has, size);
  3078. }
  3079.  
  3080. StGWSetHasVscroll(gwinfo, has, size)
  3081.     StGWWinInfo *gwinfo;
  3082.     int has, size;
  3083. {
  3084.   set_has_scroll(gwinfo, 'V', has, size);
  3085. }
  3086.  
  3087. StGWHasHscroll(gwinfo)
  3088.     StGWWinInfo *gwinfo;
  3089. {
  3090.   if (is_allocated(gwinfo)) return(gwinfo->hasHscroll);
  3091.   else return(FALSE);
  3092. }
  3093.  
  3094. StGWHasVscroll(gwinfo)
  3095.     StGWWinInfo *gwinfo;
  3096. {
  3097.   if (is_allocated(gwinfo)) return(gwinfo->hasVscroll);
  3098.   else return(FALSE);
  3099. }
  3100.  
  3101. StGWSetScroll(gwinfo, h, v, move)
  3102.         StGWWinInfo *gwinfo;
  3103.         int h, v, move;
  3104. {
  3105.   if (is_allocated(gwinfo)) {
  3106.     gwinfo->view_h = (gwinfo->hasHscroll) ? h : 0;
  3107.     gwinfo->view_v = (gwinfo->hasVscroll) ? v : 0;
  3108.  
  3109.     set_gc_clip_regions(gwinfo);
  3110.     adjust_scroll_bars(gwinfo, FALSE);
  3111.   }
  3112. }
  3113.  
  3114. StGWGetScroll(gwinfo, h, v)
  3115.     StGWWinInfo *gwinfo;
  3116.     int *h, *v;
  3117. {
  3118.   
  3119.   if (is_allocated(gwinfo)) {
  3120.     if (h != nil) *h = gwinfo->view_h;
  3121.     if (v != nil) *v = gwinfo->view_v;
  3122.   }
  3123. }
  3124.  
  3125. StGWSetHscrollIncs(gwinfo, inc, pageInc)
  3126.     StGWWinInfo *gwinfo;
  3127.     int inc, pageInc;
  3128. {
  3129.   if (is_allocated(gwinfo)) {
  3130.     gwinfo->h_scroll_inc[0] = inc;
  3131.     gwinfo->h_scroll_inc[1] = pageInc;
  3132.   }
  3133. }
  3134.  
  3135. StGWGetHscrollIncs(gwinfo, inc, pageInc)
  3136.     StGWWinInfo *gwinfo;
  3137.     int *inc, *pageInc;
  3138. {
  3139.   if (is_allocated(gwinfo)) {
  3140.     if (inc != 0) *inc = gwinfo->h_scroll_inc[0];
  3141.     if (pageInc != 0) *pageInc = gwinfo->h_scroll_inc[1];
  3142.   }
  3143. }
  3144.  
  3145. StGWSetVscrollIncs(gwinfo, inc, pageInc)
  3146.     StGWWinInfo *gwinfo;
  3147.     int inc, pageInc;
  3148. {
  3149.   if (is_allocated(gwinfo)) {
  3150.     gwinfo->v_scroll_inc[0] = inc;
  3151.     gwinfo->v_scroll_inc[1] = pageInc;
  3152.   }
  3153. }
  3154.  
  3155. StGWGetVscrollIncs(gwinfo, inc, pageInc)
  3156.     StGWWinInfo *gwinfo;
  3157.     int *inc, *pageInc;
  3158. {
  3159.   if (is_allocated(gwinfo)) {
  3160.     if (inc != 0) *inc = gwinfo->v_scroll_inc[0];
  3161.     if (pageInc != 0) *pageInc = gwinfo->v_scroll_inc[1];
  3162.   }
  3163. }
  3164.  
  3165. #ifdef TODO
  3166. close/menu buttons at top of X modeless dialog and graphics windows
  3167. menus for Macintosh modeless dialogs/sun modeless dialogs
  3168. X protocol error trapping
  3169. #endif TODO
  3170.