home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d3xx / d386 / xlispstat.lha / XLispStat / src3.lzh / Mac / maciviewwindow3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-30  |  26.0 KB  |  1,036 lines
  1. #ifdef MPWC
  2. #include <Windows.h>
  3. #include <Menus.h>
  4. #include <ToolUtils.h>
  5. #include <Events.h>
  6. #include <Controls.h>
  7. #include <Fonts.h>
  8. #include <Memory.h>
  9. #include <Scrap.h>
  10. #else
  11. #include <WindowMgr.h>
  12. #include <MenuMgr.h>
  13. #include <ToolboxUtil.h>
  14. #include <EventMgr.h>
  15. #include <ControlMgr.h>
  16. #include <FontMgr.h>
  17. #include <ColorToolbox.h>
  18. #endif MPWC
  19.  
  20. #include "StGWWindow.h"
  21. #include "macgraphwindow.h"
  22. #include "stdio.h"
  23.  
  24. /**************************************************************************/
  25. /**                                                                      **/
  26. /**                            Global Variables                          **/
  27. /**                                                                      **/
  28. /**************************************************************************/
  29.  
  30. static CGrafPort CWP;
  31. static CGrafPtr CWorkPort;
  32. static GrafPort WP;
  33. static GrafPtr WorkPort;
  34. static char **WorkRowStarts;
  35. static int WorkPortWidth, WorkPortHeight;
  36.  
  37. static int buffering = FALSE;
  38. static int copying_to_clip = FALSE;
  39. static int bufflevel = 0;
  40.  
  41. static WindowPtr get_port() { return(thePort); }
  42.  
  43. static set_port(port)
  44.     WindowPtr port;
  45. {
  46.   if (port != thePort) SetPort(port);
  47. }
  48.  
  49. reset_clip_rect(gwinfo)
  50.     StGWWinInfo *gwinfo;
  51. {
  52.   WindowPtr w;
  53.   GrafPtr savePort;
  54.   Rect r;
  55.   
  56.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;  
  57.   GetPort(&savePort);
  58.   SetPort(w);
  59.   r = w->portRect;
  60.   r.right -= 15;
  61.   if (gwinfo->hasHscroll) r.bottom -= 15;
  62.   if (gwinfo->clipped) {
  63.     gwinfo->clip_rect.right = min(gwinfo->clip_rect.right, r.right);
  64.     gwinfo->clip_rect.bottom = min(gwinfo->clip_rect.bottom, r.bottom);
  65.     r = gwinfo->clip_rect;
  66.   }
  67.   ClipRect(&r);
  68.   if (buffering) {
  69.     SetDrawingPort(w);
  70.     ClipRect(&r);
  71.   }
  72.   SetPort(savePort);
  73. }
  74.  
  75. /**************************************************************************/
  76. /**                                                                      **/
  77. /**                       Initialization Functions                       **/
  78. /**                                                                      **/
  79. /**************************************************************************/
  80.  
  81. initialize_static_globals()
  82. {
  83.   int portSize;
  84.   long i;  /* long to force row start calculation to be done long */
  85.   
  86.   WorkPort = &WP;
  87.   OpenPort(WorkPort);
  88.   WorkPort->portBits = screenBits;
  89.   portSize = WorkPort->portBits.bounds.bottom 
  90.            - WorkPort->portBits.bounds.top;
  91.   WorkPort->portBits.baseAddr = 
  92.       StCalloc(portSize, WorkPort->portBits.rowBytes);
  93.   if (WorkPort->portBits.baseAddr == nil) {
  94.       StPerror("Buffer allocation failed");
  95.       exit(1);
  96.   }
  97.   WorkPortWidth = WorkPort->portBits.bounds.right 
  98.                 - WorkPort->portBits.bounds.left;
  99.   WorkPortHeight = WorkPort->portBits.bounds.bottom 
  100.                  - WorkPort->portBits.bounds.top;
  101.   WorkRowStarts = (char **) StCalloc(sizeof(char *), portSize);
  102.   for (i = 0; i < portSize; i++)
  103.     WorkRowStarts[i] = WorkPort->portBits.baseAddr
  104.                      + i * WorkPort->portBits.rowBytes;
  105.   MakeSymbols();
  106.  
  107.   CWorkPort = (CGrafPtr) WorkPort;
  108.   if (StScreenHasColor()) {
  109.     char *p;
  110.     Rect r;
  111.     struct row_bytes {
  112.       unsigned int flags : 3;
  113.       unsigned int data  : 13;
  114.     } *rowBytes;
  115.  
  116.     CWorkPort = &CWP;
  117.     OpenCPort(CWorkPort);
  118.     
  119.     r = (*CWorkPort->portPixMap)->bounds;
  120.     rowBytes = (struct row_bytes *) &(*CWorkPort->portPixMap)->rowBytes;
  121.     portSize = r.bottom - r.top;
  122.     
  123.     if (FreeMem() < portSize + 1000000) {
  124.       stdputstr("not enough memory to allocate color port\n");
  125.       CWorkPort = (CGrafPtr) WorkPort;
  126.     }
  127.     else {
  128.       HLock((Handle) *CWorkPort->portPixMap);
  129.       /* I do't know why I need this two-step business */
  130.       p = StCalloc(portSize, rowBytes->data);
  131.       (*CWorkPort->portPixMap)->baseAddr = p;
  132.       HUnlock((Handle) *CWorkPort->portPixMap);
  133.     }
  134.   }
  135. }
  136.  
  137. adjust_graph_workport(gwinfo)
  138.     StGWWinInfo *gwinfo;
  139. {
  140.   GrafPtr savePort, workPort;
  141.   WindowPtr w;
  142.   
  143.   if (buffering && gwinfo != nil && (w = gwinfo->window) != nil) {
  144.     workPort = (StGWUseColor(gwinfo)) ? (GrafPtr) CWorkPort : WorkPort;
  145.     GetPort(&savePort);
  146.     SetPort(workPort);
  147.     if (gwinfo->lineType != 0) PenPat(gray);
  148.     else PenPat(black);
  149.     PenMode(w->pnMode);
  150.     TextMode(w->txMode);
  151.     PenSize(w->pnSize.h, w->pnSize.h);
  152.     set_fore_color(gwinfo);
  153.     set_back_color(gwinfo);
  154.     SetPort(savePort);
  155.   }
  156. }
  157.  
  158. /**************************************************************************/
  159. /**                                                                      **/
  160. /**                  Line and Rectangle Drawing Functions                **/
  161. /**                                                                      **/
  162. /**************************************************************************/
  163.  
  164. static SetDrawingPort(w)
  165.      WindowPtr w;
  166. {
  167.   StGWWinInfo *gwinfo = (StGWWinInfo *) GetWRefCon(w);
  168.  
  169.   set_port((buffering) ? ((gwinfo->use_color) ? (GrafPtr) CWorkPort: WorkPort) : w);
  170. }
  171.  
  172. static draw_object(gwinfo, what, how, a, b, c, d)
  173.     StGWWinInfo *gwinfo;
  174.     int what, how, a, b, c, d;
  175. {
  176.   GrafPtr savePort;
  177.   Rect r;
  178.   WindowPtr w;
  179.   
  180.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  181.   savePort = get_port();
  182.   SetDrawingPort(w);
  183.     
  184.   switch (what) {
  185.   case 'L': MoveTo(a, b); LineTo(c, d); break;
  186.   case 'P': MoveTo(a, b); Line(0, 0); break;
  187.   case 'R':
  188.     SetRect(&r, a, b, a + c, b + d);
  189.     switch (how) {
  190.     case 'E': EraseRect(&r); break;
  191.     case 'F': FrameRect(&r); break;
  192.     case 'P': PaintRect(&r); break;
  193.     }
  194.     break;
  195.   case 'O':
  196.     SetRect(&r, a, b, a + c, b + d);
  197.     switch (how) {
  198.     case 'E': EraseOval(&r); break;
  199.     case 'F': FrameOval(&r); break;
  200.     case 'P': PaintOval(&r); break;
  201.     }
  202.     break;
  203.   }  
  204.   set_port(savePort);
  205. }
  206.  
  207. static draw_arc(gwinfo, how, a, b, c, d, angle1, angle2)
  208.     StGWWinInfo *gwinfo;
  209.     int how, a, b, c, d;
  210.     double angle1, angle2;
  211. {
  212.   GrafPtr savePort;
  213.   Rect r;
  214.   int a1, a2;
  215.   WindowPtr w;
  216.   
  217.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  218.   savePort = get_port();
  219.   SetDrawingPort(w);
  220.     
  221.   SetRect(&r, a, b, a + c, b + d);
  222.   a1 = 90 - angle1;
  223.   a2 = -angle2;
  224.   switch (how) {
  225.   case 'E': EraseArc(&r, a1, a2); break;
  226.   case 'F': FrameArc(&r, a1, a2); break;
  227.   case 'P': PaintArc(&r, a1, a2); break;
  228.   }
  229.   set_port(savePort);
  230. }
  231.  
  232. static draw_poly(gwinfo, how, n, p, from_origin)
  233.     StGWWinInfo *gwinfo;
  234.     int how, n, from_origin;
  235.     short *p;
  236. {
  237.   GrafPtr savePort;
  238.   int i;
  239.   WindowPtr w;
  240.   PolyHandle poly;
  241.   
  242.   if (gwinfo == nil || (w = gwinfo->window) == nil || n <= 0) return;
  243.   savePort = get_port();
  244.   SetDrawingPort(w);
  245.   
  246.   poly = OpenPoly();
  247.   MoveTo((int) p[0], (int) p[1]);
  248.   for (i = 1; i < n; i++) {
  249.     if (from_origin) LineTo((int) p[2 * i], (int) p[2 * i + 1]);
  250.     else Line((int) p[2 * i], (int) p[2 * i + 1]);
  251.   }
  252.   ClosePoly();
  253.   switch (how) {
  254.   case 'E': ErasePoly(poly); break;
  255.   case 'F': FramePoly(poly); break;
  256.   case 'P': PaintPoly(poly); break;
  257.   }
  258.   KillPoly(poly);
  259.   set_port(savePort);
  260. }    
  261.   
  262. StGWDrawLine(gwinfo, x1, y1, x2, y2)
  263.     StGWWinInfo *gwinfo;
  264.     int x1, y1, x2, y2;
  265. {
  266.   draw_object(gwinfo, 'L', '0', x1, y1, x2, y2);
  267. }
  268.  
  269. StGWDrawPoint(gwinfo, x, y)
  270.     StGWWinInfo *gwinfo;
  271.     int x, y;
  272. {
  273.   draw_object(gwinfo, 'P', '0', x, y, 0, 0);
  274. }
  275.  
  276. StGWEraseRect(gwinfo, left, top, width, height)
  277.     StGWWinInfo *gwinfo;
  278.     int left, top, width, height;
  279. {
  280.   draw_object(gwinfo, 'R', 'E', left, top, width, height);
  281. }
  282.  
  283. StGWFrameRect(gwinfo, left, top, width, height)
  284.     StGWWinInfo *gwinfo;
  285.     int left, top, width, height;
  286. {
  287.   draw_object(gwinfo, 'R', 'F', left, top, width, height);
  288. } 
  289.  
  290. StGWPaintRect(gwinfo, left, top, width, height)
  291.     StGWWinInfo *gwinfo;
  292.     int left, top, width, height;
  293. {
  294.   draw_object(gwinfo, 'R', 'P', left, top, width, height);
  295. }
  296.  
  297. StGWEraseOval(gwinfo, left, top, width, height)
  298.     StGWWinInfo *gwinfo;
  299.     int left, top, width, height;
  300. {
  301.   draw_object(gwinfo, 'O', 'E', left, top, width, height);
  302. }
  303.  
  304. StGWFrameOval(gwinfo, left, top, width, height)
  305.     StGWWinInfo *gwinfo;
  306.     int left, top, width, height;
  307. {
  308.   draw_object(gwinfo, 'O', 'F', left, top, width, height);
  309. }
  310.  
  311. StGWPaintOval(gwinfo, left, top, width, height)
  312.     StGWWinInfo *gwinfo;
  313.     int left, top, width, height;
  314. {
  315.   draw_object(gwinfo, 'O', 'P', left, top, width, height);
  316. }
  317.  
  318. StGWEraseArc(gwinfo, left, top, width, height, angle1, angle2)
  319.     StGWWinInfo *gwinfo;
  320.     int left, top, width, height;
  321.     double angle1, angle2;
  322. {
  323.   draw_arc(gwinfo, 'E', left, top, width, height, angle1, angle2);
  324. }
  325.  
  326. StGWFrameArc(gwinfo, left, top, width, height, angle1, angle2)
  327.     StGWWinInfo *gwinfo;
  328.     int left, top, width, height;
  329.     double angle1, angle2;
  330. {
  331.   draw_arc(gwinfo, 'F', left, top, width, height, angle1, angle2);
  332. }
  333.  
  334. StGWPaintArc(gwinfo, left, top, width, height, angle1, angle2)
  335.     StGWWinInfo *gwinfo;
  336.     int left, top, width, height;
  337.     double angle1, angle2;
  338. {
  339.   draw_arc(gwinfo, 'P', left, top, width, height, angle1, angle2);
  340. }
  341.  
  342. StGWErasePoly(gwinfo, n, p, from_origin)
  343.     StGWWinInfo *gwinfo;
  344.     int n, from_origin;
  345.     short *p;
  346. {
  347.   draw_poly(gwinfo, 'E', n, p, from_origin);
  348. }
  349.  
  350. StGWFramePoly(gwinfo, n, p, from_origin)
  351.     StGWWinInfo *gwinfo;
  352.     int n, from_origin;
  353.     short *p;
  354. {
  355.   draw_poly(gwinfo, 'F', n, p, from_origin);
  356. }
  357.  
  358. StGWPaintPoly(gwinfo, n, p, from_origin)
  359.     StGWWinInfo *gwinfo;
  360.     int n, from_origin;
  361.     short *p;
  362. {
  363.   draw_poly(gwinfo, 'P', n, p, from_origin);
  364. }
  365.  
  366. /**************************************************************************/
  367. /**                                                                      **/
  368. /**                            Text Functions                            **/
  369. /**                                                                      **/
  370. /**************************************************************************/
  371.  
  372. static text_size(gwinfo, ascent)
  373.     StGWWinInfo *gwinfo;
  374.     int ascent;
  375. {
  376.   WindowPtr w;
  377.   GrafPtr savePort;
  378.   FontInfo info;
  379.   
  380.   if (gwinfo == nil || (w = gwinfo->window) == nil)
  381.       w = (StGWUseColor(gwinfo)) ? (WindowPtr) CWorkPort : (WindowPtr) WorkPort;
  382.  
  383.   savePort = get_port();
  384.   set_port(w);
  385.     
  386.   GetFontInfo(&info);
  387.   
  388.   set_port(savePort);
  389.   return((ascent) ? info.ascent : info.descent);
  390. }
  391.  
  392. StGWTextAscent(gwinfo) StGWWinInfo *gwinfo;  { return(text_size(gwinfo, TRUE));  }
  393. StGWTextDescent(gwinfo) StGWWinInfo *gwinfo; { return(text_size(gwinfo, FALSE)); }
  394.  
  395. StGWTextWidth(gwinfo, text)
  396.     StGWWinInfo *gwinfo;
  397.     char *text;
  398. {
  399.   WindowPtr w;
  400.   GrafPtr savePort;
  401.   int string_width;
  402.   
  403.   if (gwinfo == nil || (w = gwinfo->window) == nil)
  404.       w = (StGWUseColor(gwinfo)) ? (WindowPtr) CWorkPort : (WindowPtr) WorkPort;
  405.  
  406.   savePort = get_port();
  407.   set_port(w);
  408.     
  409.   CtoPstr(text);
  410.   string_width = StringWidth(text);
  411.   PtoCstr(text);
  412.   
  413.   set_port(savePort);
  414.   return(string_width);
  415. }
  416.  
  417. StGWDrawString(gwinfo, s, x, y)
  418.     StGWWinInfo *gwinfo;
  419.     char *s;
  420.     int x, y;
  421. {
  422.   GrafPtr savePort;
  423.   WindowPtr w;
  424.   
  425.   if (s == nil || gwinfo == nil || (w = gwinfo->window) == nil) return;
  426.   
  427.   savePort = get_port();
  428.   SetDrawingPort(w);
  429.     
  430.   MoveTo(x, y);
  431.   CtoPstr(s);
  432.   DrawString(s);
  433.   PtoCstr(s);
  434.   
  435.   set_port(savePort);
  436. }
  437.  
  438. StGWDrawText(gwinfo, text, x, y, h, v)
  439.     StGWWinInfo *gwinfo;
  440.     char *text;
  441.     int x, y, h, v;
  442. {
  443.   int FontAscent, string_width;
  444.  
  445.   if (text == nil || gwinfo == nil) return;
  446.   
  447.   FontAscent = StGWTextAscent(gwinfo);
  448.   string_width = StGWTextWidth(gwinfo, text);
  449.  
  450.   if (v == 1) y += FontAscent;
  451.   if (h == 1) x -= string_width / 2;
  452.   if (h == 2) x -= string_width;
  453.  
  454.   StGWDrawString(gwinfo, text, x, y);
  455. }
  456.  
  457. static DrawCharUp(w, myChar, x, y)
  458.     WindowPtr w;
  459.     char myChar;
  460.     int x, y;
  461. {
  462.   static GrafPort gp;
  463.   static GrafPtr charPort;
  464.   static is_open = FALSE;
  465.   char myImage[32], myTarget[32];
  466.   BitMap myMap, saveBits;
  467.   GrafPtr savePort;
  468.   Rect r;
  469.   
  470.   register int i, j;
  471.   
  472.   savePort = get_port();
  473.   
  474.   if (! is_open) {
  475.     charPort = &gp;
  476.     OpenPort(charPort);
  477.     is_open = TRUE;
  478.   }
  479.   set_port(charPort);
  480.   
  481.   charPort->txFont = w->txFont;
  482.   charPort->txFace = w->txFace;
  483.   charPort->txMode = w->txMode;
  484.   charPort->txSize = w->txSize;
  485.   charPort->spExtra = w->spExtra;
  486.   
  487.   myMap.baseAddr = myImage;
  488.   myMap.rowBytes = 2;
  489.   SetRect(&myMap.bounds, 0, 0, 15, 15);
  490.   
  491.   for (i = 0; i < 32; i++) {
  492.     myImage[i] = '\0';
  493.     myTarget[i] = '\0';
  494.   }
  495.   
  496.   saveBits = charPort->portBits;
  497.   charPort->portBits = myMap;
  498.   MoveTo(3, 12);
  499.   DrawChar(myChar);
  500.   charPort->portBits = saveBits;
  501.   set_port(savePort);
  502.   
  503.   for (i = 0; i < 16; i++)
  504.     for (j = 0; j < 16; j++)
  505.       if (BitTst(myImage, 16 * i + j)) BitSet(myTarget, i + (16 - j) * 16);
  506.   
  507.   r = myMap.bounds;
  508.   OffsetRect(&r, x - 12, y + 3 - (r.bottom - r.top));
  509.   myMap.baseAddr = myTarget;
  510.   
  511.   SetDrawingPort(w);
  512.   CopyBits(&myMap, &thePort->portBits, &myMap.bounds,  &r, w->txMode, nil);
  513.   set_port(savePort);
  514. }
  515.  
  516. StGWDrawStringUp(gwinfo, s, x, y)
  517.     StGWWinInfo *gwinfo;
  518.     char *s;
  519.     int x, y;
  520. {
  521.   WindowPtr w;
  522.   char str[2];
  523.   int n;
  524.   
  525.   if (s == nil || gwinfo == nil || (w = gwinfo->window) == nil) return;
  526.   str[1] = '\0';
  527.   
  528.   for (n = strlen(s); n > 0; n--, s++) {
  529.       DrawCharUp(w, *s, x, y);
  530.       str[0] = *s;
  531.       y -= StGWTextWidth(gwinfo, str);
  532.   }
  533. }
  534.  
  535. StGWDrawTextUp(gwinfo, text, x, y, h, v)
  536.     StGWWinInfo *gwinfo;
  537.      char *text;
  538.      int x, y, h, v;
  539. {
  540.   int FontAscent, string_width;
  541.  
  542.   if (text == nil || gwinfo == nil) return;
  543.   
  544.   FontAscent = StGWTextAscent(gwinfo);
  545.   string_width = StGWTextWidth(gwinfo, text);
  546.  
  547.   if (v == 1) x += FontAscent;
  548.   if (h == 1) y += string_width / 2;
  549.   if (h == 2) y += string_width;
  550.  
  551.   StGWDrawStringUp(gwinfo, text, x, y);
  552. }
  553.  
  554. /**************************************************************************/
  555. /**                                                                      **/
  556. /**                           Symbol Functions                           **/
  557. /**                                                                      **/
  558. /**************************************************************************/
  559.  
  560. #define NUMSYMBOLS 18
  561. #define SYMROWS 5
  562.  
  563. typedef struct {
  564.   unsigned bit0 :1;
  565.   unsigned bit1 :1;
  566.   unsigned bit2 :1;
  567.   unsigned bit3 :1;
  568.   unsigned bit4 :1;
  569. } SymBits;
  570.  
  571. typedef struct {
  572.   BitMap map;
  573.   int left, top;
  574.   short image[SYMROWS];
  575.   long refcon;
  576. } Symbol;
  577.  
  578. static Symbol Symbols[NUMSYMBOLS];
  579.  
  580. StGWSetSymRefCon(index, rc)
  581.     unsigned int index;
  582.     long rc;
  583. {
  584.   if (index < NUMSYMBOLS) Symbols[index].refcon = rc;
  585. }
  586.  
  587. long StGWGetSymRefCon(index)
  588.     unsigned int index;
  589. {    
  590.   if (index < NUMSYMBOLS) return(Symbols[index].refcon);
  591.   else return(nil);
  592. }
  593.  
  594. static InitSymbol(sym, left, top, width, height)
  595.      int sym, left, top, width, height;
  596. {
  597.   SetRect(&Symbols[sym].map.bounds, 0, 0, width, height);
  598.   Symbols[sym].map.rowBytes = 2;
  599.   Symbols[sym].map.baseAddr = (Ptr) &Symbols[sym].image;
  600.   Symbols[sym].left = left;
  601.   Symbols[sym].top = top;
  602. }
  603.  
  604. StGWGetSymbolSize(sym, width, height)
  605.     int sym, *width, *height;
  606. {
  607.   *width = Symbols[sym].map.bounds.right;
  608.   *height = Symbols[sym].map.bounds.bottom;
  609. }
  610.  
  611. static SetSymbolData(sym, row, bit0, bit1, bit2, bit3, bit4)
  612.      int sym, row;
  613.      int bit0, bit1, bit2, bit3, bit4;
  614. {
  615.   SymBits *d = (SymBits *) &(Symbols[sym].image[row]);
  616.   d->bit0 = bit0;
  617.   d->bit1 = bit1;
  618.   d->bit2 = bit2;
  619.   d->bit3 = bit3;
  620.   d->bit4 = bit4;
  621. }
  622.  
  623. static MakeSymbols()
  624. {
  625.   InitSymbol(0, 0, 0, 2, 2);
  626.   SetSymbolData(0, 0, 1, 0, 0, 0, 0);
  627.   SetSymbolData(0, 1, 0, 0, 0, 0, 0);
  628.   SetSymbolData(0, 2, 0, 0, 0, 0, 0);
  629.   SetSymbolData(0, 3, 0, 0, 0, 0, 0);
  630.   SetSymbolData(0, 4, 0, 0, 0, 0, 0);
  631.  
  632.   InitSymbol(1, 0, 0, 2, 2);
  633.   SetSymbolData(1, 0, 1, 1, 0, 0, 0);
  634.   SetSymbolData(1, 1, 0, 0, 0, 0, 0);
  635.   SetSymbolData(1, 2, 0, 0, 0, 0, 0);
  636.   SetSymbolData(1, 3, 0, 0, 0, 0, 0);
  637.   SetSymbolData(1, 4, 0, 0, 0, 0, 0);
  638.  
  639.   InitSymbol(2, 0, 0, 2, 2);
  640.   SetSymbolData(2, 0, 1, 1, 0, 0, 0);
  641.   SetSymbolData(2, 1, 1, 0, 0, 0, 0);
  642.   SetSymbolData(2, 2, 0, 0, 0, 0, 0);
  643.   SetSymbolData(2, 3, 0, 0, 0, 0, 0);
  644.   SetSymbolData(2, 4, 0, 0, 0, 0, 0);
  645.  
  646.   InitSymbol(3, 0, 0, 2, 2);
  647.   SetSymbolData(3, 0, 1, 1, 0, 0, 0);
  648.   SetSymbolData(3, 1, 1, 1, 0, 0, 0);
  649.   SetSymbolData(3, 2, 0, 0, 0, 0, 0);
  650.   SetSymbolData(3, 3, 0, 0, 0, 0, 0);
  651.   SetSymbolData(3, 4, 0, 0, 0, 0, 0);
  652.  
  653.   InitSymbol(4, 2, 2, 4, 4);
  654.   SetSymbolData(4, 0, 0, 1, 1, 0, 0);
  655.   SetSymbolData(4, 1, 1, 0, 0, 1, 0);
  656.   SetSymbolData(4, 2, 1, 0, 0, 1, 0);
  657.   SetSymbolData(4, 3, 0, 1, 1, 0, 0);
  658.   SetSymbolData(4, 4, 0, 0, 0, 0, 0);
  659.  
  660.   InitSymbol(5, 2, 2, 4, 4);
  661.   SetSymbolData(5, 0, 0, 1, 1, 0, 0);
  662.   SetSymbolData(5, 1, 1, 1, 1, 1, 0);
  663.   SetSymbolData(5, 2, 1, 1, 1, 1, 0);
  664.   SetSymbolData(5, 3, 0, 1, 1, 0, 0);
  665.   SetSymbolData(5, 4, 0, 0, 0, 0, 0);
  666.  
  667.   InitSymbol(6, 3, 3, 5, 5);
  668.   SetSymbolData(6, 0, 0, 0, 1, 0, 0);
  669.   SetSymbolData(6, 1, 0, 1, 0, 1, 0);
  670.   SetSymbolData(6, 2, 1, 0, 0, 0, 1);
  671.   SetSymbolData(6, 3, 0, 1, 0, 1, 0);
  672.   SetSymbolData(6, 4, 0, 0, 1, 0, 0);
  673.  
  674.   InitSymbol(7, 3, 3, 5, 5);
  675.   SetSymbolData(7, 0, 0, 0, 1, 0, 0);
  676.   SetSymbolData(7, 1, 0, 1, 1, 1, 0);
  677.   SetSymbolData(7, 2, 1, 1, 1, 1, 1);
  678.   SetSymbolData(7, 3, 0, 1, 1, 1, 0);
  679.   SetSymbolData(7, 4, 0, 0, 1, 0, 0);
  680.  
  681.   InitSymbol(8, 3, 3, 5, 5);
  682.   SetSymbolData(8, 0, 0, 0, 1, 0, 0);
  683.   SetSymbolData(8, 1, 0, 0, 1, 0, 0);
  684.   SetSymbolData(8, 2, 1, 1, 1, 1, 1);
  685.   SetSymbolData(8, 3, 0, 0, 1, 0, 0);
  686.   SetSymbolData(8, 4, 0, 0, 1, 0, 0);
  687.  
  688.   InitSymbol(9, 3, 3, 5, 5);
  689.   SetSymbolData(9, 0, 0, 1, 1, 1, 0);
  690.   SetSymbolData(9, 1, 1, 0, 1, 0, 1);
  691.   SetSymbolData(9, 2, 1, 1, 1, 1, 1);
  692.   SetSymbolData(9, 3, 1, 0, 1, 0, 1);
  693.   SetSymbolData(9, 4, 0, 1, 1, 1, 0);
  694.  
  695.   InitSymbol(10, 2, 2, 4, 4);
  696.   SetSymbolData(10, 0, 1, 1, 1, 1, 0);
  697.   SetSymbolData(10, 1, 1, 0, 0, 1, 0);
  698.   SetSymbolData(10, 2, 1, 0, 0, 1, 0);
  699.   SetSymbolData(10, 3, 1, 1, 1, 1, 0);
  700.   SetSymbolData(10, 4, 0, 0, 0, 0, 0);
  701.  
  702.   InitSymbol(11, 2, 2, 4, 4);
  703.   SetSymbolData(11, 0, 1, 1, 1, 1, 0);
  704.   SetSymbolData(11, 1, 1, 1, 1, 1, 0);
  705.   SetSymbolData(11, 2, 1, 1, 1, 1, 0);
  706.   SetSymbolData(11, 3, 1, 1, 1, 1, 0);
  707.   SetSymbolData(11, 4, 0, 0, 0, 0, 0);
  708.  
  709.   InitSymbol(12, 3, 3, 5, 5);
  710.   SetSymbolData(12, 0, 0, 1, 1, 1, 0);
  711.   SetSymbolData(12, 1, 1, 0, 0, 0, 1);
  712.   SetSymbolData(12, 2, 1, 0, 0, 0, 1);
  713.   SetSymbolData(12, 3, 0, 1, 0, 1, 0);
  714.   SetSymbolData(12, 4, 0, 0, 1, 0, 0);
  715.  
  716.   InitSymbol(13, 3, 3, 5, 5);
  717.   SetSymbolData(13, 0, 0, 1, 1, 1, 0);
  718.   SetSymbolData(13, 1, 1, 1, 1, 1, 1);
  719.   SetSymbolData(13, 2, 1, 1, 1, 1, 1);
  720.   SetSymbolData(13, 3, 0, 1, 1, 1, 0);
  721.   SetSymbolData(13, 4, 0, 0, 1, 0, 0);
  722.  
  723.   InitSymbol(14, 3, 3, 5, 5);
  724.   SetSymbolData(14, 0, 0, 0, 1, 0, 0);
  725.   SetSymbolData(14, 1, 0, 1, 0, 1, 0);
  726.   SetSymbolData(14, 2, 1, 0, 0, 0, 1);
  727.   SetSymbolData(14, 3, 1, 0, 0, 0, 1);
  728.   SetSymbolData(14, 4, 0, 1, 1, 1, 0);
  729.  
  730.   InitSymbol(15, 3, 3, 5, 5);
  731.   SetSymbolData(15, 0, 0, 0, 1, 0, 0);
  732.   SetSymbolData(15, 1, 0, 1, 1, 1, 0);
  733.   SetSymbolData(15, 2, 1, 1, 1, 1, 1);
  734.   SetSymbolData(15, 3, 1, 1, 1, 1, 1);
  735.   SetSymbolData(15, 4, 0, 1, 1, 1, 0);
  736.  
  737.   InitSymbol(16, 3, 3, 5, 5);
  738.   SetSymbolData(16, 0, 1, 0, 0, 0, 1);
  739.   SetSymbolData(16, 1, 0, 1, 0, 1, 0);
  740.   SetSymbolData(16, 2, 0, 0, 1, 0, 0);
  741.   SetSymbolData(16, 3, 0, 1, 0, 1, 0);
  742.   SetSymbolData(16, 4, 1, 0, 0, 0, 1);
  743.  
  744.   InitSymbol(17, 3, 3, 5, 5);
  745.   SetSymbolData(17, 0, 1, 1, 0, 1, 1);
  746.   SetSymbolData(17, 1, 1, 1, 0, 1, 1);
  747.   SetSymbolData(17, 2, 0, 0, 1, 0, 0);
  748.   SetSymbolData(17, 3, 1, 1, 0, 1, 1);
  749.   SetSymbolData(17, 4, 1, 1, 0, 1, 1);
  750. }
  751.  
  752. StGWDrawSymbol(gwinfo, sym, x, y)
  753.     StGWWinInfo *gwinfo;
  754.     int sym, x, y;
  755. {
  756.   WindowPtr w;
  757.   GrafPtr savePort;
  758.   Rect r;
  759.   
  760.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  761.   
  762.   savePort = get_port();
  763.   SetDrawingPort(w);
  764.   
  765.   if (! copying_to_clip && buffering && sym < 4 && ! gwinfo->use_color) {
  766.     BufferMarkPoint(x - gwinfo->view_h, y - gwinfo->view_v, 
  767.                     sym, gwinfo->drawColor);
  768.     return;
  769.   }
  770.  
  771.   if (sym < 0 || sym >= NUMSYMBOLS) return;
  772.   x -= Symbols[sym].left;
  773.   y -= Symbols[sym].top;
  774.   r = Symbols[sym].map.bounds;
  775.   OffsetRect(&r, x, y);
  776.   
  777.   CopyBits(&Symbols[sym].map, &thePort->portBits,
  778.            &Symbols[sym].map.bounds, &r, gwinfo->symbolMode, nil);
  779.            
  780.   set_port(savePort);
  781. }
  782.  
  783. static BufferMarkPoint(x, y, sym, color)
  784.     unsigned x, y, sym, color;
  785. {
  786.   if (x >= WorkPortWidth || y >= WorkPortHeight) return;
  787.   if (color != 0) {
  788.     BitSet(WorkRowStarts[y], x);     if (sym == 0) return;
  789.     BitSet(WorkRowStarts[y], x + 1); if (sym == 1) return;
  790.     BitSet(WorkRowStarts[y + 1], x); if (sym == 2) return;
  791.     BitSet(WorkRowStarts[y + 1], x + 1);
  792.   }
  793.   else {
  794.     BitClr(WorkRowStarts[y], x);     if (sym == 0) return;
  795.     BitClr(WorkRowStarts[y], x + 1); if (sym == 1) return;
  796.     BitClr(WorkRowStarts[y + 1], x); if (sym == 2) return;
  797.     BitClr(WorkRowStarts[y + 1], x + 1);
  798.   }  
  799. }
  800.  
  801. StGWReplaceSymbol(gwinfo, oldsym, newsym, x, y)
  802.     StGWWinInfo *gwinfo;
  803.     unsigned oldsym, newsym;
  804.     int x, y;
  805. {
  806.   int oldwidth, oldheight, newwidth, newheight;
  807.   
  808.   if (oldsym >= NUMSYMBOLS || newsym >= NUMSYMBOLS) return;
  809.   
  810.   StGWGetSymbolSize(oldsym, &oldwidth, &oldheight);
  811.   StGWGetSymbolSize(newsym, &newwidth, &newheight);
  812.   if (oldwidth > newwidth || oldheight > newheight)
  813.     StGWEraseRect(gwinfo, x - Symbols[oldsym].left, y - Symbols[oldsym].top,
  814.                   oldwidth, oldheight);
  815.   StGWDrawSymbol(gwinfo, newsym, x, y);
  816. }
  817.  
  818. /**************************************************************************/
  819. /**                                                                      **/
  820. /**                           Bitmap Functions                           **/
  821. /**                                                                      **/
  822. /**************************************************************************/
  823.  
  824. static make_bitmap(width, height, image, pbm)
  825.     int width, height;
  826.     char *image;
  827.     BitMap *pbm;
  828. {
  829.   int i, j;
  830.   char *rowdata;
  831.   
  832.   pbm->rowBytes = 2 * ((width % 16 == 0) ? width / 16 : width / 16 + 1);
  833.   if (pbm->rowBytes * height <= 0) return(FALSE);
  834.   
  835.   pbm->baseAddr = StCalloc(pbm->rowBytes * height, 1);
  836.   if (pbm->baseAddr == nil) return(FALSE);
  837.   
  838.   for (i = 0; i < height; i++) {
  839.     rowdata = pbm->baseAddr + i * pbm->rowBytes;
  840.     for (j = 0; j < width; j++)
  841.       if (image[i * width + j] != 0) BitSet(rowdata, j);
  842.   }
  843.   pbm->bounds.left = 0; pbm->bounds.top = 0;
  844.   pbm->bounds.right = width; pbm->bounds.bottom = height;
  845.   return(TRUE);
  846. }
  847.  
  848. static free_bitmap(pbm)
  849.     BitMap *pbm;
  850. {
  851.   if (pbm->baseAddr != nil) StFree(pbm->baseAddr);
  852. }
  853.     
  854. StGWDrawBitmap(gwinfo, left, top, width, height, image)
  855.     StGWWinInfo *gwinfo;
  856.     int left, top, width, height;
  857.     char *image;
  858. {
  859.   WindowPtr w;
  860.   BitMap bm;
  861.   GrafPtr savePort;
  862.   Rect r;
  863.   
  864.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  865.   
  866.   savePort = get_port();
  867.   SetDrawingPort(w);
  868.   if (make_bitmap(width, height, image, &bm)) {
  869.     r = bm.bounds;
  870.     OffsetRect(&r, left, top);
  871.     CopyBits(&bm, &thePort->portBits, &bm.bounds, &r, gwinfo->symbolMode, nil);
  872.     free_bitmap(&bm);
  873.   }
  874.   set_port(savePort);
  875. }
  876.  
  877. /**************************************************************************/
  878. /**                                                                      **/
  879. /**                         Buffering Functions                          **/
  880. /**                                                                      **/
  881. /**************************************************************************/
  882.  
  883. StGWStartBuffering(gwinfo)
  884.     StGWWinInfo *gwinfo;
  885. {
  886.   WindowPtr w;
  887.   GrafPtr savePort;
  888.   Rect r;
  889.  
  890.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  891.   
  892.   bufflevel++;
  893.   if (buffering) return;
  894.   buffering = TRUE;
  895.   
  896.   GetPort(&savePort);
  897.   SetPort((StGWUseColor(gwinfo)) ? (GrafPtr) CWorkPort : WorkPort);
  898.  
  899.   set_fore_color(gwinfo);
  900.   set_back_color(gwinfo);
  901.   if (gwinfo->lineType != 0) PenPat(gray);
  902.   else PenPat(black);
  903.   
  904.   PenMode(w->pnMode);
  905.   TextFont(w->txFont);
  906.   TextFace(w->txFace);
  907.   TextMode(w->txMode);
  908.   TextSize(w->txSize);
  909.   SpaceExtra(w->spExtra);
  910.   SetOrigin(gwinfo->view_h, gwinfo->view_v);
  911.   r = w->portRect;
  912.   r.right -= 15;
  913.   if (gwinfo->hasHscroll) r.bottom -= 15;
  914.   ClipRect(&r);
  915.   CopyRgn(w->visRgn, thePort->visRgn);
  916.   CopyRgn(w->clipRgn, thePort->clipRgn);
  917.   SetPort(savePort);
  918. }
  919.  
  920. StGWBufferToScreen(gwinfo, left, top, width, height)
  921.     StGWWinInfo *gwinfo;
  922.     int left, top, width, height;
  923. {
  924.   WindowPtr w;
  925.   GrafPtr savePort, workPort;
  926.   Rect r;
  927.  
  928.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  929.   
  930.   if (bufflevel > 0) bufflevel--;
  931.   if (bufflevel > 0) return;
  932.   if (! buffering) return;
  933.   
  934.   buffering = FALSE;  
  935.   workPort = (StGWUseColor(gwinfo)) ? (GrafPtr) CWorkPort : WorkPort;
  936.   
  937.   GetPort(&savePort);
  938.   SetPort(w);
  939.   ForeColor(blackColor);
  940.   BackColor(whiteColor);
  941.   SetRect(&r, left, top, left + width, top + height);
  942.   if (SectRect(&r, &w->portRect, &r))
  943.     CopyBits(&workPort->portBits,&w->portBits, &r, &r, srcCopy, nil);
  944.   set_fore_color(gwinfo);
  945.   set_back_color(gwinfo);
  946.   SetPort(savePort);
  947. }
  948.  
  949. /**************************************************************************/
  950. /**                                                                      **/
  951. /**                         Miscelaneous Functions                       **/
  952. /**                                                                      **/
  953. /**************************************************************************/
  954.  
  955. extern char buf[];
  956.  
  957. StGWCopyToClip(gwinfo)
  958.     StGWWinInfo *gwinfo;
  959. {
  960.   make_picture(gwinfo, nil);
  961. }
  962.  
  963. StGWDumpImage(gwinfo, fname, scale)
  964.     StGWWinInfo *gwinfo;
  965.     char *fname;
  966.     double scale;
  967. {
  968.   make_picture(gwinfo, fname);
  969. }
  970.  
  971. static make_picture(gwinfo, fname)
  972.     StGWWinInfo *gwinfo;
  973.     char *fname;
  974. {
  975.   PicHandle pic;
  976.   Rect r;
  977.   long result, mytype;
  978.   GrafPtr savePort, workPort;
  979.   char *object;
  980.   WindowPtr w;
  981. /*  int vRefNum, i;
  982.   FILE *fptr; */
  983.   
  984.   if (gwinfo == nil || (w = gwinfo->window) == nil) return;
  985.   
  986.   object = (char *) StGWGetObject(gwinfo);
  987.   workPort = (StGWUseColor(gwinfo)) ? (GrafPtr) CWorkPort : WorkPort;
  988.  
  989.   StGWStartBuffering(gwinfo);
  990.   r = w->portRect;
  991.   r.right -= 15;
  992.   if (StGWHasHscroll(gwinfo)) r.bottom -= 15;
  993.   
  994.   copying_to_clip = TRUE;
  995.   GetPort(&savePort);
  996.   SetPort(workPort);
  997.   pic = OpenPicture(&r);
  998.   SetPort(savePort);
  999.   
  1000.   StGWObRedraw(object);
  1001.  
  1002.   GetPort(&savePort);
  1003.   SetPort(workPort);
  1004.   ClosePicture();
  1005.   SetPort(savePort);
  1006.   
  1007.   StGWBufferToScreen(gwinfo, 0, 0, 0, 0);
  1008.   
  1009.   if (fname == nil) {
  1010.     ZeroScrap();
  1011.     mytype = 'PICT';
  1012.     HLock((Handle) pic);
  1013.     result = PutScrap(GetHandleSize((Handle) pic), mytype, (Ptr) *pic);
  1014.     HUnlock((Handle) pic);
  1015.   }
  1016.   else {
  1017. /*    if ((fptr = fopen(fname, "w")) == nil)
  1018.       xlfail("can't open file");
  1019.     GetPort(&savePort);
  1020.     SetPort(WorkPort);
  1021.     DrawPicture(pic, &r);
  1022.     SetPort(savePort);
  1023.     writemacp(fptr, WorkRowStarts, r.right - r.left, r.bottom - r.top);
  1024.     xlfail("operation not supported");
  1025.     spoolpict(fname, pic, WorkPort);*/
  1026.   }
  1027.   KillPicture(pic);
  1028.   copying_to_clip = FALSE;
  1029. }
  1030.  
  1031. StGWResetBuffer()
  1032. {
  1033.   copying_to_clip = FALSE;
  1034.   bufflevel = 0;
  1035.   buffering = FALSE;  
  1036. }