Return to bitmap.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / bitmap

Annotation of 43BSD/contrib/X/bitmap/bitmap.c, revision 1.1

1.1     ! root        1: #include <X/mit-copyright.h>
        !             2: 
        !             3: /* Copyright 1985, Massachusetts Institute of Technology */
        !             4: 
        !             5: #ifndef lint
        !             6: static char *rcsid_bitmap_c = "$Header: bitmap.c,v 10.7 86/02/01 15:18:05 tony Rel $";
        !             7: #endif
        !             8: 
        !             9: #include <errno.h>
        !            10: #include <stdio.h>
        !            11: #include <X/Xlib.h>
        !            12: #include <sys/types.h>
        !            13: 
        !            14: #include "../cursors/cross.cursor"
        !            15: #include "../cursors/cross_mask.cursor"
        !            16: #include "../cursors/ul_angle.cursor"
        !            17: #include "../cursors/ul_angle_mask.cursor"
        !            18: #include "../cursors/lr_angle.cursor"
        !            19: #include "../cursors/lr_angle_mask.cursor"
        !            20: #include "../cursors/dot.cursor"
        !            21: #include "../cursors/dot_mask.cursor"
        !            22: 
        !            23: #define TOP_MARGIN 10
        !            24: #define LEFT_MARGIN 10
        !            25: #define BOTTOM_MARGIN 10
        !            26: #define AROUND_RASTER_MARGIN 20
        !            27: #define GRID_TO_COMMAND_MARGIN 5
        !            28: #define RIGHT_MARGIN 5
        !            29: 
        !            30: #define MIN_SQUARE_SIZE 8
        !            31: #define DEFAULT_SQUARE_SIZE 13
        !            32: 
        !            33: #define bit int
        !            34: #define boolean int
        !            35: #define TRUE 1
        !            36: #define FALSE 0
        !            37: #define OUT_OF_RANGE 10000
        !            38: 
        !            39: #define min(x,y) ((x < y) ? x : y)
        !            40: #define max(x,y) ((x < y) ? y : x)
        !            41: 
        !            42: /* error handling stuff */
        !            43: extern int errno;
        !            44: extern char *sys_errlist[];
        !            45: 
        !            46: /* global "constants" -- set once at startup time */
        !            47: /* the first few variables are not static because they are shared
        !            48:    with dialog.c */
        !            49: int foreground = BlackPixel;
        !            50: int background = WhitePixel;
        !            51: Pixmap backmap;
        !            52: Pixmap border;
        !            53: int borderwidth = 3;
        !            54: int invertplane = 1;
        !            55: int highlightplane = 1;
        !            56: int mousepix = BlackPixel;
        !            57: static int squares_wide = OUT_OF_RANGE;
        !            58: static int squares_high = OUT_OF_RANGE;
        !            59: static short *raster;
        !            60: static int raster_length; /* how many shorts in the raster[] array */
        !            61: static Window outer_window, grid_window;
        !            62: static Window raster_window, raster_invert_window;
        !            63: static Font font;
        !            64: static FontInfo fontInfo;
        !            65: static Cursor cross, upper_left, lower_right, dot;
        !            66: static char *filename = NULL; /* name of input file */
        !            67: static char *backup_filename;
        !            68: static char *stripped_name; 
        !            69:   /* file name without directory path or extension */
        !            70: static char *progname; /* name this program was invoked by */
        !            71: static Pattern DottedPattern = XMakePattern (
        !            72:     1 /* pattern */,
        !            73:     2 /* length */,
        !            74:     1); /* multiplier */
        !            75: static Pattern InverseDottedPattern = XMakePattern (
        !            76:     2 /* pattern */,
        !            77:     2 /* length */,
        !            78:     1); /* multiplier */
        !            79: 
        !            80: /* command-button data */
        !            81: #define N_COMMANDS 12
        !            82: static struct command_data {
        !            83:   Window window;
        !            84:   char *name;
        !            85:   int name_length;
        !            86:   int x_offset;  /* so text is centered within command box */
        !            87:   boolean inverted;
        !            88:   int (*proc)(); 
        !            89:      /* function to invoke when command button is "pressed" */
        !            90:      /* actually no return value, but compiler doesn't like "void" here */
        !            91:   int data;  /* arbitrary instance data to call procedure back with */
        !            92:   } commands [N_COMMANDS];
        !            93: 
        !            94: /* global variables */
        !            95: /* layout-related variables */
        !            96: static int square_size;  /* length of square's side, in pixels */
        !            97: static OpaqueFrame frames[N_COMMANDS+3], outer_frame;
        !            98:      /* frames[0] throgh frames[N_COMMANDS-1] are the command windows;
        !            99:         frames[N_COMMANDS] is the raster;
        !           100:        frames[N_COMMANDS+1] is the inverted raster;
        !           101:        frames[N_COMMANDS+2] is the grid */
        !           102: 
        !           103:   /* location of x'd-through squares, if any */
        !           104: static int x1_square_exed_through = OUT_OF_RANGE;
        !           105: static int y1_square_exed_through = OUT_OF_RANGE;
        !           106: static int x2_square_exed_through = OUT_OF_RANGE;
        !           107: static int y2_square_exed_through = OUT_OF_RANGE;
        !           108: 
        !           109:   /* location of "plus'd through" squares, if any */
        !           110: static int x1_square_plus_through = OUT_OF_RANGE;
        !           111: static int y1_square_plus_through = OUT_OF_RANGE;
        !           112: static int x2_square_plus_through = OUT_OF_RANGE;
        !           113: static int y2_square_plus_through = OUT_OF_RANGE;
        !           114: 
        !           115:   /* location of hot spot, if any */
        !           116: static int x_hot_spot = OUT_OF_RANGE;
        !           117: static int y_hot_spot = OUT_OF_RANGE;
        !           118: 
        !           119: static boolean changed = FALSE;
        !           120:    /* has user changed bitmap since starting program or last write? */
        !           121: 
        !           122: static enum RepaintGridType {e_AgainstBackground, e_AgainstForeground, e_Invert};
        !           123: 
        !           124: extern char *malloc();
        !           125: 
        !           126: main (argc, argv)
        !           127:   int argc;
        !           128:   char **argv;
        !           129:   {
        !           130:   SetUp (argc, argv);
        !           131:   while (TRUE) {
        !           132:     XEvent event;
        !           133:     XNextEvent(&event);
        !           134:     ProcessEvent(&event);
        !           135:     }
        !           136:   }   /* end of main procedure */
        !           137: 
        !           138: 
        !           139: SetUp (argc, argv)
        !           140:   int argc;
        !           141:   char **argv;
        !           142:   {
        !           143:   char *StripName(), *BackupName(), *index();
        !           144:   char *option;
        !           145:   FILE *file;
        !           146:   char *geometry = NULL, *host = NULL, *dimensions = NULL;
        !           147:   int i;
        !           148: 
        !           149:   progname = argv[0];
        !           150:   setlinebuf (stderr);
        !           151: 
        !           152:   /* Parse command line */
        !           153:   for (i = 1; i < argc; i++) {
        !           154:     if (argv[i][0] == '=')
        !           155:        geometry = argv[i];
        !           156: 
        !           157:     else if (index (argv[i], ':') != NULL)
        !           158:        host = argv[i];
        !           159:        
        !           160:     else if (filename == NULL)
        !           161:        filename = argv[i];
        !           162: 
        !           163:     else 
        !           164:        dimensions = argv[i];
        !           165:     }
        !           166: 
        !           167:   if (filename == NULL) {
        !           168:     fprintf (stderr, "%s: no file name specified\n", progname);
        !           169:     exit (1);
        !           170:     }
        !           171:   
        !           172:   stripped_name = StripName (filename);
        !           173:   backup_filename = BackupName (filename);
        !           174: 
        !           175:   file = fopen (filename, "r");
        !           176:   if (!file && (errno != ENOENT)) {
        !           177:     fprintf (stderr, "%s: could not open file '%s' for reading -- %s\n",
        !           178:       progname, filename, sys_errlist[errno]);
        !           179:     exit (1);
        !           180:     }
        !           181:       
        !           182:   if (file)
        !           183:     DimensionsFromFile(file);
        !           184:   else {
        !           185:     if (dimensions != NULL) {
        !           186:       if (sscanf (dimensions, "%2dx%2d", &squares_wide, &squares_high) != 2) {
        !           187:        fprintf (stderr, "%s: invalid dimensions '%s'\n",
        !           188:          progname, dimensions);
        !           189:        exit (1);
        !           190:        }
        !           191:       if ((squares_wide <=0) || (squares_high <=0)) {
        !           192:         fprintf (stderr, "%s: dimensions must be positive\n", progname);
        !           193:         exit (1);
        !           194:         }
        !           195:       }
        !           196:     else   /* dimensions not supplied on command line */
        !           197:       squares_wide = squares_high = 16;
        !           198:     }
        !           199: 
        !           200:   raster_length = ((squares_wide+15)/16)*squares_high;
        !           201:   raster = (short *) malloc (raster_length*sizeof(short));
        !           202:   
        !           203:   if (file) {
        !           204:     InitialValuesFromFile(file);
        !           205:     fclose (file);
        !           206:     }
        !           207:   else {
        !           208:     /* set raster to all 0's (background color) */
        !           209:     register int i;
        !           210:     for (i=0;i<raster_length;i++)
        !           211:       raster[i] = 0;
        !           212:     }
        !           213: 
        !           214:   if (!XOpenDisplay(host)) {
        !           215:     fprintf (stderr, "%s: could not connect to X server on %s\n",
        !           216:        progname, host);
        !           217:     exit (1);
        !           218:     }
        !           219: 
        !           220:   backmap = WhitePixmap;
        !           221:   border = BlackPixmap;
        !           222:   if ((option = XGetDefault(progname, "BorderWidth")) != NULL)
        !           223:     borderwidth = atoi(option);
        !           224:   if ((option = XGetDefault(progname, "BodyFont")) == NULL)
        !           225:     option = "vtsingle";
        !           226:   font = XGetFont (option);
        !           227:   XQueryFont (font, &fontInfo);
        !           228:   if (DisplayCells() > 2) {
        !           229:     char *fore_color = XGetDefault(progname, "Foreground");
        !           230:     char *back_color = XGetDefault(progname, "Background");
        !           231:     char *high_color = XGetDefault(progname, "Highlight");
        !           232:     char *brdr_color = XGetDefault(progname, "Border");
        !           233:     char *mous_color = XGetDefault(progname, "Mouse");
        !           234:     Color fdef, bdef, hdef;
        !           235:     if (fore_color && XParseColor(fore_color, &fdef) &&
        !           236:       back_color && XParseColor(back_color, &bdef) &&
        !           237:       (high_color == NULL || XParseColor(high_color, &hdef)) &&
        !           238:       XGetColorCells(0, 1, high_color ? 2 : 1, &invertplane, &bdef.pixel)) {
        !           239:       background = bdef.pixel;
        !           240:       backmap = XMakeTile(background);
        !           241:       if (high_color) {
        !           242:        hdef.pixel = bdef.pixel | invertplane;
        !           243:        XStoreColor(&hdef);
        !           244:        highlightplane = 1 << (ffs(invertplane) - 1);
        !           245:        hdef.pixel = bdef.pixel | highlightplane;
        !           246:        XStoreColor(&hdef);
        !           247:        invertplane ^= highlightplane;
        !           248:       } else
        !           249:        highlightplane = invertplane;
        !           250:       XStoreColor(&bdef);
        !           251:       foreground = background | invertplane;
        !           252:       fdef.pixel = foreground;
        !           253:       XStoreColor(&fdef);
        !           254:     }
        !           255:     if (brdr_color && XParseColor(brdr_color, &bdef) &&
        !           256:        XGetHardwareColor(&bdef))
        !           257:       border = XMakeTile(bdef.pixel);
        !           258:     if (mous_color && XParseColor(mous_color, &fdef) &&
        !           259:        XGetHardwareColor(&fdef))
        !           260:       mousepix = fdef.pixel;
        !           261:   }
        !           262: 
        !           263:   {
        !           264:   int right_side_bottom, right_side_width;
        !           265:   int minwidth, minheight;
        !           266:   int default_width, default_height, default_x, default_y;
        !           267:   int display_width = DisplayWidth();
        !           268:   int display_height = DisplayHeight();
        !           269:   char default_geometry[20];
        !           270: 
        !           271:   LayoutStage1();
        !           272:   right_side_bottom = frames[N_COMMANDS+1].y + frames[N_COMMANDS+1].height
        !           273:     + 2 /* borders */ + AROUND_RASTER_MARGIN;
        !           274:   right_side_width = frames[0].width + 2 /* borders */
        !           275:     + GRID_TO_COMMAND_MARGIN + RIGHT_MARGIN;
        !           276:   OuterWindowDims (MIN_SQUARE_SIZE, right_side_width, right_side_bottom,
        !           277:     &minwidth, &minheight);
        !           278:   OuterWindowDims (DEFAULT_SQUARE_SIZE, right_side_width, right_side_bottom,
        !           279:     &default_width, &default_height);
        !           280:   default_x = min (200, display_width - default_width - 2*borderwidth);
        !           281:   default_y = min (200, display_height - default_height - 2*borderwidth);
        !           282:   sprintf (default_geometry, "=%dx%d+%d+%d", default_width,
        !           283:     default_height, default_x, default_y);
        !           284:   outer_frame.bdrwidth = borderwidth;
        !           285:   outer_frame.border = border;
        !           286:   outer_frame.background = backmap;
        !           287:   outer_window = XCreate ("Bitmap Editor", progname, geometry,
        !           288:      default_geometry, &outer_frame, minwidth, minheight);
        !           289:   LayoutStage2 ();
        !           290:   }
        !           291:   
        !           292:   upper_left = XCreateCursor (ul_angle_width, ul_angle_height, 
        !           293:     ul_angle_bits, ul_angle_mask_bits, ul_angle_x_hot, ul_angle_y_hot,
        !           294:     mousepix, background, GXcopy);
        !           295:   lower_right = XCreateCursor (lr_angle_width, lr_angle_height,
        !           296:     lr_angle_bits, lr_angle_mask_bits,
        !           297:     lr_angle_x_hot, lr_angle_y_hot, mousepix, background, GXcopy);
        !           298:   cross = XCreateCursor (cross_width, cross_height, cross_bits, 
        !           299:     cross_mask_bits, cross_x_hot, cross_y_hot, mousepix, background,
        !           300:     GXcopy);
        !           301:   dot = XCreateCursor (dot_width, dot_height, dot_bits,
        !           302:     dot_mask_bits, dot_x_hot, dot_y_hot, mousepix, background,
        !           303:     GXcopy);
        !           304:   XDefineCursor (outer_window, cross);
        !           305: 
        !           306:   XExpandEvents();  /* do NOT collapse adjacent MouseMotion events */
        !           307:   XSelectInput (outer_window, ExposeWindow);  /* to detect size changes */
        !           308:   XMapWindow (outer_window);
        !           309:   XMapSubwindows (outer_window);
        !           310:   }    /* end of Set_Up procedure */
        !           311: 
        !           312: 
        !           313: /* Unfortunately, the current implementation of X (version 10) does not
        !           314:    handle resize event notification very well.  When the outer window
        !           315:    is resized, X sends ExposeWindow events for each subwindow BEFORE sending
        !           316:    an ExposeWindow for the outer window.
        !           317: 
        !           318:    If I handled the events in the order sent, I would repaint each
        !           319:    subwindow, only then to discover that the outer window had changed
        !           320:    size...at which time I would unmap and rearrange the subwindows,
        !           321:    causing ANOTHER set of exposure events on the subwindows.  This would
        !           322:    not just be inefficient, it would also look ugly on the screen.
        !           323: 
        !           324:    To work around this misfeature, I do not process ExposeWindow events
        !           325:    immediately upon receipt, but instead go into a recursion (HandleExposure)
        !           326:    until I either run out of events or get a non-ExposeWindow event.  If
        !           327:    the list of ExposeWindow events ends with a resize, I discard all of the
        !           328:    earlier ExposeWindow events.  Otherwise, I unwind out of the recursion,
        !           329:    processing each exposure event in the opposite of the order received,
        !           330:    eventually returning to the normal event notification loop.
        !           331: 
        !           332:    This code is admittedly convoluted, and will hopefully go away in a
        !           333:    future version of X.  */
        !           334: 
        !           335: #define PROCESS_IT 0
        !           336: #define DISCARD_IT 1
        !           337: 
        !           338: ProcessEvent (event)
        !           339:   register XEvent *event;
        !           340:   {
        !           341:   register Window w = event->window;
        !           342:   register int i;
        !           343:   if (event->type == ExposeWindow) {
        !           344:     int status;
        !           345:     /* make sure that I get all the exposure events that have been sent */
        !           346:     XSync(0); 
        !           347:     status = HandleExposure (event);
        !           348:     if (status == DISCARD_IT)
        !           349:        return;
        !           350:     }
        !           351:   ProcessEventReally (event);
        !           352:   }
        !           353: 
        !           354: ProcessEventReally (event)
        !           355:   register XEvent *event;
        !           356:   {
        !           357:   register Window w = event->window;
        !           358:   register int i;
        !           359:   if (w == grid_window)
        !           360:     ProcessGridWindowEvent (event);
        !           361:   else if (w == outer_window)
        !           362:     ProcessOuterWindowEvent (event);
        !           363:   else if (w == raster_window)
        !           364:     RepaintRaster();
        !           365:   else if (w == raster_invert_window)
        !           366:     RepaintRasterInverted();
        !           367:   else for (i=0;i<N_COMMANDS;i++)
        !           368:     if (w == commands[i].window)
        !           369:       ProcessCommandButtonEvent (&commands[i], event);
        !           370:   }  /* end of ProcessInput procedure */
        !           371: 
        !           372: 
        !           373: int HandleExposure (event)
        !           374:   XExposeWindowEvent *event;
        !           375:   {
        !           376:   int status;
        !           377:   XEvent next_event;
        !           378:   
        !           379:   if (QLength() == 0)
        !           380:     /* there are no more events, so this can't be a resize */
        !           381:     return (PROCESS_IT);
        !           382:     
        !           383:   XNextEvent (&next_event);
        !           384:   if (next_event.type != ExposeWindow) {
        !           385:     /* the list of exposures ended, so this can't be a resize */
        !           386:     XPutBackEvent (&next_event);
        !           387:     return (PROCESS_IT);
        !           388:     }
        !           389:     
        !           390:   if (next_event.window == outer_window) {
        !           391:     if ((outer_frame.height == ((XExposeWindowEvent *)&next_event)->height)
        !           392:       && (outer_frame.width == ((XExposeWindowEvent *)&next_event)->width))
        !           393:         /* the list of exposures ended with a non-resize */
        !           394:         status = PROCESS_IT;
        !           395:     else
        !           396:        /* this IS a resize */
        !           397:         status = DISCARD_IT;
        !           398:     /* Handle the outer window exposure, whether or not it's a resize */
        !           399:     ProcessEventReally (&next_event);
        !           400:     return (status);
        !           401:     }
        !           402: 
        !           403:   if ((status = HandleExposure (&next_event)) == PROCESS_IT)
        !           404:     ProcessEventReally (&next_event);
        !           405:   return (status);
        !           406:   }
        !           407:   
        !           408: ProcessGridWindowEvent (event)
        !           409:   XEvent *event;
        !           410:   {
        !           411:   int x_square, y_square;
        !           412:   static int x_square_prev, y_square_prev;
        !           413:   static boolean raster_outdated;
        !           414:   switch (event->type) {
        !           415: 
        !           416:     case ExposeWindow:
        !           417:       RepaintGridLines(e_AgainstBackground);
        !           418:       RefillGrid(FALSE);
        !           419:       if (x1_square_exed_through != OUT_OF_RANGE)
        !           420:        ExThroughRectangle (x1_square_exed_through, y1_square_exed_through,
        !           421:          x2_square_exed_through, y2_square_exed_through);
        !           422:       if (x1_square_plus_through != OUT_OF_RANGE)
        !           423:         PlusThroughRectangle (x1_square_plus_through, y1_square_plus_through,
        !           424:          x2_square_plus_through, y2_square_plus_through);
        !           425:       if (x_hot_spot != OUT_OF_RANGE)
        !           426:        HighlightHotSpot();
        !           427:       break;
        !           428: 
        !           429:     case ExposeRegion: {
        !           430: #define this_event ((XExposeRegionEvent *)event)
        !           431:       int x1 = this_event->x;
        !           432:       int y1 = this_event->y;
        !           433:       int x2 = x1 + this_event->width;
        !           434:       int y2 = y1 + this_event->height;
        !           435: #undef this_event
        !           436:       x1 /= square_size;
        !           437:       x2 /= square_size;
        !           438:       y1 /= square_size;
        !           439:       y2 /= square_size;
        !           440:       if (x2 >= squares_wide)
        !           441:         x2 = squares_wide - 1;  /* sanity check */
        !           442:       if (y2 >= squares_high)
        !           443:         y2 = squares_high - 1;  /* sanity check */
        !           444:       RepaintGridLinesPartially(x1,y1,x2+1,y2+1,e_AgainstBackground,TRUE);
        !           445:       RefillGridPartially (x1,y1,x2,y2,FALSE);
        !           446:       if (x1_square_exed_through != OUT_OF_RANGE)
        !           447:         ExThroughRectangle (
        !           448:          max (x1, x1_square_exed_through),
        !           449:          max (y1, y1_square_exed_through),
        !           450:          min (x2, x2_square_exed_through),
        !           451:          min (y2, y2_square_exed_through));
        !           452:       if (x1_square_plus_through != OUT_OF_RANGE)
        !           453:         PlusThroughRectangle (
        !           454:          max (x1, x1_square_plus_through),
        !           455:          max (y1, y1_square_plus_through),
        !           456:          min (x2, x2_square_plus_through),
        !           457:          min (y2, y2_square_plus_through));
        !           458:       if (x_hot_spot >= x1 && x_hot_spot <= x2
        !           459:        && y_hot_spot >= y1 && y_hot_spot <= y2)
        !           460:            HighlightHotSpot();
        !           461:       break;
        !           462:       }
        !           463: 
        !           464:     case ButtonPressed:
        !           465:       if (WhatSquare (event, &x_square, &y_square))
        !           466:         return;  /* mouse outside grid; really shouldn't happen, but... */
        !           467:       switch (((XButtonPressedEvent *)event)->detail & ValueMask) {
        !           468:        case LeftButton:
        !           469:          PaintSquare (x_square, y_square, foreground);
        !           470:          if (x_square == x_hot_spot && y_square == y_hot_spot)
        !           471:            HighlightHotSpot();
        !           472:          SetRasterBit (raster, x_square, y_square, 1);
        !           473:          break;
        !           474:        case MiddleButton:
        !           475:          InvertSquare (x_square, y_square);
        !           476:          InvertRasterBit (raster, x_square, y_square);
        !           477:          break;
        !           478:        case RightButton:
        !           479:          PaintSquare (x_square, y_square, background);
        !           480:          if (x_square == x_hot_spot && y_square == y_hot_spot)
        !           481:            HighlightHotSpot();
        !           482:          SetRasterBit (raster, x_square, y_square, 0);
        !           483:          break;
        !           484:        }
        !           485:       RepaintRaster();
        !           486:       RepaintRasterInverted();
        !           487:       x_square_prev = x_square;
        !           488:       y_square_prev = y_square;
        !           489:       raster_outdated = FALSE;
        !           490:       changed = TRUE;
        !           491:       break;
        !           492:     
        !           493:     case MouseMoved:
        !           494:       if (WhatSquare (event, &x_square, &y_square))
        !           495:         return;  /* mouse outside grid; really shouldn't happen, but... */
        !           496:       if ((x_square != x_square_prev) || (y_square != y_square_prev))
        !           497:                  switch (((XMouseMovedEvent *)event)->detail) {
        !           498:            case LeftMask:
        !           499:              PaintSquare (x_square, y_square, foreground);
        !           500:              if (x_square == x_hot_spot && y_square == y_hot_spot)
        !           501:                HighlightHotSpot();
        !           502:              SetRasterBit (raster, x_square, y_square, 1);
        !           503:              changed = raster_outdated = TRUE;
        !           504:              break;
        !           505:            case MiddleMask:
        !           506:              InvertSquare (x_square, y_square);
        !           507:              InvertRasterBit (raster, x_square, y_square);
        !           508:              changed = raster_outdated = TRUE;
        !           509:              break;
        !           510:            case RightMask:
        !           511:              PaintSquare (x_square, y_square, background);
        !           512:              if (x_square == x_hot_spot && y_square == y_hot_spot)
        !           513:                HighlightHotSpot();
        !           514:              SetRasterBit (raster, x_square, y_square, 0);
        !           515:              changed = raster_outdated = TRUE;
        !           516:              break;
        !           517:            default:
        !           518:              break;  /* ignore events with multiple buttons down */
        !           519:            }
        !           520:       if (raster_outdated && !MouseMovedEventQueued()) {
        !           521:        RepaintRaster();
        !           522:        RepaintRasterInverted();
        !           523:        raster_outdated = FALSE;
        !           524:        }
        !           525:       x_square_prev = x_square;
        !           526:       y_square_prev = y_square;
        !           527:       break;
        !           528:   
        !           529:     }
        !           530:   }  /* end of ProcessGridWindowEvent procedure */
        !           531: 
        !           532: boolean MouseMovedEventQueued () {
        !           533:   XEvent event;
        !           534:   if (XPending() == 0) return (FALSE);
        !           535:   XPeekEvent (&event);
        !           536:   return (event.type == MouseMoved);
        !           537:   }
        !           538: 
        !           539: 
        !           540: ProcessOuterWindowEvent (event)
        !           541:   XEvent *event;
        !           542:   {
        !           543:   if (event->type != ExposeWindow)
        !           544:     return;
        !           545:   if ((outer_frame.height == ((XExposeWindowEvent *)event)->height)
        !           546:      && (outer_frame.width == ((XExposeWindowEvent *)event)->width))
        !           547:      /* if this isn't a resize, there's nothing to do here. */
        !           548:      return;
        !           549: 
        !           550:   /* the outer window's size has changed.  Must rearrange subwindows. */
        !           551:   outer_frame.height = ((XExposeWindowEvent *)event)->height;
        !           552:   outer_frame.width = ((XExposeWindowEvent *)event)->width;
        !           553:   XDestroySubwindows (outer_window);
        !           554:   LayoutStage2 ();
        !           555:   XMapSubwindows (outer_window);
        !           556:   }
        !           557:   
        !           558: ProcessCommandButtonEvent (command, event)
        !           559:   struct command_data *command;
        !           560:   XEvent *event;
        !           561:   {
        !           562:   static struct command_data *button_down_command;
        !           563:   
        !           564:   switch (event->type) {
        !           565: 
        !           566:     case ExposeWindow:
        !           567:       if (command->inverted)
        !           568:         XClear (command->window);
        !           569:       XTextMask (
        !           570:         command->window,    /* w */
        !           571:        command->x_offset,  /* x */
        !           572:        0,                  /* y */
        !           573:        command->name,      /* string */
        !           574:        command->name_length,    /* length */
        !           575:        font,               /* font */
        !           576:        foreground);        /* source pixel */
        !           577:       if (command->inverted)
        !           578:        InvertCommandWindow (command);
        !           579:       break;
        !           580: 
        !           581:     case ButtonPressed:
        !           582:       if (button_down_command != NULL)
        !           583:         break;  /* must be a second button push--ignore */
        !           584:       button_down_command = command;
        !           585:       InvertCommandWindow (command);
        !           586:       command->inverted = TRUE;
        !           587:       break;
        !           588: 
        !           589:     case LeaveWindow:
        !           590:       if (command == button_down_command) {
        !           591:        InvertCommandWindow (command);
        !           592:        command->inverted = FALSE;
        !           593:        button_down_command = NULL;
        !           594:        }
        !           595:       break;
        !           596: 
        !           597:     case ButtonReleased:
        !           598:       if (command == button_down_command) {
        !           599:        (*command->proc)(command->data);
        !           600:        button_down_command = NULL;
        !           601:        InvertCommandWindow (command);
        !           602:        command->inverted = FALSE;
        !           603:        }
        !           604:       break;
        !           605:       
        !           606:     }
        !           607:   }
        !           608: 
        !           609: 
        !           610: InvertCommandWindow (command)
        !           611:   struct command_data *command;
        !           612:   {
        !           613:   XPixFill (
        !           614:     command->window,
        !           615:     0,     /* x */
        !           616:     0,             /* y */
        !           617:     400,    /* width = "infinity " */
        !           618:     fontInfo.height,   /* height */
        !           619:     1,     /* pixel */
        !           620:     NULL,   /* clipmask bitmap */
        !           621:     GXinvert,  /* function */
        !           622:     invertplane);      /* planes */
        !           623:   }  /* end of InvertCommandWindow procedure */
        !           624: 
        !           625:          
        !           626: /* WhatSquare returns TRUE if mouse is outside grid, FALSE if inside.
        !           627:    If it returns FALSE, it assigns to *x_square and *y_square. */
        !           628: 
        !           629: boolean WhatSquare (event, x_square, y_square)
        !           630:   register XEvent *event;
        !           631:   register int *x_square, *y_square; /*RETURN*/
        !           632:   {
        !           633:   int x = ((XKeyPressedEvent *)event)->x;
        !           634:   int y = ((XKeyPressedEvent *)event)->y;
        !           635:   if ((x < 0) || (y < 0))
        !           636:     return (TRUE);
        !           637:   *x_square = x/square_size;
        !           638:   *y_square = y/square_size;
        !           639:   return ((*x_square >= squares_wide) || (*y_square >= squares_high));
        !           640:   }  /* end of WhatSquare procedure */
        !           641: 
        !           642: 
        !           643: RepaintGridLines(how)
        !           644:   enum RepaintGridType how;
        !           645:   {
        !           646:   RepaintGridLinesPartially (0, 0, squares_wide, squares_high, how, TRUE);
        !           647:   }
        !           648: 
        !           649: RepaintGridLinesPartially (x1, y1, x2, y2, how, include_boundaries)
        !           650:   int x1, y1, x2, y2;
        !           651:   enum RepaintGridType how;
        !           652:   boolean include_boundaries;
        !           653:   {
        !           654:   register int i;
        !           655:   Vertex v[2];
        !           656:   int pixel, func, planes;
        !           657:   Pattern pattern;
        !           658:   switch (how) {
        !           659:     case e_AgainstBackground:
        !           660:        pixel = foreground;
        !           661:        pattern = DottedPattern;
        !           662:        func = GXcopy;
        !           663:        planes = AllPlanes;
        !           664:        break;
        !           665:     case e_AgainstForeground:
        !           666:        pixel = background;
        !           667:        pattern = InverseDottedPattern;
        !           668:        func = GXcopy;
        !           669:        planes = AllPlanes;
        !           670:        break;
        !           671:     case e_Invert:
        !           672:        pixel = 1;
        !           673:        pattern = SolidLine;
        !           674:        func = GXinvert;
        !           675:        planes = invertplane;
        !           676:        break;
        !           677:     }
        !           678:     
        !           679:   /* draw vertical grid lines */
        !           680:   v[0].flags = v[1].flags = 0;
        !           681:   v[0].y = y1*square_size;
        !           682:   v[0].y += (v[0].y & 1);  /* make sure pattern is aligned on even bit boundary */
        !           683:   v[1].y = y2*square_size;
        !           684:   if (!include_boundaries) {x1++;x2--;}
        !           685:   v[0].x = v[1].x = x1*square_size;
        !           686:   for (i=x1;i<=x2; i++) {
        !           687:      XDrawDashed (
        !           688:        grid_window,
        !           689:        v,  /* vertices */
        !           690:        2,  /* vertex count */
        !           691:        1,  /* width */
        !           692:        1,  /* height */
        !           693:        pixel,
        !           694:        pattern,
        !           695:        func,
        !           696:        planes);        /* planes */
        !           697:      v[0].x = (v[1].x += square_size);
        !           698:      }
        !           699:   if (!include_boundaries) {x1--;x2++;}
        !           700: 
        !           701:   /* draw horizontal grid lines */
        !           702:   v[0].flags = v[1].flags = 0;
        !           703:   v[0].x = x1*square_size;
        !           704:   v[0].x += (v[0].x & 1);  /* make sure pattern is aligned on even bit boundary */
        !           705:   v[1].x = x2*square_size;
        !           706:   if (!include_boundaries) {y1++;y2--;}
        !           707:   v[0].y = v[1].y = y1*square_size;
        !           708:   for (i=y1;i<=y2;i++) {
        !           709:     XDrawDashed (
        !           710:        grid_window,
        !           711:        v,  /* vertices */
        !           712:        2,  /* vertex count */
        !           713:        1,  /* width */
        !           714:        1,  /* height */
        !           715:        pixel,
        !           716:        pattern,
        !           717:        func,
        !           718:        planes);        /* planes */
        !           719:      v[0].y = (v[1].y += square_size);
        !           720:      }
        !           721:   }  /* end of RepaintGridLinesPartially procedure */
        !           722: 
        !           723: 
        !           724: RefillGrid (paint_background)
        !           725:   boolean paint_background;
        !           726:   {
        !           727:   RefillGridPartially (0, 0, squares_wide-1, squares_high-1, paint_background);
        !           728:   }
        !           729: 
        !           730: 
        !           731: RefillGridPartially(x1, y1, x2, y2, paint_background)
        !           732:   register int x1, y1, x2, y2;
        !           733:   boolean paint_background;
        !           734:   {
        !           735:   register i, j;
        !           736:   for (i=x1; i<=x2; i++) {
        !           737:     for (j=y1; j<=y2; j++) {
        !           738:       bit b = GetRasterBit (raster, i, j);
        !           739:       if (b || paint_background)
        !           740:        PaintSquare (i, j, (b ? foreground : background));
        !           741:       }
        !           742:     }
        !           743:   }  /* end of RefillGridPartially procedure */
        !           744: 
        !           745: 
        !           746: PaintSquare(x, y, pixel)
        !           747:   int x, y;
        !           748:   int pixel;  /* display function */  
        !           749:   {
        !           750:   XPixSet (
        !           751:     grid_window,
        !           752:     x*square_size + 1, /* x */
        !           753:     y*square_size + 1,         /* y */
        !           754:     square_size - 1,   /* width */
        !           755:     square_size - 1,   /* height */
        !           756:     pixel);                            /* pixel */
        !           757:   }  /* end of PaintSquare procedure */
        !           758: 
        !           759: InvertSquare(x, y)
        !           760:   int x, y;
        !           761:   {
        !           762:   XPixFill (
        !           763:     grid_window,
        !           764:     x*square_size + 1, /* x */
        !           765:     y*square_size + 1,         /* y */
        !           766:     square_size - 1,   /* width */
        !           767:     square_size - 1,   /* height */
        !           768:     1,                         /* pixel */
        !           769:     NULL,                      /* clipmask */
        !           770:     GXinvert,                          /* function */
        !           771:     invertplane);              /* planes */
        !           772:   }
        !           773: 
        !           774: bit GetRasterBit (raster, x, y)
        !           775:   short *raster;
        !           776:   register int x;
        !           777:   int y;
        !           778:   {
        !           779:   register short *word = raster + x/16 + y*((squares_wide+15)/16);
        !           780:   return ( (*word & (1 << (x % 16))) ? 1 : 0);
        !           781:   }  /* end of GetRasterBit procedure */
        !           782: 
        !           783: 
        !           784: SetRasterBit (raster, x, y, new)
        !           785:   short *raster;
        !           786:   register int x;
        !           787:   int y;
        !           788:   bit new;
        !           789:   {
        !           790:   register short *word = raster + x/16 + y*((squares_wide+15)/16);
        !           791:   x %= 16;
        !           792:   *word = (new << x) | (*word & ~(1 << x));
        !           793:   }  /* end of SetRasterBit procedure */
        !           794: 
        !           795: 
        !           796: InvertRasterBit (raster, x, y)
        !           797:   short *raster;
        !           798:   register int x;
        !           799:   int y;
        !           800:   {
        !           801:   register short *word = raster + x/16 + y*((squares_wide+15)/16);
        !           802:   *word ^= (1 << (x % 16));
        !           803:   }  /* end of InvertRasterBit procedure */
        !           804: 
        !           805: 
        !           806: RepaintRaster() {
        !           807:   XBitmapBitsPut (
        !           808:     raster_window,
        !           809:     3, /* x */
        !           810:     3, /* y */
        !           811:     squares_wide,   /* width */
        !           812:     squares_high,   /* height */
        !           813:     raster,        /* data */
        !           814:     foreground,            /* foreground */
        !           815:     background,            /* background */
        !           816:     0,             /* mask */
        !           817:     GXcopy,        /* func */
        !           818:     AllPlanes);            /* planes */
        !           819:   }  /* end of RepaintRaster procedure */
        !           820: 
        !           821: 
        !           822: RepaintRasterInverted () {
        !           823:   XBitmapBitsPut (
        !           824:     raster_invert_window,
        !           825:     3, /* x */
        !           826:     3, /* y */
        !           827:     squares_wide,   /* width */
        !           828:     squares_high,   /* height */
        !           829:     raster,        /* data */
        !           830:     background,            /* foreground */
        !           831:     foreground,            /* background */
        !           832:     0,             /* mask */
        !           833:     GXcopy,        /* func */
        !           834:     AllPlanes);            /* planes */
        !           835:   } /* end of RepaintRasterInverted procedure */
        !           836: 
        !           837: 
        !           838: WriteOutputToFile (file)
        !           839:   FILE *file;
        !           840:   {
        !           841:   register int i;
        !           842:   fprintf (file, "#define %s_width %d\n", stripped_name, squares_wide);
        !           843:   fprintf (file, "#define %s_height %d\n", stripped_name, squares_high);
        !           844:   if (x_hot_spot != OUT_OF_RANGE)
        !           845:     fprintf (file, "#define %s_x_hot %d\n", stripped_name, x_hot_spot);
        !           846:   if (y_hot_spot != OUT_OF_RANGE)
        !           847:     fprintf (file, "#define %s_y_hot %d\n", stripped_name, y_hot_spot);
        !           848:   fprintf (file, "static short %s_bits[] = {\n   0x%04x",
        !           849:     stripped_name, (u_short) raster[0]);
        !           850: 
        !           851:   for (i=1;i<raster_length;i++) {
        !           852:     fprintf (file, ",");
        !           853:     fprintf (file, (i % 4) ? " " : "\n   ");
        !           854:     fprintf (file, "0x%04x", (u_short) raster[i]);
        !           855:     }
        !           856:   fprintf (file, "};\n");
        !           857:   }  /* end of WriteOutputToFile procedure */
        !           858: 
        !           859: 
        !           860: DimensionsFromFile(file) 
        !           861:   FILE *file;
        !           862:   {
        !           863:   char variable[81];
        !           864:   int value;
        !           865:   while (fscanf (file, "#define %80s %2d\n", variable, &value) == 2) {
        !           866:     if (StringEndsWith (variable, "width"))
        !           867:        squares_wide = value;
        !           868:     else if (StringEndsWith (variable, "height"))
        !           869:        squares_high = value;
        !           870:     else if (StringEndsWith (variable, "x_hot"))
        !           871:        x_hot_spot = value;
        !           872:     else if (StringEndsWith (variable, "y_hot"))
        !           873:        y_hot_spot = value;
        !           874:     else fprintf (stderr, "Unrecognized variable '%s' in file '%s'\n",
        !           875:        variable, filename);
        !           876:     }
        !           877: 
        !           878:   if (squares_wide <= 0 || squares_wide == OUT_OF_RANGE) {
        !           879:     fprintf (stderr,
        !           880:       "%s: file '%s' does not have a valid width dimension\n",
        !           881:       progname, filename);
        !           882:     exit(1);
        !           883:     }
        !           884:     
        !           885:   if (squares_high <= 0 || squares_high == OUT_OF_RANGE) {
        !           886:     fprintf (stderr,
        !           887:       "%s: file '%s' does not have a valid height dimension\n",
        !           888:       progname, filename);
        !           889:     exit(1);
        !           890:     }  
        !           891:   }  /* end of DimensionsFromFile procedure */
        !           892: 
        !           893: 
        !           894: InitialValuesFromFile(file)
        !           895:   FILE *file;
        !           896:   {
        !           897:   register int i, status;
        !           898:   char s[81];
        !           899: 
        !           900:   status = fscanf (file, "static short %80s = { 0x%4hx", s, &raster[0]);
        !           901:   if ((status != 2) || !StringEndsWith (s, "bits[]")) {
        !           902:     fprintf (stderr,
        !           903:       "%s: file '%s' has an invalid 1st array element\n",
        !           904:       progname, filename);
        !           905:     exit (1);
        !           906:     }
        !           907:   for (i=1;i<raster_length;i++) {
        !           908:     status = fscanf (file, ", 0x%4hx", &raster[i]);
        !           909:     if (status != 1) {
        !           910:       fprintf (stderr,
        !           911:         "%s: file '%s' has an invalid %dth array element\n",
        !           912:         progname, filename, i+1);
        !           913:       exit (1);
        !           914:       }
        !           915:     }
        !           916: 
        !           917:   }  /* end of InitialValuesFromFile procedure */
        !           918: 
        !           919: 
        !           920: char *StripName(name)
        !           921:   char *name;
        !           922:   {
        !           923:   char *rindex(), *index();
        !           924:   char *begin = rindex (name, '/');
        !           925:   char *end, *result;
        !           926:   int length;
        !           927:   begin = (begin ? begin+1 : name);
        !           928:   end = index (begin, '.');
        !           929:   length = (end ? (end - begin) : strlen (begin));
        !           930:   result = (char *) malloc (length + 1);
        !           931:   strncpy (result, begin, length);
        !           932:   result [length] = '\0';
        !           933:   return (result);
        !           934:   }
        !           935: 
        !           936: 
        !           937: char *BackupName(name)
        !           938:   char *name;
        !           939:   {
        !           940:   int name_length = strlen (name);
        !           941:   char *result = (char *) malloc (name_length+2);
        !           942:   strncpy (result, name, name_length);
        !           943:   result [name_length] = '~';
        !           944:   result [name_length+1] = '\0';
        !           945:   return (result);
        !           946:   }
        !           947: 
        !           948: char *TmpFileName(name)
        !           949:   char *name;
        !           950:   {
        !           951:   {
        !           952:   char *rindex();
        !           953:   char *begin = rindex (name, '/');
        !           954:   if (begin)
        !           955:     name = begin+1;
        !           956:   }
        !           957:   {
        !           958:   char *tmp = "/tmp/";
        !           959:   int name_length = strlen (name);
        !           960:   int tmp_length = strlen (tmp);
        !           961:   int result_length = name_length + tmp_length;
        !           962:   char *result = (char *) malloc (result_length + 1);
        !           963:   strncpy (result, tmp, tmp_length);
        !           964:   strncpy (result+tmp_length, name, name_length);
        !           965:   result [result_length] = '\0';
        !           966:   return (result);
        !           967:   }
        !           968:   }
        !           969: 
        !           970: /* StringEndsWith returns TRUE if "s" ends with "suffix", else returns FALSE */
        !           971: boolean StringEndsWith (s, suffix)
        !           972:   char *s, *suffix;
        !           973:   {
        !           974:   int s_len = strlen (s);
        !           975:   int suffix_len = strlen (suffix);
        !           976:   return (strcmp (s + s_len - suffix_len, suffix) == 0);
        !           977:   }
        !           978: 
        !           979: /* LayoutStage1 determines the size and y-position of all commmand
        !           980:    windows and both raster windows.  It fills in everything in the
        !           981:    commands[] array except the "window" field, and fills in everything in
        !           982:    the frames[] array except for the "self" (window) and "x" fields. It
        !           983:    returns in *width and *bottom the dimensions of the command area to be
        !           984:    created.  
        !           985:    This routine is called only once, at startup time.
        !           986:    Everything done at this stage stays the same even if the user later
        !           987:    reshapes the window. */
        !           988: 
        !           989: LayoutStage1 ()
        !           990:   {
        !           991:   int widths [N_COMMANDS];
        !           992:   int maxwidth = 0;
        !           993:   int ypos = TOP_MARGIN;
        !           994:   register int i;
        !           995:   register OpaqueFrame *frame;
        !           996:   int ClearOrSetAll(), InvertAll(),
        !           997:       ClearOrSetArea(), InvertArea(), CopyOrMoveArea(),
        !           998:       SetHotSpot(), ClearHotSpot(),
        !           999:       WriteOutput(), Quit();
        !          1000: 
        !          1001:   commands[0].name = "Clear All";
        !          1002:   commands[0].proc = ClearOrSetAll;
        !          1003:   commands[0].data = 0;
        !          1004:   
        !          1005:   commands[1].name = "Set All";
        !          1006:   commands[1].proc = ClearOrSetAll;
        !          1007:   commands[1].data = 1;
        !          1008: 
        !          1009:   commands[2].name = "Invert All";
        !          1010:   commands[2].proc = InvertAll;
        !          1011: 
        !          1012:   commands[3].name = "Clear Area";
        !          1013:   commands[3].proc = ClearOrSetArea;
        !          1014:   commands[3].data = 0;
        !          1015: 
        !          1016:   commands[4].name = "Set Area";
        !          1017:   commands[4].proc = ClearOrSetArea;
        !          1018:   commands[4].data = 1;
        !          1019: 
        !          1020:   commands[5].name = "Invert Area";
        !          1021:   commands[5].proc = InvertArea;
        !          1022: 
        !          1023:   commands[6].name = "Copy Area";
        !          1024:   commands[6].proc = CopyOrMoveArea;
        !          1025:   commands[6].data = 0;
        !          1026: 
        !          1027:   commands[7].name = "Move Area";
        !          1028:   commands[7].proc = CopyOrMoveArea;
        !          1029:   commands[7].data = 1;
        !          1030: 
        !          1031:   commands[8].name = "Set HotSpot";
        !          1032:   commands[8].proc = SetHotSpot;
        !          1033: 
        !          1034:   commands[9].name = "Clear HotSpot";
        !          1035:   commands[9].proc = ClearHotSpot;
        !          1036: 
        !          1037:   commands[10].name = "Write Output";
        !          1038:   commands[10].proc = WriteOutput;
        !          1039: 
        !          1040:   commands[11].name = "Quit";
        !          1041:   commands[11].proc = Quit;
        !          1042: 
        !          1043: 
        !          1044:   for (i=0;i<N_COMMANDS;i++) {
        !          1045:     widths[i] = XQueryWidth (commands[i].name, font);
        !          1046:     if (maxwidth < widths[i])
        !          1047:       maxwidth = widths[i];
        !          1048:     }
        !          1049: 
        !          1050:   maxwidth += 4; /* so even widest command has a little space around it */
        !          1051: 
        !          1052:   for (i=0;i<N_COMMANDS;i++) {
        !          1053:     register struct command_data *command = &commands[i];
        !          1054:     frame = &frames[i];
        !          1055:     command->name_length = strlen (command->name);
        !          1056:     command->x_offset = (maxwidth - widths[i])/2;
        !          1057:     frame->y = ypos;
        !          1058:     frame->width = maxwidth;
        !          1059:     frame->height = fontInfo.height;
        !          1060:     frame->bdrwidth = 1;
        !          1061:     frame->border = border;
        !          1062:     frame->background = backmap;
        !          1063:     ypos += fontInfo.height + 5;
        !          1064:     if (i==2 || i == 5 || i == 7 || i == 9)
        !          1065:       ypos += fontInfo.height + 5;
        !          1066:       /* for gaps between groups;  pretty random! */
        !          1067: 
        !          1068:     }
        !          1069:   
        !          1070:   /* set up raster window */
        !          1071:   frame = &frame[N_COMMANDS];
        !          1072:   frame = &frames[i];
        !          1073:   frame->y = (ypos += AROUND_RASTER_MARGIN);
        !          1074:   frame->width = squares_wide + 6;
        !          1075:   frame->height = squares_high + 6;
        !          1076:   frame->bdrwidth = 1;
        !          1077:   frame->border = border;
        !          1078:   frame->background = backmap;
        !          1079:   
        !          1080:   /* raster invert window is the same, except for y position */
        !          1081:   *(frame+1) = *frame;
        !          1082:   (++frame)->y += squares_high + 8 + AROUND_RASTER_MARGIN;
        !          1083: 
        !          1084:   }
        !          1085: 
        !          1086: /* LayoutStage2 is called both at startup time and whenever the user
        !          1087:    resizes the outer window.  It figures out what the new grid square size
        !          1088:    should be, determines the size and position of all subwindows, then
        !          1089:    creates (but does not map) the subwindows. */
        !          1090: 
        !          1091: LayoutStage2 ()
        !          1092:   {
        !          1093:   int x_room = outer_frame.width - 1
        !          1094:      - LEFT_MARGIN - frames[0].width - GRID_TO_COMMAND_MARGIN - RIGHT_MARGIN;
        !          1095:   int y_room = outer_frame.height - 1
        !          1096:      - TOP_MARGIN - BOTTOM_MARGIN;
        !          1097:   int i;
        !          1098:   int command_x_offset;
        !          1099:   OpaqueFrame *grid_frame = &frames[N_COMMANDS+2];
        !          1100:   
        !          1101:   x_room /= squares_wide;
        !          1102:   y_room /= squares_high;
        !          1103:   square_size = min (x_room, y_room);
        !          1104:   
        !          1105:   /* fill in the grid window's frame */
        !          1106:   grid_frame->x = LEFT_MARGIN;
        !          1107:   grid_frame->y = TOP_MARGIN;
        !          1108:   grid_frame->width = (squares_wide * square_size) + 1;
        !          1109:   grid_frame->height = (squares_high * square_size) + 1;
        !          1110:   grid_frame->bdrwidth = 0;
        !          1111:   grid_frame->border = NULL;
        !          1112:   grid_frame->background = backmap;
        !          1113: 
        !          1114:   /* fill in x offsets for command window frames */
        !          1115:   command_x_offset = grid_frame->x + grid_frame->width
        !          1116:     + GRID_TO_COMMAND_MARGIN;
        !          1117:   for (i=0;i<N_COMMANDS;i++)
        !          1118:     frames[i].x = command_x_offset;
        !          1119: 
        !          1120:   /* fill in x offsets for raster and raster-inverted window frames */
        !          1121:   frames[N_COMMANDS].x = frames[N_COMMANDS+1].x =
        !          1122:     grid_frame->x + grid_frame->width + AROUND_RASTER_MARGIN;
        !          1123: 
        !          1124:   /* create all the subwindows */
        !          1125:   XCreateWindows (outer_window, frames, N_COMMANDS+3);
        !          1126: 
        !          1127:   /* stow away all the resulting window id's, and select input */
        !          1128:   for (i=0;i<N_COMMANDS;i++)
        !          1129:     XSelectInput (commands[i].window = frames[i].self, 
        !          1130:        ButtonPressed | ButtonReleased | LeaveWindow | ExposeWindow);
        !          1131: 
        !          1132:   XSelectInput (raster_window = frames[N_COMMANDS].self, ExposeWindow);
        !          1133:   XSelectInput (raster_invert_window = frames[N_COMMANDS+1].self,
        !          1134:     ExposeWindow);
        !          1135:   XSelectInput (grid_window = grid_frame->self,
        !          1136:     RightDownMotion | MiddleDownMotion | LeftDownMotion
        !          1137:     | ExposeRegion | ButtonPressed | ButtonReleased);
        !          1138:     /* ButtonReleased is selected for AskUserForArea's benefit */
        !          1139: 
        !          1140:   }
        !          1141: 
        !          1142: /* OuterWindowDims determines the minimum size for the outer window,
        !          1143:    based on three constraints:  the grid square size, the width of
        !          1144:    the command/raster area, and the minimum height of the
        !          1145:    command/raster area ("right side" of the window).  It is called
        !          1146:    at startup time. */
        !          1147: 
        !          1148: OuterWindowDims (square_size, right_side_width,
        !          1149:   right_side_bottom, width, height)
        !          1150:   int square_size, right_side_width, right_side_bottom;
        !          1151:   int *width, *height; /* RETURN */
        !          1152:   {
        !          1153:   *width = LEFT_MARGIN + squares_wide*square_size + 1 + right_side_width;
        !          1154:   *height = TOP_MARGIN + squares_high*square_size + 1 + BOTTOM_MARGIN;
        !          1155:   if (*height < right_side_bottom)
        !          1156:     *height = right_side_bottom;
        !          1157:   }
        !          1158: 
        !          1159: 
        !          1160: ClearOrSetAll(b)
        !          1161:   bit b;  /* 0 for clear, 1 for set */
        !          1162:   {
        !          1163:   register int i;
        !          1164:   register int new = (b ? ~0: 0);
        !          1165:   for (i=0;i<raster_length;i++)
        !          1166:     raster[i] = new;
        !          1167:   changed = TRUE;
        !          1168:   XPixSet (
        !          1169:     grid_window,    /* window */
        !          1170:     0,     /* x */
        !          1171:     0,     /* y */
        !          1172:     squares_wide*square_size+1,        /* width */
        !          1173:     squares_high*square_size+1,        /* height */
        !          1174:     b ? foreground : background);
        !          1175:   RepaintGridLines (b ? e_AgainstForeground : e_AgainstBackground);
        !          1176:   RepaintRaster();
        !          1177:   RepaintRasterInverted();
        !          1178:   if (x_hot_spot != OUT_OF_RANGE)
        !          1179:     HighlightHotSpot();
        !          1180:   }  /* end of ClearAll procedure */
        !          1181: 
        !          1182: 
        !          1183: ClearOrSetArea(b)
        !          1184:   bit b;  /* 0 for clear, 1 for set */
        !          1185:   {
        !          1186:   int x1, y1, x2, y2;
        !          1187:   register int x, y;
        !          1188:   if (AskUserForArea (&x1, &y1, &x2, &y2))
        !          1189:     return;
        !          1190:   for (x=x1;x<=x2;x++)
        !          1191:     for (y=y1;y<=y2;y++)
        !          1192:       SetRasterBit (raster, x, y, b);
        !          1193:   XPixSet (
        !          1194:     grid_window,       /* window */
        !          1195:     x1*square_size+1,  /* x */
        !          1196:     y1*square_size+1,  /* y */
        !          1197:     (x2-x1+1)*square_size-1,  /* width */
        !          1198:     (y2-y1+1)*square_size-1,  /* height */
        !          1199:     b ? foreground : background);
        !          1200:   RepaintGridLinesPartially (x1, y1, x2+1, y2+1, b ? e_AgainstForeground : e_AgainstBackground, FALSE);
        !          1201:   if (x_hot_spot >= x1 && x_hot_spot <= x2
        !          1202:     && y_hot_spot >= y1 && y_hot_spot <= y2)
        !          1203:        HighlightHotSpot();
        !          1204:   changed = TRUE;
        !          1205:   RepaintRaster();
        !          1206:   RepaintRasterInverted();
        !          1207:   x1_square_exed_through = y1_square_exed_through = OUT_OF_RANGE;
        !          1208:   x2_square_exed_through = y2_square_exed_through = OUT_OF_RANGE;
        !          1209:   }  /* end of ClearArea procedure */
        !          1210: 
        !          1211: 
        !          1212: InvertAll() {
        !          1213:   register int i;
        !          1214:   for (i=0;i<raster_length;i++)
        !          1215:     raster[i] ^= ~0;  /* invert = exclusive or with all 1's */
        !          1216:   changed = TRUE;
        !          1217:   XPixFill (
        !          1218:     grid_window,    /* window */
        !          1219:     0,     /* x */
        !          1220:     0,     /* y */
        !          1221:     squares_wide*square_size+1,        /* width */
        !          1222:     squares_high*square_size+1,        /* height */
        !          1223:     1,     /* pixel */
        !          1224:     NULL,   /* clipmask */
        !          1225:     GXinvert,  /* function */
        !          1226:     invertplane);  /* plane mask */
        !          1227:   RepaintGridLines (e_Invert);
        !          1228:   RepaintRaster();
        !          1229:   RepaintRasterInverted();
        !          1230:   }  /* end of InvertAll procedure */
        !          1231: 
        !          1232: 
        !          1233: InvertArea() {
        !          1234:   int x1, y1, x2, y2;
        !          1235:   register int x, y;
        !          1236:   if (AskUserForArea (&x1, &y1, &x2, &y2))
        !          1237:     return;
        !          1238:   for (x=x1;x<=x2;x++)
        !          1239:     for (y=y1;y<=y2;y++)
        !          1240:       InvertRasterBit (raster, x, y);
        !          1241:   ExThroughRectangle (x1, y1, x2, y2);  /* wipe out X-outs */
        !          1242:   XPixFill (
        !          1243:     grid_window,       /* window */
        !          1244:     x1*square_size+1,  /* x */
        !          1245:     y1*square_size+1,  /* y */
        !          1246:     (x2-x1+1)*square_size-1,  /* width */
        !          1247:     (y2-y1+1)*square_size-1,  /* height */
        !          1248:     1,     /* pixel */
        !          1249:     NULL,   /* clipmask */
        !          1250:     GXinvert,  /* function */
        !          1251:     invertplane); /* plane mask */
        !          1252:   RepaintGridLinesPartially (x1, y1, x2+1, y2+1, e_Invert, FALSE);
        !          1253:   changed = TRUE;
        !          1254:   RepaintRaster();
        !          1255:   RepaintRasterInverted();
        !          1256:   x1_square_exed_through = y1_square_exed_through = OUT_OF_RANGE;
        !          1257:   x2_square_exed_through = y2_square_exed_through = OUT_OF_RANGE;
        !          1258:   }  /* end of InvertArea procedure */
        !          1259: 
        !          1260: 
        !          1261: CopyOrMoveArea (move)
        !          1262:   boolean move;
        !          1263:   {
        !          1264:   int x1, y1, x2, y2;
        !          1265:   int x1dest, y1dest;
        !          1266:   if (AskUserForArea (&x1, &y1, &x2, &y2))
        !          1267:     return;
        !          1268:   if (AskUserForDest (&x1dest, &y1dest, x2-x1+1, y2-y1+1))
        !          1269:     /* button released outside grid */
        !          1270:     ExThroughRectangle (x1_square_exed_through, y1_square_exed_through,
        !          1271:       x2_square_exed_through, y2_square_exed_through);
        !          1272:   else {
        !          1273:     register int xsrc, ysrc, xdest, ydest;
        !          1274:     register short *new_raster =
        !          1275:       (short *) malloc (raster_length*sizeof(short));
        !          1276: 
        !          1277:     if (x_hot_spot != OUT_OF_RANGE)
        !          1278:        HighlightHotSpot();  /* actually UNhighlight it */
        !          1279: 
        !          1280:     /* copy whole raster to new raster */
        !          1281:     bcopy (raster, new_raster, raster_length*sizeof(short));
        !          1282:     
        !          1283:     if (move)
        !          1284:       /* clear source bits in new raster.  this is VERY inefficient.
        !          1285:          sure wish we had BitBlt available in user memory! */
        !          1286:       for (xsrc = x1; xsrc <= x2; xsrc++)
        !          1287:         for (ysrc = y1; ysrc <= y2; ysrc++)
        !          1288:          SetRasterBit (new_raster, xsrc, ysrc, 0);
        !          1289: 
        !          1290:     /* copy old source bits to new destination. this is VERY inefficient.
        !          1291:        sure wish we had BitBlt available in user memory! */
        !          1292: 
        !          1293:     for (xsrc = x1, xdest = x1dest;
        !          1294:       xsrc<=x2 && xdest < squares_wide; xsrc++, xdest++) 
        !          1295:         for (ysrc = y1, ydest = y1dest;
        !          1296:           ysrc<=y2 && ydest < squares_high; ysrc++, ydest++)
        !          1297:             SetRasterBit (new_raster, xdest, ydest, 
        !          1298:              GetRasterBit (raster, xsrc, ysrc));
        !          1299: 
        !          1300:     free (raster);
        !          1301:     raster = new_raster;
        !          1302:     if (move)
        !          1303:        RepaintRectangles (x1, y1, x2, y2, x1dest, y1dest);
        !          1304:     else {
        !          1305:        ExThroughRectangle (x1_square_exed_through, y1_square_exed_through,
        !          1306:            x2_square_exed_through, y2_square_exed_through);
        !          1307:        RefillGridPartially (x1dest, y1dest, xdest-1, ydest-1, TRUE);
        !          1308:        }
        !          1309: 
        !          1310:     if (x_hot_spot != OUT_OF_RANGE)
        !          1311:        HighlightHotSpot();  /* put the hot spot back on the screen */
        !          1312: 
        !          1313:     RepaintRaster();
        !          1314:     RepaintRasterInverted();
        !          1315:     changed = TRUE;
        !          1316:     x1_square_plus_through = y1_square_plus_through = OUT_OF_RANGE;
        !          1317:     x2_square_plus_through = y2_square_plus_through = OUT_OF_RANGE;
        !          1318:     }
        !          1319:     
        !          1320:   x1_square_exed_through = y1_square_exed_through = OUT_OF_RANGE;
        !          1321:   x2_square_exed_through = y2_square_exed_through = OUT_OF_RANGE;
        !          1322:   }  /* end of CopyArea procedure */
        !          1323: 
        !          1324: 
        !          1325: ClearHotSpot() {
        !          1326:     if (x_hot_spot == OUT_OF_RANGE)
        !          1327:        return;
        !          1328:     HighlightHotSpot();  /* UNhighlight existing hot spot */
        !          1329:     x_hot_spot = y_hot_spot = OUT_OF_RANGE;
        !          1330:     changed = TRUE;
        !          1331:     }
        !          1332: 
        !          1333: SetHotSpot() {
        !          1334:     XCompressEvents();
        !          1335:     XDefineCursor (outer_window, dot);
        !          1336:     XSelectInput (outer_window, ButtonPressed | ButtonReleased | ExposeWindow);
        !          1337:        /* so that we can detect button pressed outside grid */
        !          1338: 
        !          1339:     while (TRUE) {
        !          1340:        XEvent event;
        !          1341:        int x1, y1;
        !          1342:        XNextEvent (&event);
        !          1343:        switch (event.type) {
        !          1344: 
        !          1345:            case ButtonPressed:
        !          1346:            case MouseMoved:
        !          1347:                if ((event.window == grid_window)
        !          1348:                && !WhatSquare (&event, &x1, &y1)
        !          1349:                && (x_hot_spot != x1 || y_hot_spot != y1)) {
        !          1350: 
        !          1351:                    /* UNhighlight old hot spot */
        !          1352:                    if (x_hot_spot != OUT_OF_RANGE)
        !          1353:                        HighlightHotSpot();  
        !          1354: 
        !          1355:                    x_hot_spot = x1;
        !          1356:                    y_hot_spot = y1;
        !          1357: 
        !          1358:                    /* highlight new hot spot */
        !          1359:                    HighlightHotSpot();
        !          1360: 
        !          1361:                    changed = TRUE;
        !          1362:                    }
        !          1363:                break;  /* keep looping until button is released */
        !          1364: 
        !          1365:            case ButtonReleased:
        !          1366:                XExpandEvents();
        !          1367:                XDefineCursor (outer_window, cross);
        !          1368:                XSelectInput (outer_window, ExposeWindow);
        !          1369:                return;
        !          1370: 
        !          1371:            case ExposeWindow:
        !          1372:            case ExposeRegion:
        !          1373:                ProcessEvent (&event);
        !          1374:                break;
        !          1375:                
        !          1376:            default:
        !          1377:                break;  /* just throw it away */
        !          1378:                
        !          1379:            }
        !          1380:        }
        !          1381:     }
        !          1382: 
        !          1383: RepaintRectangles (x1, y1, x2, y2, x3, y3)
        !          1384:     int x1, y1; /* first rectangle's top & left */
        !          1385:     int x2, y2; /* first rectangle's bottom & right */
        !          1386:     int x3, y3; /* second rectangle's top & left */
        !          1387:     {
        !          1388:     int x4 = x3 + (x2 - x1);  /* second rectangle's right edge */
        !          1389:     int y4 = y3 + (y2 - y1);  /* second rectangle's bottom edge */
        !          1390: 
        !          1391:     if (x4 >= squares_wide) x4 = squares_wide-1;
        !          1392:     if (y4 >= squares_wide) y4 = squares_high-1;
        !          1393: 
        !          1394:     /* if first rectangle is right of second, swap "first" and "second" variables */
        !          1395:     if (x1 > x3)
        !          1396:        {int temp;
        !          1397: #define swap(a,b) {temp = a; a = b; b = temp;}
        !          1398:        swap (x1, x3); swap (y1, y3); swap (x2, x4); swap (y2, y4);
        !          1399: #undef swap
        !          1400:        }
        !          1401:     
        !          1402:     RefillGridPartially (x1, y1, x2, y2, TRUE);
        !          1403: 
        !          1404:     if ((x3 > x2) || (max (y1, y3) > min (y2, y4)))
        !          1405:        /* rectangles don't overlap */
        !          1406:        RefillGridPartially (x3, y3, x4, y4, TRUE);
        !          1407: 
        !          1408:     else if (y1 < y3) {
        !          1409:        /* second rectangle is below & right of first */
        !          1410:        RefillGridPartially (x2+1, y3, x4, y2, TRUE);
        !          1411:        RefillGridPartially (x3, y2+1, x4, y4, TRUE);
        !          1412:        }
        !          1413: 
        !          1414:     else {
        !          1415:        /* second rectangle is above & right of first */
        !          1416:        RefillGridPartially (x3, y3, x4, y1-1, TRUE);
        !          1417:        RefillGridPartially (x2+1, y1, x4, y4, TRUE);
        !          1418:        }
        !          1419:     }
        !          1420: 
        !          1421: 
        !          1422: /* AskUserForArea returns FALSE if the user has defined a valid area,
        !          1423:    TRUE if the user hasn't (e.g. by clicking outside grid) */
        !          1424: 
        !          1425: boolean AskUserForArea(px1, py1, px2, py2) 
        !          1426:   int *px1, *py1, *px2, *py2;
        !          1427:   {
        !          1428:   XEvent event;
        !          1429:   int x1, y1, x2, y2;
        !          1430:   boolean result;
        !          1431: 
        !          1432:   XSelectInput (outer_window, ButtonPressed | ExposeWindow);
        !          1433:     /* so that we can detect button pressed outside grid */
        !          1434: 
        !          1435:   XDefineCursor (outer_window, upper_left);
        !          1436:   
        !          1437:   while (TRUE) {
        !          1438:     XNextEvent (&event);
        !          1439:     switch (event.type) {
        !          1440:       case ButtonPressed:
        !          1441:         if ((event.window != grid_window)
        !          1442:        || WhatSquare (&event, &x1, &y1)) {
        !          1443:           XDefineCursor (outer_window, cross);
        !          1444:          XSelectInput (outer_window, ExposeWindow);
        !          1445:           return (TRUE);
        !          1446:          }
        !          1447:        goto out1;  /* get out of the loop */
        !          1448:       case ExposeWindow:
        !          1449:       case ExposeRegion:
        !          1450:        ProcessEvent (&event);
        !          1451:        break;
        !          1452:       default:
        !          1453:        break;  /* just throw it away */
        !          1454:       }
        !          1455:     }
        !          1456: 
        !          1457:   out1:
        !          1458:   XCompressEvents();  /* DO collapse consecutive MouseMoved events */
        !          1459:   ExThroughSquare (x1, y1);
        !          1460:   FlushLineBuffer();
        !          1461:   x1_square_exed_through = x2_square_exed_through = x2 = x1;
        !          1462:   y1_square_exed_through = y2_square_exed_through = y2 = y1;
        !          1463:   XDefineCursor (outer_window, lower_right);
        !          1464:   
        !          1465:   while (TRUE) {
        !          1466:     XNextEvent (&event);
        !          1467:     switch (event.type) {
        !          1468:       case ButtonPressed:
        !          1469:        result = TRUE;
        !          1470:        goto out2;
        !          1471:       case ExposeWindow:
        !          1472:       case ExposeRegion:
        !          1473:        ProcessEvent (&event);
        !          1474:        break;
        !          1475:       case MouseMoved:
        !          1476:       case ButtonReleased: {
        !          1477:         int x, y;
        !          1478:        result = (event.window != grid_window)
        !          1479:             || WhatSquare (&event, &x, &y)  /* mouse outside grid? */
        !          1480:            || (x < x1) || (y < y1);
        !          1481:        if (result) {
        !          1482:          ExThroughRectangle (x1+1, y1, x2, y2);
        !          1483:          ExThroughRectangle (x1, y1+1, x1, y2);
        !          1484:          x2 = x2_square_exed_through = x1;
        !          1485:          y2 = y2_square_exed_through = y1;
        !          1486:          }
        !          1487:        else if ((x == x2) && (y == y2))
        !          1488:          ; /* both dimensions the same; do nothing */
        !          1489:        else if ((x > x2) == (y > y2)) {
        !          1490:          /* both dimensions bigger or smaller */
        !          1491:          ExThroughRectangle (min(x2,x)+1, y1, max(x2,x), max(y2,y));
        !          1492:          ExThroughRectangle (x1, min(y2,y)+1, min(x2,x), max(y2,y));
        !          1493:          x2 = x2_square_exed_through = x;
        !          1494:          y2 = y2_square_exed_through = y;
        !          1495:          }
        !          1496:         else {
        !          1497:          /* one dimension bigger, the other smaller */
        !          1498:          ExThroughRectangle (min(x2,x)+1, y1, max(x2,x), min(y2,y));
        !          1499:          ExThroughRectangle (x1, min(y2,y)+1, min(x2,x), max(y2,y));
        !          1500:          x2 = x2_square_exed_through = x;
        !          1501:          y2 = y2_square_exed_through = y;
        !          1502:          }
        !          1503:        if (event.type == ButtonReleased)
        !          1504:          goto out2;
        !          1505:        break;
        !          1506:        }
        !          1507:       default:
        !          1508:        break;  /* just throw it away */
        !          1509:       }
        !          1510:     }
        !          1511: 
        !          1512:   out2:
        !          1513:   XSelectInput (outer_window, ExposeWindow);
        !          1514:   XDefineCursor (outer_window, cross);
        !          1515:   if (result) {
        !          1516:     /* no area properly selected; remove X-outs from display */
        !          1517:     ExThroughRectangle (x1, y1, x2, y2);
        !          1518:     x1_square_exed_through = y1_square_exed_through = OUT_OF_RANGE;
        !          1519:     x2_square_exed_through = y2_square_exed_through = OUT_OF_RANGE;
        !          1520:     }
        !          1521:   else {
        !          1522:     *px1 = x1;
        !          1523:     *px2 = x2;
        !          1524:     *py1 = y1;
        !          1525:     *py2 = y2;
        !          1526:     }
        !          1527:   XExpandEvents();
        !          1528:   return (result);
        !          1529:   }  /* end of AskUserForArea procedure */
        !          1530: 
        !          1531: 
        !          1532: boolean AskUserForDest (px1, py1, width, height)
        !          1533:   int *px1, *py1;
        !          1534:   int width, height;
        !          1535:   {
        !          1536:   XEvent event;
        !          1537:   boolean result;
        !          1538:   XCompressEvents();  /* DO collapse consecutive MouseMoved events */
        !          1539:   XSelectInput (outer_window, ButtonPressed | ButtonReleased | ExposeWindow);
        !          1540:     /* so we can detect button action outside grid */
        !          1541:   XDefineCursor (outer_window, upper_left);
        !          1542: 
        !          1543:   while (TRUE) {
        !          1544:     XNextEvent (&event);
        !          1545:     switch (event.type) {
        !          1546: 
        !          1547:       case ExposeWindow:
        !          1548:       case ExposeRegion:
        !          1549:         ProcessEvent (&event);
        !          1550:        break;
        !          1551: 
        !          1552:       case ButtonPressed:
        !          1553:       case MouseMoved: {
        !          1554:        int x1_new, y1_new;
        !          1555:        boolean this_window = (event.window == grid_window)
        !          1556:          && !WhatSquare (&event, &x1_new, &y1_new);
        !          1557: 
        !          1558:        if (this_window && (x1_new == *px1) && (y1_new == *py1))
        !          1559:          break;  /* mouse is still in same square as before; do nothing */
        !          1560: 
        !          1561:         if (x1_square_plus_through != OUT_OF_RANGE)
        !          1562:           PlusThroughRectangle (x1_square_plus_through, y1_square_plus_through,
        !          1563:               x2_square_plus_through, y2_square_plus_through);
        !          1564: 
        !          1565:        if (this_window) {
        !          1566:          *px1 = x1_square_plus_through = x1_new;
        !          1567:          *py1 = y1_square_plus_through = y1_new;
        !          1568:          x2_square_plus_through = min (x1_new + width, squares_wide) - 1;
        !          1569:          y2_square_plus_through = min (y1_new + height, squares_high) - 1;
        !          1570:           PlusThroughRectangle (x1_square_plus_through, y1_square_plus_through,
        !          1571:               x2_square_plus_through, y2_square_plus_through);
        !          1572:          }
        !          1573:        else {
        !          1574:           x1_square_plus_through = y1_square_plus_through = OUT_OF_RANGE;
        !          1575:           x2_square_plus_through = y2_square_plus_through = OUT_OF_RANGE;
        !          1576:          *px1 = *py1 = OUT_OF_RANGE;
        !          1577:          }
        !          1578:         break;
        !          1579:        }
        !          1580: 
        !          1581:       case ButtonReleased: {
        !          1582:         result = (event.window != grid_window)
        !          1583:           || WhatSquare (&event, px1, py1);
        !          1584:        goto out;
        !          1585:        }
        !          1586: 
        !          1587:       default:
        !          1588:         break;  /* throw it away */
        !          1589:       }
        !          1590:     }
        !          1591: 
        !          1592:     out:
        !          1593:     if (result) {
        !          1594:       /* button released outside grid */
        !          1595:       if (x1_square_plus_through != OUT_OF_RANGE)
        !          1596:         PlusThroughRectangle (x1_square_plus_through, y1_square_plus_through,
        !          1597:           x2_square_plus_through, y2_square_plus_through);
        !          1598:       x1_square_plus_through = y1_square_plus_through = OUT_OF_RANGE;
        !          1599:       x2_square_plus_through = y2_square_plus_through = OUT_OF_RANGE;
        !          1600:       }
        !          1601: 
        !          1602:     XExpandEvents();
        !          1603:     XSelectInput (outer_window, ExposeWindow);
        !          1604:     XDefineCursor (outer_window, cross);
        !          1605:     return (result);
        !          1606:     }  /* end of AskUserForDest procedure */
        !          1607: 
        !          1608: 
        !          1609: DialogInputHandler (event)
        !          1610:   XEvent *event;
        !          1611:   {
        !          1612:   switch (event->type) {
        !          1613:     case ExposeWindow:
        !          1614:     case ExposeRegion:
        !          1615:       ProcessEvent (event);
        !          1616:     }
        !          1617:   }
        !          1618: 
        !          1619: enum output_error {e_rename, e_write};
        !          1620: 
        !          1621: /* WriteOutput returns TRUE if output successfully written, FALSE if not */
        !          1622: 
        !          1623: WriteOutput() {
        !          1624:   FILE *file;
        !          1625:   if (!changed)
        !          1626:     return (TRUE);
        !          1627:   if (rename (filename, backup_filename) && errno != ENOENT)
        !          1628:     return (HandleOutputError(e_rename));
        !          1629:   file = fopen (filename, "w+");
        !          1630:   if (!file)
        !          1631:     return (HandleOutputError(e_write));
        !          1632:   WriteOutputToFile (file);
        !          1633:   fclose (file);
        !          1634:   changed = FALSE;
        !          1635:   return (TRUE);
        !          1636:   }
        !          1637: 
        !          1638: 
        !          1639: /* HandleOutputError returns TRUE if alternate file written, FALSE if not */
        !          1640: 
        !          1641: int HandleOutputError(e)
        !          1642:   enum output_error e;
        !          1643:   {
        !          1644:   int result;
        !          1645:   char *strings[2];
        !          1646:   char msg1[120], msg2[120];
        !          1647:   char *tmp_filename;
        !          1648:   if (e == e_rename)
        !          1649:     sprintf (msg1, "Can't rename %s to %s -- %s",
        !          1650:       filename, backup_filename, sys_errlist[errno]);
        !          1651:   else
        !          1652:     sprintf (msg1, "Can't write on file %s -- %s",
        !          1653:       filename, sys_errlist[errno]);
        !          1654:   tmp_filename = TmpFileName (filename);
        !          1655:   sprintf (msg2, "Should I write output to file %s?", tmp_filename);
        !          1656:   strings[0] = "Yes";
        !          1657:   strings[1] = "No";
        !          1658:   result = dialog (outer_window, font, fontInfo.height,
        !          1659:     msg1, msg2, strings, 2, DialogInputHandler);
        !          1660: 
        !          1661:   if (result == 0)  /* "yes" */ {
        !          1662:     filename = tmp_filename;
        !          1663:     free (backup_filename);
        !          1664:     backup_filename = BackupName (filename);
        !          1665:     return (WriteOutput());
        !          1666:     }
        !          1667:   else {  /* "no" */
        !          1668:     free (tmp_filename);
        !          1669:     return (FALSE);
        !          1670:     }
        !          1671:   }
        !          1672: 
        !          1673:     
        !          1674: Quit() {
        !          1675:   if (changed) {
        !          1676:     int result;
        !          1677:     char *strings[3];
        !          1678:     strings[0] = "Yes";
        !          1679:     strings[1] = "No";
        !          1680:     strings[2] = "Cancel";
        !          1681:     result = dialog (outer_window, font, fontInfo.height,
        !          1682:       "Save changes before quitting?", "", strings, 3, DialogInputHandler);
        !          1683:       
        !          1684:     switch (result) {
        !          1685:       case 0:     /* "yes" */
        !          1686:        if (WriteOutput())
        !          1687:          exit(0);
        !          1688:        else return;
        !          1689:       case 1:    /* "no" */
        !          1690:         exit(0);
        !          1691:       default:  /* "cancel" */
        !          1692:        return;
        !          1693:       }
        !          1694:     }
        !          1695: 
        !          1696:   exit(0);
        !          1697:   }
        !          1698: 
        !          1699: HighlightHotSpot() {
        !          1700:   /* Draw a diamond in the hot spot square */
        !          1701:   /* x1 and y1 are the center of the hot spot square */
        !          1702:   register int x1 = x_hot_spot*square_size + square_size/2;
        !          1703:   register int y1 = y_hot_spot*square_size + square_size/2;
        !          1704:   register int radius = square_size/6;
        !          1705:   register int i;
        !          1706:   Vertex v[5];
        !          1707:   v[0].x = v[2].x = v[4].x = x1;
        !          1708:   v[1].x = x1 + radius;
        !          1709:   v[3].x = x1 - radius;
        !          1710:   v[0].y = v[4].y = y1 + radius;
        !          1711:   v[1].y = v[3].y = y1;
        !          1712:   v[2].y = y1 - radius;
        !          1713:   for (i=0;i<5;i++)
        !          1714:     v[i].flags = 0;
        !          1715:   XDraw (grid_window, v, 5, 1, 1, 1, GXinvert, highlightplane);
        !          1716:   }
        !          1717: 
        !          1718: ExThroughRectangle (x1, y1, x2, y2)
        !          1719:   register int x1, y1, x2, y2;
        !          1720:   {
        !          1721:   register int x, y;
        !          1722:   for (x=x1;x<=x2;x++)
        !          1723:     for (y=y1;y<=y2;y++)
        !          1724:       ExThroughSquare (x, y);
        !          1725:   FlushLineBuffer();
        !          1726:   }
        !          1727: 
        !          1728: 
        !          1729: ExThroughSquare (x, y)
        !          1730:   register int x, y;
        !          1731:   {
        !          1732:   register int x1 = x*square_size;
        !          1733:   register int y1 = y*square_size;
        !          1734:   LineIntoBuffer (x1+1, y1+1,
        !          1735:     x1+square_size, y1+square_size);
        !          1736:   LineIntoBuffer (x1+square_size-1, y1+1,
        !          1737:     x1, y1+square_size);
        !          1738:   }
        !          1739: 
        !          1740: 
        !          1741: PlusThroughRectangle (x1, y1, x2, y2)
        !          1742:   register int x1, y1, x2, y2;
        !          1743:   {
        !          1744:   register int x, y;
        !          1745:   for (x=x1;x<=x2;x++)
        !          1746:     for (y=y1;y<=y2;y++)
        !          1747:       PlusThroughSquare (x, y);
        !          1748:   FlushLineBuffer();
        !          1749:   }
        !          1750: 
        !          1751: PlusThroughSquare (x, y)
        !          1752:   register int x, y;
        !          1753:   {
        !          1754:   register int x1 = x*square_size;
        !          1755:   register int y1 = y*square_size;
        !          1756:   LineIntoBuffer (x1+square_size/2, y1+1,
        !          1757:     x1+square_size/2, y1+square_size);
        !          1758:   LineIntoBuffer (x1+1, y1+square_size/2,
        !          1759:     x1+square_size, y1+square_size/2);
        !          1760:   }
        !          1761: 
        !          1762: 
        !          1763: #define BUFFER_MAXLENGTH 200  /* must be even */
        !          1764: static Vertex buffer [BUFFER_MAXLENGTH];
        !          1765: static int buffer_length = 0;
        !          1766: 
        !          1767: LineIntoBuffer (x1, y1, x2, y2) {
        !          1768:   buffer [buffer_length].x = x1;
        !          1769:   buffer [buffer_length].y = y1;
        !          1770:   buffer [buffer_length++].flags = VertexDontDraw;
        !          1771:   buffer [buffer_length].x = x2;
        !          1772:   buffer [buffer_length].y = y2;
        !          1773:   buffer [buffer_length++].flags = 0;
        !          1774:   if (buffer_length == BUFFER_MAXLENGTH)
        !          1775:     FlushLineBuffer();
        !          1776:   }
        !          1777:   
        !          1778: FlushLineBuffer () {
        !          1779:   XDraw (grid_window, buffer, buffer_length, 1, 1, 1, GXinvert,highlightplane);
        !          1780:   buffer_length = 0;
        !          1781:   }
        !          1782: 
        !          1783: #ifdef romp
        !          1784: /* 
        !          1785:  * prerelease IBM RT/PC software does not have ffs in its C library.
        !          1786:  * This code should be thrown away by summer, 1986.
        !          1787:  */
        !          1788: int ffs(i)
        !          1789:    int i;
        !          1790:    {
        !          1791:    int j = 1;
        !          1792:    if (i == 0) return (0);
        !          1793:    while (1) {
        !          1794:         if (i & 1) return (j);
        !          1795:         j++;
        !          1796:         i >>= 1;
        !          1797:         }
        !          1798:    }
        !          1799: 
        !          1800: #endif

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.