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