![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wsimple.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 / xsetroot|
Return to wsimple.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / clients / xsetroot |
1.1 root 1: /* $Header: wsimple.c,v 1.2 87/09/11 22:38:15 rws Exp $ */
2: #include <X11/Xlib.h>
3: #include <X11/Xutil.h>
4: #include <X11/cursorfont.h>
5: #include <stdio.h>
6: /*
7: * Other_stuff.h: Definitions of routines in other_stuff.
8: *
9: * Written by Mark Lillibridge. Last updated 7/1/87
10: *
11: * Send bugs, etc. to [email protected].
12: */
13:
14: unsigned long Resolve_Color();
15: Pixmap Bitmap_To_Pixmap();
16: Window Select_Window();
17: void out();
18: void blip();
19: Window Window_With_Name();
20: /*
21: * Just_display: A group of routines designed to make the writting of simple
22: * X11 applications which open a display but do not open
23: * any windows much faster and easier. Unless a routine says
24: * otherwise, it may be assumed to require program_name, dpy,
25: * and screen already defined on entry.
26: *
27: * Written by Mark Lillibridge. Last updated 7/1/87
28: *
29: * Send bugs, etc. to [email protected].
30: */
31:
32: #include <strings.h>
33:
34: #define NULL 0
35:
36: /* This stuff is defined in the calling program by just_display.h */
37: extern char *program_name;
38: extern Display *dpy;
39: extern int screen;
40:
41:
42: /*
43: * Standard fatal error routine - call like printf but maximum of 7 arguments.
44: * Does not require dpy or screen defined.
45: */
46: void Fatal_Error(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
47: char *msg;
48: char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
49: {
50: fflush(stdout);
51: fflush(stderr);
52: fprintf(stderr, "%s: error: ", program_name);
53: fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
54: fprintf(stderr, "\n");
55: exit(1);
56: }
57:
58:
59: /*
60: * Malloc: like malloc but handles out of memory using Fatal_Error.
61: */
62: char *Malloc(size)
63: unsigned size;
64: {
65: char *data, *malloc();
66:
67: if (!(data = malloc(size)))
68: Fatal_Error("Out of memory!");
69:
70: return(data);
71: }
72:
73:
74: /*
75: * Realloc: like Malloc except for realloc, handles NULL using Malloc.
76: */
77: char *Realloc(ptr, size)
78: char *ptr;
79: int size;
80: {
81: char *new_ptr, *realloc();
82:
83: if (!ptr)
84: return(Malloc(size));
85:
86: if (!(new_ptr = realloc(ptr, size)))
87: Fatal_Error("Out of memory!");
88:
89: return(new_ptr);
90: }
91:
92:
93: /*
94: * Get_Display_Name: Routine which returns the name of the display we
95: * are supposed to use. This is either the display name
96: * given in the list of command arguments or if no name
97: * is given, the value of the DISPLAY environmental
98: * variable. If DISPLAY is unset, NULL is returned.
99: * The main program should pass its command arguments
100: * to this routine. The display argument if any is found
101: * will be removed from the list of command arguments.
102: * Any command argument containing a ':' which occurs
103: * before a '-' is considered to be a display. If
104: * two or more of these occur, only the first will be used.
105: * Does not require dpy or screen defined on entry.
106: */
107: char *Get_Display_Name(argc, argv)
108: int *argc; /* MODIFIED */
109: char **argv; /* MODIFIED */
110: {
111: char *display;
112: char *getenv();
113: int nargc=1;
114: int count;
115: char **nargv;
116:
117: /* Get default display name from environmental variable DISPLAY */
118: display = getenv("DISPLAY");
119:
120: /*
121: * Search for a user supplied overide command argument of the
122: * form host:display and remove it from command arguments if found.
123: */
124: count = *argc;
125: nargv = argv + 1;
126: for (count--, argv++; count>0; count--, argv++) {
127: if (!strcmp("-", *argv)) { /* Don't search past a "-" */
128: break;
129: }
130: if (index(*argv, ':')) {
131: display = *(argv++);
132: count--;
133: break; /* Only use first display name */
134: }
135: *(nargv++) = *argv;
136: nargc++;
137: }
138: while (count>0) {
139: *(nargv++) = *(argv++);
140: nargc++; count--;
141: }
142: *argc = nargc;
143:
144: return(display);
145: }
146:
147:
148: /*
149: * Open_Display: Routine to open a display with correct error handling.
150: * Does not require dpy or screen defined on entry.
151: */
152: Display *Open_Display(display_name)
153: char *display_name;
154: {
155: Display *d;
156:
157: d = XOpenDisplay(display_name);
158: if (d == NULL) {
159: if (display_name == NULL)
160: Fatal_Error("Could not open default display!");
161: else
162: Fatal_Error("Could not open display %s!", display_name);
163: }
164:
165: return(d);
166: }
167:
168:
169: /*
170: * Setup_Display_And_Screen: This routine opens up the correct display (i.e.,
171: * it calls Get_Display_Name) and then stores a
172: * pointer to it in dpy. The default screen
173: * for this display is then stored in screen.
174: * Does not require dpy or screen defined.
175: */
176: void Setup_Display_And_Screen(argc, argv)
177: int *argc; /* MODIFIED */
178: char **argv; /* MODIFIED */
179: {
180: dpy = Open_Display(Get_Display_Name(argc, argv));
181: screen = DefaultScreen(dpy);
182: }
183:
184:
185: /*
186: * Open_Font: This routine opens a font with error handling.
187: */
188: XFontStruct *Open_Font(name)
189: char *name;
190: {
191: XFontStruct *font;
192:
193: if (!(font=XLoadQueryFont(dpy, name)))
194: Fatal_Error("Unable to open font %s!", name);
195:
196: return(font);
197: }
198:
199:
200: /*
201: * Beep: Routine to beep the display.
202: */
203: void Beep()
204: {
205: XBell(dpy, 50);
206: }
207:
208:
209: /*
210: * ReadBitmapFile: same as XReadBitmapFile except it returns the bitmap
211: * directly and handles errors using Fatal_Error.
212: */
213: static void _bitmap_error(status, filename)
214: int status;
215: char *filename;
216: {
217: if (status == BitmapOpenFailed)
218: Fatal_Error("Can't open file %s!", filename);
219: else if (status == BitmapFileInvalid)
220: Fatal_Error("file %s: Bad bitmap format.", filename);
221: else
222: Fatal_Error("Out of memory!");
223: }
224:
225: Pixmap ReadBitmapFile(d, filename, width, height, x_hot, y_hot)
226: Drawable d;
227: char *filename;
228: int *width, *height, *x_hot, *y_hot;
229: {
230: Pixmap bitmap;
231: int status;
232:
233: status = XReadBitmapFile(dpy, RootWindow(dpy, screen), filename, width,
234: height, &bitmap, x_hot, y_hot);
235: if (status != BitmapSuccess)
236: _bitmap_error(status, filename);
237:
238: return(bitmap);
239: }
240:
241:
242: /*
243: * WriteBitmapFile: same as XWriteBitmapFile except it handles errors
244: * using Fatal_Error.
245: */
246: void WriteBitmapFile(filename, bitmap, width, height, x_hot, y_hot)
247: char *filename;
248: Pixmap bitmap;
249: int width, height, x_hot, y_hot;
250: {
251: int status;
252:
253: status= XWriteBitmapFile(dpy, filename, bitmap, width, height, x_hot,
254: y_hot);
255: if (status != BitmapSuccess)
256: _bitmap_error(status, filename);
257: }
258:
259:
260: /*
261: * Select_Window_Args: a rountine to provide a common interface for
262: * applications that need to allow the user to select one
263: * window on the screen for special consideration.
264: * This routine implements the following command line
265: * arguments:
266: *
267: * -root Selects the root window.
268: * -id <id> Selects window with id <id>. <id> may
269: * be either in decimal or hex.
270: * -name <name> Selects the window with name <name>.
271: *
272: * Call as Select_Window_Args(&argc, argv) in main before
273: * parsing any of your program's command line arguments.
274: * Select_Window_Args will remove its arguments so that
275: * your program does not have to worry about them.
276: * The window returned is the window selected or 0 if
277: * none of the above arguments was present. If 0 is
278: * returned, Select_Window should probably be called after
279: * all command line arguments, and other setup is done.
280: * For examples of usage, see xwininfo, xwd, or xprop.
281: */
282: Window Select_Window_Args(rargc, argv)
283: int *rargc;
284: char **argv;
285: #define ARGC (*rargc)
286: {
287: int nargc=1;
288: int argc;
289: char **nargv;
290: Window w=0;
291:
292: nargv = argv+1; argc = ARGC;
293: #define OPTION argv[0]
294: #define NXTOPTP ++argv, --argc>0
295: #define NXTOPT if (++argv, --argc==0) usage()
296: #define COPYOPT nargv++[0]=OPTION; nargc++
297:
298: while (NXTOPTP) {
299: if (!strcmp(OPTION, "-")) {
300: COPYOPT;
301: while (NXTOPTP)
302: COPYOPT;
303: break;
304: }
305: if (!strcmp(OPTION, "-root")) {
306: w=RootWindow(dpy, screen);
307: continue;
308: }
309: if (!strcmp(OPTION, "-name")) {
310: NXTOPT;
311: w = Window_With_Name(dpy, RootWindow(dpy, screen),
312: OPTION);
313: if (!w)
314: Fatal_Error("No window with name %s exists!",OPTION);
315: continue;
316: }
317: if (!strcmp(OPTION, "-id")) {
318: NXTOPT;
319: w=0;
320: sscanf(OPTION, "0x%lx", &w);
321: if (!w)
322: sscanf(OPTION, "%ld", &w);
323: if (!w)
324: Fatal_Error("Invalid window id format: %s.", OPTION);
325: continue;
326: }
327: COPYOPT;
328: }
329: ARGC = nargc;
330:
331: return(w);
332: }
333:
334: /*
335: * Just_one_window: A group of routines designed to make the writting of simple
336: * X11 applications which open a display and exactly one real
337: * window much faster and easier. Unless a routine says
338: * otherwise, it requires program_name, dpy, screen, and
339: * wind to be defined on entry.
340: *
341: * Written by Mark Lillibridge. Last updated 7/1/87
342: *
343: * Send bugs, etc. to [email protected].
344: */
345:
346:
347: #define NULL 0
348:
349: /* This stuff is defined in program by just_display.h */
350: extern char *program_name;
351: extern Display *dpy;
352: extern int screen;
353:
354: /* This stuff is defined in the calling program by just_one_window.h */
355: extern Window wind;
356: extern char **_commands;
357: extern int _number_of_commands;
358: extern char *title, *icon_name, *icon_bitmap_file;
359: extern char *geometry,*border_color, *back_color, *fore_color, *body_font_name;
360: extern int border_width, reverse;
361: extern unsigned long border, background, foreground;
362: extern XFontStruct *body_font;
363: extern XSizeHints size_hints;
364: extern Pixmap icon_pixmap;
365:
366: /*
367: * Get_X_Defaults: This routine reads in the user's .Xdefaults file and
368: * uses it to update the X Options to the user's personal
369: * defaults. Note: this routines does not require wind
370: * defined on entry.
371: */
372: void Get_X_Defaults()
373: {
374: char *option;
375:
376: if (option = XGetDefault(dpy, program_name, "ReverseVideo")) {
377: if (!strcmp("on", option))
378: reverse=1;
379: if (!strcmp("off", option))
380: reverse=0;
381: }
382: if (option = XGetDefault(dpy, program_name, "BorderWidth"))
383: border_width = atoi(option);
384: if (option = XGetDefault(dpy, program_name, "BorderColor"))
385: border_color = option;
386: if (option = XGetDefault(dpy, program_name, "Border"))
387: border_color = option;
388: if (option = XGetDefault(dpy, program_name, "Background"))
389: back_color = option;
390: if (option = XGetDefault(dpy, program_name, "Foreground"))
391: fore_color = option;
392: if (option = XGetDefault(dpy, program_name, "BodyFont"))
393: body_font_name = option;
394: if (option = XGetDefault(dpy, program_name, "Title"))
395: title = option;
396: if (option = XGetDefault(dpy, program_name, "IconName"))
397: icon_name = option;
398: if (option = XGetDefault(dpy, program_name, "IconBitmap"))
399: icon_bitmap_file = option;
400: }
401:
402:
403: /*
404: * Get_X_Arguments: This routine takes a program's command argument list and
405: * extracts all standard X arguments and uses these to
406: * set the X Options with the user's overides. For Options
407: * requiring a lookup to get the real value (e.g., a color)
408: * the lookup is not done and only the name is stored.
409: * The X arguments are removed from the command argument
410: * list by compressing the list. *argc is changed
411: * appropiatly. All arguments looking like a geometry
412: * are also removed unless they follow a '-'. In no case,
413: * are any arguments beyond a singe '-' examined or
414: * changed. This is to allow a file name with a ':'
415: * for instance. The '-' will be left in the argument list.
416: * This routine does not require wind be defined.
417: *
418: */
419: void Get_X_Arguments(argc, argv)
420: int *argc; /* Modified */
421: char **argv; /* Modified */
422: {
423: int i;
424: int nargc;
425: char **nargv;
426:
427: nargv = argv+1;
428: nargc = 1;
429:
430: for (i=1; i<*argc; i++) {
431: if (argv[i][0] == '=') {
432: geometry = argv[i];
433: continue;
434: }
435: if (!strcmp(argv[i],"-rv") || !strcmp(argv[i],"-reverse")) {
436: reverse = 1;
437: continue;
438: }
439: if (!strcmp(argv[i],"-nm") || !strcmp(argv[i],"-normal")) {
440: reverse = 0;
441: continue;
442: }
443: if (!strcmp(argv[i],"-fw") || !strcmp(argv[i],"-forward")) {
444: reverse = 0;
445: continue;
446: }
447: if (!strcmp(argv[i],"-bw") || !strcmp(argv[i],"-borderwidth")){
448: if (++i >= *argc)
449: usage();
450: border_width = atoi(argv[i]);
451: continue;
452: }
453: if (!strcmp(argv[i],"-bd") || !strcmp(argv[i],"-bordercolor")){
454: if (++i >= *argc)
455: usage();
456: border_color = argv[i];
457: continue;
458: }
459: if (!strcmp(argv[i],"-fg") || !strcmp(argv[i],"-foreground")) {
460: if (++i >= *argc)
461: usage();
462: fore_color = argv[i];
463: continue;
464: }
465: if (!strcmp(argv[i],"-bg") || !strcmp(argv[i],"-background")) {
466: if (++i >= *argc)
467: usage();
468: back_color = argv[i];
469: continue;
470: }
471: if (!strcmp(argv[i],"-bf") || !strcmp(argv[i],"-bodyfont")) {
472: if (++i >= *argc)
473: usage();
474: body_font_name = argv[i];
475: continue;
476: }
477: if (!strcmp(argv[i],"-tl") || !strcmp(argv[i],"-title")) {
478: if (++i >= *argc)
479: usage();
480: title = argv[i];
481: continue;
482: }
483: if (!strcmp(argv[i],"-in") || !strcmp(argv[i],"-iconname")) {
484: if (++i >= *argc)
485: usage();
486: icon_name = argv[i];
487: continue;
488: }
489: if (!strcmp(argv[i],"-ib") || !strcmp(argv[i],"-icon")) {
490: if (++i >= *argc)
491: usage();
492: icon_bitmap_file = argv[i];
493: continue;
494: }
495:
496: if (!strcmp(argv[i],"-")) {
497: while (i<*argc) {
498: nargv[0] = argv[i++];
499: nargc++;
500: }
501: continue;
502: }
503:
504: *(nargv++) = argv[i];
505: nargc++;
506: }
507: *argc = nargc;
508: }
509:
510: /*
511: * Get_X_Options: The routine does the "right" thing to get the X Options.
512: * It is provided basically as a binding procedure.
513: * This routine requires only that program_name is defined on
514: * entry. As a side effect, both dpy & screen are setup & the
515: * "right" display is opened.
516: */
517: void Get_X_Options(argc, argv)
518: int *argc; /* Modified */
519: char **argv; /* Modified */
520: {
521: Setup_Display_And_Screen(argc, argv);
522: Get_X_Defaults();
523:
524: Get_X_Arguments(argc, argv);
525: }
526:
527: /*
528: * Resolve_X_Options: This routine takes off where Get_X_Options left off.
529: * It resolves each of the X Options left as names by
530: * Get_X_Options to their real value. Wind need not
531: * be set on entry.
532: * Colors are not resolved. They must be resolved with
533: * Resolve_X_Colors AFTER the window wind is created.
534: */
535: void Resolve_X_Options()
536: {
537: XFontStruct *Open_Font();
538: int status, width, height;
539: Pixmap bitmap;
540: GC gc;
541: XGCValues gc_init;
542: unsigned long temp;
543:
544: /* Handle Geometry */
545: if (geometry) {
546: status = XParseGeometry(geometry, &(size_hints.x),
547: &(size_hints.y),
548: &(size_hints.width),
549: &(size_hints.height));
550: if (status & (XValue|YValue)) {
551: size_hints.flags |= USPosition;
552: size_hints.flags &= ~PPosition;
553: }
554: if (status & (WidthValue|HeightValue)) {
555: size_hints.flags |= USSize;
556: size_hints.flags &= ~PSize;
557: }
558: }
559:
560: /* Handle body font */
561: body_font = Open_Font(body_font_name);
562:
563: /* Handle no icon name specified, default = use title */
564: if (!icon_name)
565: icon_name = title;
566:
567: /* Handle icon bitmap if any */
568: if (icon_bitmap_file) {
569: bitmap = ReadBitmapFile(RootWindow(dpy, screen),
570: icon_bitmap_file,
571: &width, &height, NULL, NULL);
572: gc_init.foreground = Resolve_Color(RootWindow(dpy, screen),
573: fore_color);
574: gc_init.background = Resolve_Color(RootWindow(dpy, screen),
575: back_color);
576: if (reverse) {
577: temp=gc_init.foreground;
578: gc_init.foreground=gc_init.background;
579: gc_init.background=temp;
580: }
581: gc = XCreateGC(dpy, RootWindow(dpy, screen),
582: GCForeground|GCBackground, &gc_init);
583: icon_pixmap = Bitmap_To_Pixmap(dpy, RootWindow(dpy, screen),
584: gc, bitmap, width, height);
585: }
586: }
587:
588: /*
589: * Resolve_X_Colors: This routine resolves the X Options involving colors.
590: * This must be called AFTER the default window has
591: * been created and stored in wind.
592: */
593: void Resolve_X_Colors()
594: {
595: unsigned long temp;
596:
597: foreground = Resolve_Color(wind, fore_color);
598: background = Resolve_Color(wind, back_color);
599: border = Resolve_Color(wind, border_color);
600: if (reverse) {
601: temp = foreground;
602: foreground = background;
603: background = temp;
604: }
605: }
606:
607: /*
608: * Create_Default_Window: This routine is used once the X Options have been
609: * gotten and resolved (except for resolving the colors)
610: * It opens up the default window with the placement,
611: * size, colors, etc. specified by the X Options.
612: * The default window is stored in wind. Wind need
613: * not be defined on entry but the X Options must be
614: * set before entry.
615: */
616: void Create_Default_Window()
617: {
618: wind = XCreateSimpleWindow(dpy, RootWindow(dpy, screen),
619: size_hints.x, size_hints.y,
620: size_hints.width, size_hints.height,
621: border_width, 0, 0);
622: if (!wind)
623: Fatal_Error("Unable to create a window!");
624:
625: Resolve_X_Colors();
626:
627: XSetWindowBackground(dpy, wind, background);
628: XSetWindowBorder(dpy, wind, border);
629:
630: XSetStandardProperties(dpy, wind, title, icon_name, None, _commands,
631: _number_of_commands, &size_hints);
632: }
633:
634: /*
635: * Get_Default: This routine returns a graphics context suitable for use in
636: * drawing into the default window. I.e., it has the right
637: * colors, font, etc. Note: This routine always returns a
638: * new graphics context. X Options must be set on entry.
639: */
640: GC Get_Default_GC()
641: {
642: XGCValues gc_init;
643:
644: gc_init.foreground = foreground;
645: gc_init.background = background;
646: gc_init.font = body_font->fid;
647:
648: return(XCreateGC(dpy, wind, GCFont|GCForeground|GCBackground,
649: &gc_init));
650: }
651:
652:
653: /*
654: * _Save_Commands: internal procedure to save away list of commands to program
655: * and set command name of program.
656: */
657: _Save_Commands(argc, argv)
658: int argc;
659: char **argv;
660: {
661: program_name = argv[0];
662: _number_of_commands = argc;
663:
664: _commands=(char **)Malloc(argc*sizeof(char *));
665:
666: bcopy(argv, _commands, argc*sizeof(char *));
667: }
668: /*
669: * Other_stuff: A group of routines which do common X11 tasks.
670: *
671: * Written by Mark Lillibridge. Last updated 7/1/87
672: *
673: * Send bugs, etc. to [email protected].
674: */
675:
676:
677: #define NULL 0
678:
679: extern Display *dpy;
680: extern int screen;
681:
682: /*
683: * Resolve_Color: This routine takes a color name and returns the pixel #
684: * that when used in the window w will be of color name.
685: * (WARNING: The colormap of w MAY be modified! )
686: * If colors are run out of, only the first n colors will be
687: * as correct as the hardware can make them where n depends
688: * on the display. This routine does not require wind to
689: * be defined.
690: */
691: unsigned long Resolve_Color(w, name)
692: Window w;
693: char *name;
694: {
695: XColor c;
696: Colormap colormap;
697: XWindowAttributes wind_info;
698:
699: /*
700: * The following is a hack to insure machines without a rgb table
701: * handle at least white & black right.
702: */
703: if (!strcmp(name, "white"))
704: name="#ffffffffffff";
705: if (!strcmp(name, "black"))
706: name="#000000000000";
707:
708: XGetWindowAttributes(dpy, w, &wind_info);
709: colormap = wind_info.colormap;
710:
711: if (!XParseColor(dpy, colormap, name, &c))
712: Fatal_Error("Bad color format '%s'.", name);
713:
714: if (!XAllocColor(dpy, colormap, &c))
715: Fatal_Error("XAllocColor failed!");
716:
717: return(c.pixel);
718: }
719:
720:
721: /*
722: * Bitmap_To_Pixmap: Convert a bitmap to a 2 colored pixmap. The colors come
723: * from the foreground and background colors of the gc.
724: * Width and height are required solely for efficiency.
725: * If needed, they can be obtained via. XGetGeometry.
726: */
727: Pixmap Bitmap_To_Pixmap(dpy, d, gc, bitmap, width, height)
728: Display *dpy;
729: Drawable d;
730: GC gc;
731: Pixmap bitmap;
732: int width, height;
733: {
734: Pixmap pix;
735: int x, depth;
736: Drawable root;
737:
738: if (!XGetGeometry(dpy, d, &root, &x, &x, &x, &x, &x, &depth))
739: return(0);
740:
741: pix = XCreatePixmap(dpy, d, width, height, depth);
742:
743: XCopyPlane(dpy, bitmap, pix, gc, 0, 0, width, height, 0, 0, 1);
744:
745: return(pix);
746: }
747:
748:
749: /*
750: * outl: a debugging routine. Flushes stdout then prints a message on stderr
751: * and flushes stderr. Used to print messages when past certain points
752: * in code so we can tell where we are. Outl may be invoked like
753: * printf with up to 7 arguments.
754: */
755: outl(msg, arg0,arg1,arg2,arg3,arg4,arg5,arg6)
756: char *msg;
757: char *arg0, *arg1, *arg2, *arg3, *arg4, *arg5, *arg6;
758: {
759: fflush(stdout);
760: fprintf(stderr, msg, arg0, arg1, arg2, arg3, arg4, arg5, arg6);
761: fprintf(stderr, "\n");
762: fflush(stderr);
763: }
764:
765:
766: /*
767: * blip: a debugging routine. Prints Blip! on stderr with flushing.
768: */
769: void blip()
770: {
771: outl("blip!");
772: }
773:
774:
775: /*
776: * Routine to let user select a window using the mouse
777: */
778:
779: Window Select_Window(dpy)
780: Display *dpy;
781: {
782: int status;
783: Cursor cursor;
784: XEvent event;
785: Window target_win;
786:
787: /* Make the target cursor */
788: cursor = XCreateFontCursor(dpy, XC_crosshair);
789:
790: /* Grab the pointer using target cursor, letting it room all over */
791: status = XGrabPointer(dpy, RootWindow(dpy, screen), True,
792: ButtonPressMask, GrabModeAsync,
793: GrabModeAsync, None, cursor, CurrentTime);
794: if (status != GrabSuccess) Fatal_Error("Can't grab the mouse.");
795:
796: /* Let the user select a window... */
797: XNextEvent(dpy, &event);
798: target_win = event.xbutton.subwindow; /* Get which window selected */
799:
800: XUngrabPointer(dpy, CurrentTime); /* Done with pointer */
801:
802: /* 0 for subwindow means root window */
803: if (target_win == 0)
804: target_win = RootWindow(dpy, screen);
805:
806: return(target_win);
807: }
808:
809:
810: /*
811: * Window_With_Name: routine to locate a window with a given name on a display.
812: * If no window with the given name is found, 0 is returned.
813: * If more than one window has the given name, the first
814: * one found will be returned. Only top and its subwindows
815: * are looked at. Normally, top should be the RootWindow.
816: */
817: Window Window_With_Name(dpy, top, name)
818: Display *dpy;
819: Window top;
820: char *name;
821: {
822: Window *children, dummy;
823: int nchildren, i;
824: Window w=0;
825: char *window_name;
826:
827: if (XFetchName(dpy, top, &window_name) && !strcmp(window_name, name))
828: return(top);
829:
830: if (!XQueryTree(dpy, top, &dummy, &dummy, &children, &nchildren))
831: return(0);
832:
833: for (i=0; i<nchildren; i++) {
834: w = Window_With_Name(dpy, children[i], name);
835: if (w)
836: break;
837: }
838: XFree(children);
839: return(w);
840: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.