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