![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xwud.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 / xwud|
Return to xwud.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / xwud |
1.1 root 1: #include <X/mit-copyright.h>
2:
3: /* Copyright 1985, 1986, Massachusetts Institute of Technology */
4:
5: /*
6: * xwud.c - MIT Project Athena, X Window system window raster image
7: * undumper.
8: *
9: * This program will read a raster image of a window from stdin or a file
10: * and display it on an X display.
11: *
12: * Author: Tony Della Fera, DEC
13: *
14: * Modified 11/14/86 by William F. Wyatt,
15: * Smithsonian Astrophysical Observatory
16: * allows writing of monochrome XYFormat window dump files on a color
17: * display, using default WhitePixel for 1's and BlackPixel for 0's.
18: *
19: * Modified 11/20/86 WFW
20: * VERSION 6 - same as V5 for monochrome, but expects color map info
21: * in the file for color images. Checks to see if the requested
22: * colors are already in the display's map (e.g. if the window dump
23: * and undump are contemporaneous to the same display). If so,
24: * undump immediately. If not, request new colors, alter the
25: * pixels to the new values, then write the pixmap. Note that
26: * multi-plane XY format undumps don't work if the pixel values
27: * corresponding to the requested colors have to be changed.
28: */
29:
30: #ifndef lint
31: static char *rcsid_xwud_c = "$Header: xwud.c,v 10.10 86/11/25 08:44:25 jg Rel $";
32: #endif
33:
34: #include <X/Xlib.h>
35: #include <stdio.h>
36: #include <strings.h>
37: #include <sys/types.h>
38: extern char *calloc();
39:
40: #include <X/XWDFile.h>
41:
42: typedef enum _bool {FALSE, TRUE} Bool;
43:
44: #define MAX(a, b) (a) > (b) ? (a) : (b)
45: #define MIN(a, b) (a) < (b) ? (a) : (b)
46: #define ABS(a) (a) < 0 ? -(a) : (a)
47:
48: #define FAILURE 0
49:
50: extern int errno;
51:
52: main(argc, argv)
53: int argc;
54: char **argv;
55: {
56: register int i;
57: register int *histbuffer;
58: register u_short *wbuffer;
59: register char *buffer;
60:
61: int j, status;
62: int *cpixels, cplanes;
63: int onebufsize;
64: int planes;
65: int forepixel;
66: int backpixel;
67: unsigned buffer_size, total_buffer_size;
68: int win_name_size;
69: char *str_index;
70: char *file_name;
71: char display[256];
72: char *win_name;
73: Bool standard_in = TRUE;
74: Bool newcolors = FALSE, debug = FALSE, inverse = FALSE;
75:
76: Color *pixcolors, *newpixcolors;
77: Display *dpy;
78: Window image_win;
79: Pixmap image_pixmap;
80: XEvent event;
81: register XExposeEvent *xevent = (XExposeEvent *)&event;
82:
83: XWDFileHeader header;
84:
85: FILE *in_file = stdin;
86:
87: for (i = 1; i < argc; i++) {
88: str_index = (char *)index (argv[i], ':');
89: if(str_index != NULL) {
90: (void) strncpy(display,argv[i],sizeof(display));
91: continue;
92: }
93: str_index = (char *) index (argv [i], '-');
94: if (str_index == NULL) Syntax(argv[0]);
95: if (strncmp(argv[i], "-help", 5) == 0) {
96: Syntax(argv[0]);
97: }
98: if (strncmp(argv[i], "-in", 4) == 0) {
99: if (++i >= argc) Syntax(argv[0]);
100: file_name = argv[i];
101: standard_in = FALSE;
102: continue;
103: }
104: if(strcmp(argv[i], "-inverse") == 0) {
105: inverse = TRUE;
106: continue;
107: }
108: if(strcmp(argv[i], "-debug") == 0) {
109: debug = TRUE;
110: continue;
111: }
112: Syntax(argv[0]);
113: }
114:
115: if (!standard_in) {
116: /*
117: * Open the output file.
118: */
119: in_file = fopen(file_name, "r");
120: if (in_file == NULL) {
121: Error("Can't open output file as specified.");
122: }
123: }
124:
125: /*
126: * Open the display.
127: */
128: if ((dpy = XOpenDisplay(display)) == NULL) {
129: fprintf(stderr, "%s: Can't open display '%s'\n",
130: argv[0], XDisplayName(display));
131: exit(1);
132: }
133:
134: /*
135: * Read in header information.
136: */
137: if(fread((char *)&header, sizeof(header), 1, in_file) != 1)
138: Error("Unable to read dump file header.");
139:
140: /*
141: * check to see if the dump file is in the proper format.
142: */
143: if (header.file_version != XWD_FILE_VERSION) {
144: fprintf(stderr,"xwud: XWD file format version missmatch.");
145: if(header.file_version == 5 && header.display_planes == 1)
146: fprintf(stderr,"\n (monochrome works anyway)\n");
147: else Error("exiting.");
148: }
149:
150: if(DisplayPlanes() < header.display_planes)
151: Error("Windump has more planes than display.");
152:
153: /*
154: * Check to see if we are in the right pixmap format for the
155: * display type.
156: */
157: if ((DisplayPlanes() == 1) && (header.pixmap_format != XYFormat)) {
158: Error(
159: "Windump is in ZFormat which is not valid on a monochrome display.");
160: }
161:
162: /*
163: * Calloc window name.
164: */
165: win_name_size = ABS(header.header_size - sizeof(header));
166: if((win_name = calloc((unsigned) win_name_size, sizeof(char))) == NULL)
167: Error("Can't calloc window name storage.");
168:
169: /*
170: * Read in window name.
171: */
172: if(fread(win_name, sizeof(char), win_name_size, in_file) != win_name_size)
173: Error("Unable to read window name from dump file.");
174: if(debug) fprintf(stderr,"win_name =%s\n", win_name);
175:
176: /*
177: * Determine the pixmap size.
178: */
179: if (header.pixmap_format == XYFormat) {
180: buffer_size =
181: XYPixmapSize(
182: header.pixmap_width,
183: header.pixmap_height,
184: header.display_planes);
185: total_buffer_size =
186: XYPixmapSize(
187: header.pixmap_width,
188: header.pixmap_height,
189: DisplayPlanes() );
190: }
191: else if (header.display_planes < 9) {
192: total_buffer_size = buffer_size = BZPixmapSize(
193: header.pixmap_width,
194: header.pixmap_height
195: );
196: }
197: else if(header.display_planes < 17) {
198: total_buffer_size = buffer_size = WZPixmapSize(
199: header.pixmap_width,
200: header.pixmap_height
201: );
202: }
203: else {
204: Error("Can't undump pixmaps more than 16 bits deep.\n");
205: }
206:
207:
208: /* Calloc the color map buffer.
209: * Read it in, copy it and use the copy to query for the
210: * existing colors at those pixel values.
211: */
212: if(header.window_ncolors) {
213: pixcolors = (Color *)calloc(header.window_ncolors,sizeof(Color));
214: if(fread(pixcolors,sizeof(Color),header.window_ncolors, in_file)
215: != header.window_ncolors)
216: Error("Unable to read color map from dump file.");
217: if(debug)
218: fprintf(stderr,"Read %d colors\n", header.window_ncolors);
219: newpixcolors = (Color *)calloc(header.window_ncolors,sizeof(Color));
220: bcopy(pixcolors, newpixcolors, sizeof(Color)*header.window_ncolors);
221: if(XQueryColors(newpixcolors,header.window_ncolors) == 0)
222: Error("Can't query the color map?");
223: for(i=0; i<header.window_ncolors; i++)
224: if(!ColorEqual(&pixcolors[i], &newpixcolors[i])) {
225: newcolors = TRUE;
226: break;
227: }
228: if(debug) {
229: if(newcolors) fprintf(stderr,"New colors needed\n");
230: else fprintf(stderr,"Old colors match!\n");
231: }
232: }
233:
234: /*
235: * Calloc the pixel buffer.
236: */
237: if((buffer = calloc(total_buffer_size, 1)) == NULL)
238: Error("Can't calloc data buffer.");
239: bzero(buffer,total_buffer_size);
240:
241: /*
242: * Read in the pixmap buffer.
243: */
244: if((status = fread(buffer, sizeof(char), (int)buffer_size, in_file))
245: != buffer_size)
246: Error("Unable to read pixmap from dump file.");
247: /*
248: * Close the input file.
249: */
250: (void) fclose(in_file);
251:
252: /*
253: * If necessary, get and store the new colors, convert the pixels to the
254: * new colors appropriately.
255: */
256: if(newcolors) {
257: cpixels = (int *)calloc(header.window_ncolors+1,sizeof(int));
258: if(XGetColorCells(0, header.window_ncolors, 0, &cplanes, cpixels)
259: == 0)
260: Error("Can't allocate colors.");
261: for(i=0; i<header.window_ncolors; i++) {
262: newpixcolors[i].pixel = cpixels[i];
263: newpixcolors[i].red = pixcolors[i].red;
264: newpixcolors[i].green = pixcolors[i].green;
265: newpixcolors[i].blue = pixcolors[i].blue;
266: if(debug)
267: fprintf(stderr,"Pixel %4d, r = %5d g = %5d b = %5d\n",
268: newpixcolors[i].pixel, newpixcolors[i].red,
269: newpixcolors[i].green, newpixcolors[i].blue);
270: }
271: XStoreColors(header.window_ncolors, newpixcolors);
272:
273: /* now, make a lookup table to convert old pixels into the new ones*/
274: if(header.pixmap_format == ZFormat) {
275: if(header.display_planes < 9) {
276: histbuffer = (int *)calloc(256, sizeof(int));
277: bzero(histbuffer, 256*sizeof(int));
278: for(i=0; i<header.window_ncolors; i++)
279: histbuffer[pixcolors[i].pixel] = newpixcolors[i].pixel;
280: for(i=0; i<buffer_size; i++)
281: buffer[i] = histbuffer[buffer[i]];
282: }
283: else if(header.display_planes < 17) {
284: histbuffer = (int *)calloc(65536, sizeof(int));
285: bzero(histbuffer, 65536*sizeof(int));
286: for(i=0; i<header.window_ncolors; i++)
287: histbuffer[pixcolors[i].pixel] = newpixcolors[i].pixel;
288: wbuffer = (u_short *)buffer;
289: for(i=0; i<(buffer_size/sizeof(u_short)); i++)
290: wbuffer[i] = histbuffer[wbuffer[i]];
291: }
292: else if(header.display_planes > 16) {
293: Error("Unable to handle more than 16 planes at this time");
294: }
295: free(histbuffer);
296: }
297: free(cpixels);
298: bcopy(newpixcolors, pixcolors, sizeof(Color)*header.window_ncolors);
299: free(newpixcolors);
300: }
301:
302:
303: /*
304: * Create the image window.
305: */
306: image_win = XCreateWindow(
307: RootWindow,
308: header.window_x, header.window_y,
309: header.pixmap_width, header.pixmap_height,
310: 0, (Pixmap) 0,
311: (Pixmap) 0
312: );
313: if (image_win == FAILURE) Error("Can't create image window.");
314:
315: /*
316: * Select mouse ButtonPressed on the window, this is how we determine
317: * when to stop displaying the window.
318: */
319: XSelectInput(image_win, (ButtonPressed | ExposeWindow | ExposeRegion));
320:
321: /*
322: * Store the window name string.
323: */
324: XStoreName(image_win, win_name);
325:
326: /*
327: * Map the image window.
328: */
329: XMapWindow(image_win);
330:
331: /*
332: * Set up a while loop to maintain the image.
333: */
334: while (TRUE) {
335: int i, nbytes;
336: /*
337: * Wait on mouse input event to terminate.
338: */
339: XNextEvent(&event);
340: if (event.type == ButtonPressed) break;
341:
342: switch((int)event.type) {
343: case ExposeWindow: /* Copy the data into the window.*/
344: case ExposeRegion: /* simpler to copy from x=0 for full width */
345: if(header.pixmap_format == XYFormat) {
346: onebufsize = /* size of each bitmap */
347: XYPixmapSize(header.pixmap_width,
348: header.pixmap_height, 1);
349: nbytes = BitmapSize(header.pixmap_width,1);
350: if(header.display_planes > 1) {
351: forepixel = -1;
352: backpixel = 0;
353: planes = 1<<(DisplayPlanes()); /* MSB << 1 */
354: }
355: else {
356: forepixel = WhitePixel;
357: backpixel = BlackPixel;
358: planes = AllPlanes;
359: }
360: for(j=0; j<header.display_planes; j++) {
361: if(header.display_planes > 1)
362: planes >>= 1; /* shift down a bit */
363: for(i=0; i<xevent->height; i+=100)
364: if(inverse)
365: XBitmapBitsPut(image_win,
366: 0, i + xevent->y,
367: header.pixmap_width,
368: MIN(100, xevent->height - i),
369: buffer+((i+xevent->y)*nbytes)
370: + (onebufsize * j),
371: backpixel, forepixel,
372: 0, GXcopy, planes);
373: else
374: XBitmapBitsPut(image_win,
375: 0, i + xevent->y,
376: header.pixmap_width,
377: MIN(100, xevent->height - i),
378: buffer+((i+xevent->y)*nbytes)
379: + (onebufsize * j),
380: forepixel, backpixel,
381: 0, GXcopy, planes);
382: }
383: }
384: else if(DisplayPlanes() < 9) {
385: nbytes = BZPixmapSize(header.pixmap_width,1);
386: for(i=0; i<xevent->height; i+=100)
387: XPixmapBitsPutZ(image_win,
388: 0, i + xevent->y,
389: header.pixmap_width,
390: MIN(100, xevent->height - i),
391: buffer+((i+xevent->y)*nbytes),
392: 0, GXcopy, AllPlanes);
393: }
394: else { /* Display Planes > 8 */
395: nbytes = WZPixmapSize(header.pixmap_width, 1);
396: for(i=0; i<xevent->height; i+=100)
397: XPixmapBitsPutZ(image_win,
398: 0, i + xevent->y,
399: header.pixmap_width,
400: MIN(50, xevent->height - i),
401: buffer+((i+xevent->y)*nbytes),
402: 0, GXcopy, AllPlanes);
403: }
404: }
405: }
406:
407: /*
408: * Destroy the image window.
409: */
410: XDestroyWindow(image_win);
411:
412: /*
413: * Free the pixmap buffer.
414: */
415: free(buffer);
416:
417: /*
418: * Free window name string.
419: */
420: free(win_name);
421: exit(0);
422: }
423:
424: /*
425: * test two color map entries for equality
426: */
427: ColorEqual(color1, color2)
428: register Color *color1, *color2;
429: {
430: return(color1->pixel == color2->pixel &&
431: color1->red == color2->red &&
432: color1->green == color2->green &&
433: color1->blue == color2->blue);
434: }
435:
436: /*
437: * Report the syntax for calling xwud.
438: */
439: Syntax(call)
440: char *call;
441: {
442: fprintf( stderr,
443: "xwud: %s [-help][-debug][-inverse][-in <file>][[host]:vs]\n",
444: call
445: );
446: exit(1);
447: }
448:
449:
450: /*
451: * Error - Fatal xwud error.
452: */
453: Error(string)
454: char *string; /* Error description string. */
455: {
456: fprintf(stderr, "xwud: Error => %s\n", string);
457:
458: if (errno != 0) {
459: perror("xwud");
460: fprintf(stderr, "\n");
461: }
462:
463: exit(1);
464: }
465:
466: /* End of xwud.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.