1 /* Device functions for X windows.
2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
3 Copyright (C) 1994, 1995 Free Software Foundation, Inc.
5 This file is part of XEmacs.
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Synched up with: Not in FSF. */
24 /* 7-8-00 !!#### This file needs definite Mule review. */
26 /* Original authors: Jamie Zawinski and the FSF */
27 /* Rewritten by Ben Wing and Chuck Thompson. */
32 #include "console-x.h"
33 #include "xintrinsicp.h" /* CoreP.h needs this */
34 #include <X11/CoreP.h> /* Numerous places access the fields of
35 a core widget directly. We could
36 use XtGetValues(), but ... */
38 #include <X11/Shell.h>
41 #include "objects-x.h"
48 #include "redisplay.h"
55 #if defined(HAVE_SHLIB) && defined(LWLIB_USES_ATHENA) && !defined(HAVE_ATHENA_3D)
57 #endif /* HAVE_SHLIB and LWLIB_USES_ATHENA and not HAVE_ATHENA_3D */
63 Lisp_Object Vdefault_x_device;
64 #if defined(MULE) && (defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET))
65 Lisp_Object Vx_app_defaults_directory;
68 /* Qdisplay in general.c */
70 Lisp_Object Qinit_pre_x_win, Qinit_post_x_win;
72 /* The application class of Emacs. */
73 Lisp_Object Vx_emacs_application_class;
75 Lisp_Object Vx_initial_argv_list; /* #### ugh! */
77 static XrmOptionDescRec emacs_options[] =
79 {"-geometry", ".geometry", XrmoptionSepArg, NULL},
80 {"-iconic", ".iconic", XrmoptionNoArg, "yes"},
82 {"-internal-border-width", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL},
83 {"-ib", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL},
84 {"-scrollbar-width", "*EmacsFrame.scrollBarWidth", XrmoptionSepArg, NULL},
85 {"-scrollbar-height", "*EmacsFrame.scrollBarHeight", XrmoptionSepArg, NULL},
87 {"-privatecolormap", ".privateColormap", XrmoptionNoArg, "yes"},
88 {"-visual", ".EmacsVisual", XrmoptionSepArg, NULL},
90 /* #### Beware! If the type of the shell changes, update this. */
91 {"-T", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
92 {"-wn", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
93 {"-title", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
95 {"-iconname", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL},
96 {"-in", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL},
97 {"-mc", "*pointerColor", XrmoptionSepArg, NULL},
98 {"-cr", "*cursorColor", XrmoptionSepArg, NULL},
99 {"-fontset", "*FontSet", XrmoptionSepArg, NULL},
102 /* Functions to synchronize mirroring resources and specifiers */
103 int in_resource_setting;
105 /************************************************************************/
106 /* helper functions */
107 /************************************************************************/
109 /* JH 97/11/25 removed the static declaration because I need it during setup in event-Xt... */
110 struct device * get_device_from_display_1 (Display *dpy);
112 get_device_from_display_1 (Display *dpy)
114 Lisp_Object devcons, concons;
116 DEVICE_LOOP_NO_BREAK (devcons, concons)
118 struct device *d = XDEVICE (XCAR (devcons));
119 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d) == dpy)
127 get_device_from_display (Display *dpy)
129 struct device *d = get_device_from_display_1 (dpy);
131 #if !defined(INFODOCK)
132 # define FALLBACK_RESOURCE_NAME "xemacs"
134 # define FALLBACK_RESOURCE_NAME "infodock"
138 /* This isn't one of our displays. Let's crash? */
140 ("\n%s: Fatal X Condition. Asked about display we don't own: \"%s\"\n",
141 (STRINGP (Vinvocation_name) ?
142 (char *) XSTRING_DATA (Vinvocation_name) : FALLBACK_RESOURCE_NAME),
143 DisplayString (dpy) ? DisplayString (dpy) : "???");
147 #undef FALLBACK_RESOURCE_NAME
153 decode_x_device (Lisp_Object device)
155 XSETDEVICE (device, decode_device (device));
156 CHECK_X_DEVICE (device);
157 return XDEVICE (device);
161 get_x_display (Lisp_Object device)
163 return DEVICE_X_DISPLAY (decode_x_device (device));
167 /************************************************************************/
168 /* initializing an X connection */
169 /************************************************************************/
171 static struct device *device_being_initialized = NULL;
174 allocate_x_device_struct (struct device *d)
176 d->device_data = xnew_and_zero (struct x_device);
180 Xatoms_of_device_x (struct device *d)
182 Display *D = DEVICE_X_DISPLAY (d);
184 DEVICE_XATOM_WM_PROTOCOLS (d) = XInternAtom (D, "WM_PROTOCOLS", False);
185 DEVICE_XATOM_WM_DELETE_WINDOW(d) = XInternAtom (D, "WM_DELETE_WINDOW",False);
186 DEVICE_XATOM_WM_SAVE_YOURSELF(d) = XInternAtom (D, "WM_SAVE_YOURSELF",False);
187 DEVICE_XATOM_WM_TAKE_FOCUS (d) = XInternAtom (D, "WM_TAKE_FOCUS", False);
188 DEVICE_XATOM_WM_STATE (d) = XInternAtom (D, "WM_STATE", False);
192 sanity_check_geometry_resource (Display *dpy)
194 char *app_name, *app_class, *s;
195 char buf1 [255], buf2 [255];
198 XtGetApplicationNameAndClass (dpy, &app_name, &app_class);
199 strcpy (buf1, app_name);
200 strcpy (buf2, app_class);
201 for (s = buf1; *s; s++) if (*s == '.') *s = '_';
202 strcat (buf1, "._no_._such_._resource_.geometry");
203 strcat (buf2, "._no_._such_._resource_.Geometry");
204 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True)
206 warn_when_safe (Qgeometry, Qerror,
208 "Apparently \"%s*geometry: %s\" or \"%s*geometry: %s\" was\n"
209 "specified in the resource database. Specifying \"*geometry\" will make\n"
210 "XEmacs (and most other X programs) malfunction in obscure ways. (i.e.\n"
211 "the Xt or Xm libraries will probably crash, which is a very bad thing.)\n"
212 "You should always use \".geometry\" or \"*EmacsFrame.geometry\" instead.\n",
213 app_name, (char *) value.addr,
214 app_class, (char *) value.addr);
215 suppress_early_error_handler_backtrace = 1;
216 error ("Invalid geometry resource");
221 x_init_device_class (struct device *d)
223 if (DEVICE_X_DEPTH(d) > 2)
225 switch (DEVICE_X_VISUAL(d)->class)
229 DEVICE_CLASS (d) = Qgrayscale;
232 DEVICE_CLASS (d) = Qcolor;
236 DEVICE_CLASS (d) = Qmono;
240 * Figure out what application name to use for xemacs
242 * Since we have decomposed XtOpenDisplay into XOpenDisplay and
243 * XtDisplayInitialize, we no longer get this for free.
245 * If there is a `-name' argument in argv, use that.
246 * Otherwise use the last component of argv[0].
248 * I have removed the gratuitous use of getenv("RESOURCE_NAME")
249 * which was in X11R5, but left the matching of any prefix of `-name'.
250 * Finally, if all else fails, return `xemacs', as it is more
251 * appropriate (X11R5 returns `main').
254 compute_x_app_name (int argc, Extbyte **argv)
259 for (i = 1; i < argc - 1; i++)
260 if (!strncmp(argv[i], "-name", max (2, strlen (argv[1]))))
263 if (argc > 0 && argv[0] && *argv[0])
264 return (ptr = strrchr (argv[0], '/')) ? ++ptr : argv[0];
270 * This function figures out whether the user has any resources of the
271 * form "XEmacs.foo" or "XEmacs*foo".
273 * Currently we only consult the display's global resources; to look
274 * for screen specific resources, we would need to also consult:
275 * xdefs = XScreenResourceString(ScreenOfDisplay(dpy, scrno));
278 have_xemacs_resources_in_xrdb (Display *dpy)
293 xdefs = XResourceManagerString (dpy); /* don't free - owned by X */
294 while (xdefs && *xdefs)
296 if (strncmp (xdefs, key, len) == 0 &&
297 (xdefs[len] == '*' || xdefs[len] == '.'))
300 while (*xdefs && *xdefs++ != '\n') /* find start of next entry.. */
307 /* Only the characters [-_A-Za-z0-9] are allowed in the individual
308 components of a resource. Convert invalid characters to `-' */
310 static char valid_resource_char_p[256];
313 validify_resource_component (char *str, size_t len)
315 for (; len; len--, str++)
316 if (!valid_resource_char_p[(unsigned char) (*str)])
321 Dynarr_add_validified_lisp_string (char_dynarr *cda, Lisp_Object str)
323 Bytecount len = XSTRING_LENGTH (str);
324 Dynarr_add_many (cda, (char *) XSTRING_DATA (str), len);
325 validify_resource_component (Dynarr_atp (cda, Dynarr_length (cda) - len), len);
329 /* compare visual info for qsorting */
331 x_comp_visual_info (const void *elem1, const void *elem2)
333 XVisualInfo *left, *right;
335 left = (XVisualInfo *)elem1;
336 right = (XVisualInfo *)elem2;
343 if ( left->depth > right->depth ) {
346 else if ( left->depth == right->depth ) {
347 if ( left->colormap_size > right->colormap_size )
349 if ( left->class > right->class )
351 else if ( left->class < right->class )
363 #define XXX_IMAGE_LIBRARY_IS_SOMEWHAT_BROKEN
365 x_try_best_visual_class (Screen *screen, int scrnum, int visual_class)
367 Display *dpy = DisplayOfScreen (screen);
369 XVisualInfo *vi_out = NULL;
372 vi_in.class = visual_class;
373 vi_in.screen = scrnum;
374 vi_out = XGetVisualInfo (dpy, (VisualClassMask | VisualScreenMask),
380 for (i = 0, best = 0; i < out_count; i++)
381 /* It's better if it's deeper, or if it's the same depth with
382 more cells (does that ever happen? Well, it could...)
383 NOTE: don't allow pseudo color to get larger than 8! */
384 if (((vi_out [i].depth > vi_out [best].depth) ||
385 ((vi_out [i].depth == vi_out [best].depth) &&
386 (vi_out [i].colormap_size > vi_out [best].colormap_size)))
387 #ifdef XXX_IMAGE_LIBRARY_IS_SOMEWHAT_BROKEN
388 /* For now, the image library doesn't like PseudoColor visuals
389 of depths other than 1 or 8. Depths greater than 8 only occur
390 on machines which have TrueColor anyway, so probably we'll end
391 up using that (it is the one that `Best' would pick) but if a
392 PseudoColor visual is explicitly specified, pick the 8 bit one.
394 && (visual_class != PseudoColor ||
395 vi_out [i].depth == 1 ||
396 vi_out [i].depth == 8)
399 /* SGI has 30-bit deep visuals. Ignore them.
400 (We only have 24-bit data anyway.)
402 && (vi_out [i].depth <= 24)
405 visual = vi_out[best].visual;
406 XFree ((char *) vi_out);
414 x_get_visual_depth (Display *dpy, Visual *visual)
420 vi_in.visualid = XVisualIDFromVisual (visual);
421 vi_out = XGetVisualInfo (dpy, /*VisualScreenMask|*/VisualIDMask,
423 if (! vi_out) abort ();
424 d = vi_out [0].depth;
425 XFree ((char *) vi_out);
430 x_try_best_visual (Display *dpy, int scrnum)
432 Visual *visual = NULL;
433 Screen *screen = ScreenOfDisplay (dpy, scrnum);
434 if ((visual = x_try_best_visual_class (screen, scrnum, TrueColor))
435 && x_get_visual_depth (dpy, visual) >= 16 )
437 if ((visual = x_try_best_visual_class (screen, scrnum, PseudoColor)))
439 if ((visual = x_try_best_visual_class (screen, scrnum, TrueColor)))
441 #ifdef DIRECTCOLOR_WORKS
442 if ((visual = x_try_best_visual_class (screen, scrnum, DirectColor)))
446 visual = DefaultVisualOfScreen (screen);
447 if ( x_get_visual_depth (dpy, visual) >= 8 )
450 if ((visual = x_try_best_visual_class (screen, scrnum, StaticGray)))
452 if ((visual = x_try_best_visual_class (screen, scrnum, GrayScale)))
454 return DefaultVisualOfScreen (screen);
459 x_init_device (struct device *d, Lisp_Object props)
467 const char *app_class;
468 const char *app_name;
469 const char *disp_name;
470 Visual *visual = NULL;
471 int depth = 8; /* shut up the compiler */
475 int best_visual_found = 0;
477 #if defined(HAVE_SHLIB) && defined(LWLIB_USES_ATHENA) && !defined(HAVE_ATHENA_3D)
479 * In order to avoid the lossage with flat Athena widgets dynamically
480 * linking to one of the ThreeD variants, using the dynamic symbol helpers
481 * to look for symbols that shouldn't be there and refusing to run if they
482 * are seems a less toxic idea than having XEmacs crash when we try and
483 * use a subclass of a widget that has changed size.
485 * It's ugly, I know, and not going to work everywhere. It seems better to
486 * do our damnedest to try and tell the user what to expect rather than
487 * simply blow up though.
489 * All the ThreeD variants I have access to define the following function
490 * symbols in the shared library. The flat Xaw library does not define them:
492 * Xaw3dComputeBottomShadowRGB
493 * Xaw3dComputeTopShadowRGB
495 * So far only Linux has shown this problem. This seems to be portable to
496 * all the distributions (certainly all the ones I checked - Debian and
499 * This will only work, sadly, with dlopen() -- the other dynamic linkers
500 * are simply not capable of doing what is needed. :/
504 /* Get a dll handle to the main process. */
505 dll_handle xaw_dll_handle = dll_open (NULL);
507 /* Did that fail? If so, continue without error.
508 * We could die here but, well, that's unfriendly and all -- plus I feel
509 * better about some crashing somewhere rather than preventing a perfectly
510 * good configuration working just because dll_open failed.
512 if (xaw_dll_handle != NULL)
514 /* Look for the Xaw3d function */
515 dll_func xaw_function_handle =
516 dll_function (xaw_dll_handle, "Xaw3dComputeTopShadowRGB");
518 /* If we found it, warn the user in big, nasty, unfriendly letters */
519 if (xaw_function_handle != NULL)
521 warn_when_safe (Qdevice, Qerror, "\n"
522 "It seems that XEmacs is built dynamically linked to the flat Athena widget\n"
523 "library but it finds a 3D Athena variant with the same name at runtime.\n"
525 "This WILL cause your XEmacs process to dump core at some point.\n"
526 "You should not continue to use this binary without resolving this issue.\n"
528 "This can be solved with the xaw-wrappers package under Debian\n"
529 "(register XEmacs as incompatible with all 3d widget sets, see\n"
530 "update-xaw-wrappers(8) and .../doc/xaw-wrappers/README.packagers). It\n"
531 "can be verified by checking the runtime path in /etc/ld.so.conf and by\n"
532 "using `ldd /path/to/xemacs' under other Linux distributions. One\n"
533 "solution is to use LD_PRELOAD or LD_LIBRARY_PATH to force ld.so to\n"
534 "load the flat Athena widget library instead of the aliased 3D widget\n"
535 "library (see ld.so(8) for use of these environment variables).\n\n"
540 /* Otherwise release the handle to the library
541 * No error catch here; I can't think of a way to recover anyhow.
543 dll_close (xaw_dll_handle);
546 #endif /* HAVE_SHLIB and LWLIB_USES_ATHENA and not HAVE_ATHENA_3D */
549 XSETDEVICE (device, d);
550 display = DEVICE_CONNECTION (d);
552 allocate_x_device_struct (d);
554 make_argc_argv (Vx_initial_argv_list, &argc, &argv);
556 LISP_STRING_TO_EXTERNAL (display, disp_name, Qctext);
559 * Break apart the old XtOpenDisplay call into XOpenDisplay and
560 * XtDisplayInitialize so we can figure out whether there
561 * are any XEmacs resources in the resource database before
562 * we initialize Xt. This is so we can automagically support
563 * both `Emacs' and `XEmacs' application classes.
565 slow_down_interrupts ();
566 /* May not be needed but XtOpenDisplay could not deal with signals here. */
567 device_being_initialized = d;
568 dpy = DEVICE_X_DISPLAY (d) = XOpenDisplay (disp_name);
569 device_being_initialized = NULL;
570 speed_up_interrupts ();
574 suppress_early_error_handler_backtrace = 1;
575 signal_simple_error ("X server not responding\n", display);
578 if (STRINGP (Vx_emacs_application_class) &&
579 XSTRING_LENGTH (Vx_emacs_application_class) > 0)
580 LISP_STRING_TO_EXTERNAL (Vx_emacs_application_class, app_class, Qctext);
583 app_class = (NILP (Vx_emacs_application_class) &&
584 have_xemacs_resources_in_xrdb (dpy))
591 /* need to update Vx_emacs_application_class: */
592 Vx_emacs_application_class = build_string (app_class);
595 slow_down_interrupts ();
596 /* May not be needed but XtOpenDisplay could not deal with signals here.
598 XtDisplayInitialize (Xt_app_con, dpy, compute_x_app_name (argc, argv),
599 app_class, emacs_options,
600 XtNumber (emacs_options), &argc, (char **) argv);
601 speed_up_interrupts ();
603 screen = DefaultScreen (dpy);
604 if (NILP (Vdefault_x_device))
605 Vdefault_x_device = device;
608 #if defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET)
610 /* Read in locale-specific resources from
611 data-directory/app-defaults/$LANG/Emacs.
612 This is in addition to the standard app-defaults files, and
613 does not override resources defined elsewhere */
614 const char *data_dir;
616 XrmDatabase db = XtDatabase (dpy); /* #### XtScreenDatabase(dpy) ? */
617 const char *locale = XrmLocaleOfDatabase (db);
619 if (STRINGP (Vx_app_defaults_directory) &&
620 XSTRING_LENGTH (Vx_app_defaults_directory) > 0)
622 LISP_STRING_TO_EXTERNAL (Vx_app_defaults_directory, data_dir, Qfile_name);
623 path = (char *)alloca (strlen (data_dir) + strlen (locale) + 7);
624 sprintf (path, "%s%s/Emacs", data_dir, locale);
625 if (!access (path, R_OK))
626 XrmCombineFileDatabase (path, &db, False);
628 else if (STRINGP (Vdata_directory) && XSTRING_LENGTH (Vdata_directory) > 0)
630 LISP_STRING_TO_EXTERNAL (Vdata_directory, data_dir, Qfile_name);
631 path = (char *)alloca (strlen (data_dir) + 13 + strlen (locale) + 7);
632 sprintf (path, "%sapp-defaults/%s/Emacs", data_dir, locale);
633 if (!access (path, R_OK))
634 XrmCombineFileDatabase (path, &db, False);
637 #endif /* LWLIB_MENUBARS_MOTIF or HAVE_XIM USE_XFONTSET */
640 if (NILP (DEVICE_NAME (d)))
641 DEVICE_NAME (d) = display;
643 /* We're going to modify the string in-place, so be a nice XEmacs */
644 DEVICE_NAME (d) = Fcopy_sequence (DEVICE_NAME (d));
645 /* colons and periods can't appear in individual elements of resource
648 XtGetApplicationNameAndClass (dpy, (char **) &app_name, (char **) &app_class);
649 /* search for a matching visual if requested by the user, or setup the display default */
651 int resource_name_length = max (sizeof (".emacsVisual"),
652 sizeof (".privateColormap"));
653 char *buf1 = alloca_array (char, strlen (app_name) + resource_name_length);
654 char *buf2 = alloca_array (char, strlen (app_class) + resource_name_length);
658 sprintf (buf1, "%s.emacsVisual", app_name);
659 sprintf (buf2, "%s.EmacsVisual", app_class);
660 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True)
663 int vis_class = PseudoColor;
665 char *str = (char*) value.addr;
667 #define CHECK_VIS_CLASS(visual_class) \
668 else if (memcmp (str, #visual_class, sizeof (#visual_class) - 1) == 0) \
669 cnt = sizeof (#visual_class) - 1, vis_class = visual_class
673 CHECK_VIS_CLASS (StaticGray);
674 CHECK_VIS_CLASS (StaticColor);
675 CHECK_VIS_CLASS (TrueColor);
676 CHECK_VIS_CLASS (GrayScale);
677 CHECK_VIS_CLASS (PseudoColor);
678 CHECK_VIS_CLASS (DirectColor);
682 depth = atoi (str + cnt);
685 stderr_out ("Invalid Depth specification in %s... ignoring...\n", str);
689 if (XMatchVisualInfo (dpy, screen, depth, vis_class, &vinfo))
691 visual = vinfo.visual;
695 stderr_out ("Can't match the requested visual %s... using defaults\n", str);
701 stderr_out( "Invalid Visual specification in %s... ignoring.\n", str);
707 visual = DefaultVisual(dpy, screen);
708 depth = DefaultDepth(dpy, screen);
710 visual = x_try_best_visual (dpy, screen);
711 depth = x_get_visual_depth (dpy, visual);
712 best_visual_found = (visual != DefaultVisual (dpy, screen));
715 /* If we've got the same visual as the default and it's PseudoColor,
716 check to see if the user specified that we need a private colormap */
717 if (visual == DefaultVisual (dpy, screen))
719 sprintf (buf1, "%s.privateColormap", app_name);
720 sprintf (buf2, "%s.PrivateColormap", app_class);
721 if ((visual->class == PseudoColor) &&
722 (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True))
724 cmap = XCopyColormapAndFree (dpy, DefaultColormap (dpy, screen));
728 cmap = DefaultColormap (dpy, screen);
733 if ( best_visual_found )
735 cmap = XCreateColormap (dpy, RootWindow (dpy, screen), visual, AllocNone);
739 /* We have to create a matching colormap anyway...
740 #### think about using standard colormaps (need the Xmu libs?) */
741 cmap = XCreateColormap(dpy, RootWindow(dpy, screen), visual, AllocNone);
742 XInstallColormap(dpy, cmap);
747 DEVICE_X_VISUAL (d) = visual;
748 DEVICE_X_COLORMAP (d) = cmap;
749 DEVICE_X_DEPTH (d) = depth;
750 validify_resource_component ((char *) XSTRING_DATA (DEVICE_NAME (d)),
751 XSTRING_LENGTH (DEVICE_NAME (d)));
755 XtSetArg (al[0], XtNvisual, visual);
756 XtSetArg (al[1], XtNdepth, depth);
757 XtSetArg (al[2], XtNcolormap, cmap);
759 app_shell = XtAppCreateShell (NULL, app_class,
760 applicationShellWidgetClass,
761 dpy, al, countof (al));
764 DEVICE_XT_APP_SHELL (d) = app_shell;
768 #endif /* HAVE_XIM */
770 /* Realize the app_shell so that its window exists for GC creation purposes,
771 and set it to the size of the root window for child placement purposes */
774 XtSetArg (al[0], XtNmappedWhenManaged, False);
775 XtSetArg (al[1], XtNx, 0);
776 XtSetArg (al[2], XtNy, 0);
777 XtSetArg (al[3], XtNwidth, WidthOfScreen (ScreenOfDisplay (dpy, screen)));
778 XtSetArg (al[4], XtNheight, HeightOfScreen (ScreenOfDisplay (dpy, screen)));
779 XtSetValues (app_shell, al, countof (al));
780 XtRealizeWidget (app_shell);
783 #ifdef HAVE_WMCOMMAND
787 make_argc_argv (Vcommand_line_args, &new_argc, &new_argv);
788 XSetCommand (XtDisplay (app_shell), XtWindow (app_shell),
789 (char **) new_argv, new_argc);
790 free_argc_argv (new_argv);
792 #endif /* HAVE_WMCOMMAND */
795 #ifdef HAVE_OFFIX_DND
796 DndInitialize ( app_shell );
799 Vx_initial_argv_list = make_arg_list (argc, argv);
800 free_argc_argv (argv);
802 DEVICE_X_WM_COMMAND_FRAME (d) = Qnil;
804 sanity_check_geometry_resource (dpy);
807 x_init_modifier_mapping (d);
809 DEVICE_INFD (d) = DEVICE_OUTFD (d) = ConnectionNumber (dpy);
813 DEVICE_X_GC_CACHE (d) = make_gc_cache (dpy, XtWindow(app_shell));
814 DEVICE_X_GRAY_PIXMAP (d) = None;
815 Xatoms_of_device_x (d);
816 Xatoms_of_select_x (d);
817 Xatoms_of_objects_x (d);
818 x_init_device_class (d);
820 /* Run the elisp side of the X device initialization. */
821 call0 (Qinit_pre_x_win);
825 x_finish_init_device (struct device *d, Lisp_Object props)
827 call0 (Qinit_post_x_win);
831 x_mark_device (struct device *d)
833 mark_object (DEVICE_X_WM_COMMAND_FRAME (d));
834 mark_object (DEVICE_X_DATA (d)->x_keysym_map_hash_table);
838 /************************************************************************/
839 /* closing an X connection */
840 /************************************************************************/
843 free_x_device_struct (struct device *d)
845 xfree (d->device_data);
849 x_delete_device (struct device *d)
854 extern void (*__free_hook) (void *);
858 XSETDEVICE (device, d);
859 display = DEVICE_X_DISPLAY (d);
864 checking_free = (__free_hook != 0);
866 /* Disable strict free checking, to avoid bug in X library */
868 disable_strict_free_check ();
871 free_gc_cache (DEVICE_X_GC_CACHE (d));
872 if (DEVICE_X_DATA (d)->x_modifier_keymap)
873 XFreeModifiermap (DEVICE_X_DATA (d)->x_modifier_keymap);
874 if (DEVICE_X_DATA (d)->x_keysym_map)
875 XFree ((char *) DEVICE_X_DATA (d)->x_keysym_map);
877 if (DEVICE_XT_APP_SHELL (d))
879 XtDestroyWidget (DEVICE_XT_APP_SHELL (d));
880 DEVICE_XT_APP_SHELL (d) = NULL;
883 XtCloseDisplay (display);
884 DEVICE_X_DISPLAY (d) = 0;
887 enable_strict_free_check ();
891 if (EQ (device, Vdefault_x_device))
893 Lisp_Object devcons, concons;
894 /* #### handle deleting last X device */
895 Vdefault_x_device = Qnil;
896 DEVICE_LOOP_NO_BREAK (devcons, concons)
898 if (DEVICE_X_P (XDEVICE (XCAR (devcons))) &&
899 !EQ (device, XCAR (devcons)))
901 Vdefault_x_device = XCAR (devcons);
907 free_x_device_struct (d);
911 /************************************************************************/
912 /* handle X errors */
913 /************************************************************************/
916 x_event_name (int event_type)
918 static const char *events[] =
958 if (event_type < 0 || event_type >= countof (events))
960 return events [event_type];
965 If an X error occurs which we are not expecting, we have no alternative
966 but to print it to stderr. It would be nice to stuff it into a pop-up
967 buffer, or to print it in the minibuffer, but that's not possible, because
968 one is not allowed to do any I/O on the display connection from an error
969 handler. The guts of Xlib expect these functions to either return or exit.
971 However, there are occasions when we might expect an error to reasonably
972 occur. The interface to this is as follows:
974 Before calling some X routine which may error, call
975 expect_x_error (dpy);
977 Just after calling the X routine, call either:
979 x_error_occurred_p (dpy);
981 to ask whether an error happened (and was ignored), or:
983 signal_if_x_error (dpy, resumable_p);
985 which will call Fsignal() with args appropriate to the X error, if there
986 was one. (Resumable_p is whether the debugger should be allowed to
987 continue from the call to signal.)
989 You must call one of these two routines immediately after calling the X
990 routine; think of them as bookends like BLOCK_INPUT and UNBLOCK_INPUT.
993 static int error_expected;
994 static int error_occurred;
995 static XErrorEvent last_error;
999 #ifdef EXTERNAL_WIDGET
1001 x_error_handler_do_enqueue (Lisp_Object frame)
1003 enqueue_magic_eval_event (io_error_delete_frame, frame);
1008 x_error_handler_error (Lisp_Object data, Lisp_Object dummy)
1012 #endif /* EXTERNAL_WIDGET */
1015 x_error_handler (Display *disp, XErrorEvent *event)
1021 last_error = *event;
1025 #ifdef EXTERNAL_WIDGET
1027 struct device *d = get_device_from_display (disp);
1029 if ((event->error_code == BadWindow ||
1030 event->error_code == BadDrawable)
1031 && ((f = x_any_window_to_frame (d, event->resourceid)) != 0))
1035 /* one of the windows comprising one of our frames has died.
1036 This occurs particularly with ExternalShell frames when the
1037 client that owns the ExternalShell's window dies.
1039 We cannot do any I/O on the display connection so we need
1040 to enqueue an eval event so that the deletion happens
1043 Furthermore, we need to trap any errors (out-of-memory) that
1044 may occur when Fenqueue_eval_event is called.
1047 if (f->being_deleted)
1049 XSETFRAME (frame, f);
1050 if (!NILP (condition_case_1 (Qerror, x_error_handler_do_enqueue,
1051 frame, x_error_handler_error, Qnil)))
1053 f->being_deleted = 1;
1058 #endif /* EXTERNAL_WIDGET */
1060 stderr_out ("\n%s: ",
1061 (STRINGP (Vinvocation_name)
1062 ? (char *) XSTRING_DATA (Vinvocation_name)
1064 XmuPrintDefaultErrorMessage (disp, event, stderr);
1070 expect_x_error (Display *dpy)
1072 assert (!error_expected);
1073 XSync (dpy, 0); /* handle pending errors before setting flag */
1079 x_error_occurred_p (Display *dpy)
1082 XSync (dpy, 0); /* handle pending errors before setting flag */
1083 val = error_occurred;
1090 signal_if_x_error (Display *dpy, int resumable_p)
1094 if (! x_error_occurred_p (dpy))
1097 sprintf (buf, "0x%X", (unsigned int) last_error.resourceid);
1098 data = Fcons (build_string (buf), data);
1101 sprintf (num, "%d", last_error.request_code);
1102 XGetErrorDatabaseText (last_error.display, "XRequest", num, "",
1105 sprintf (buf, "Request-%d", last_error.request_code);
1106 data = Fcons (build_string (buf), data);
1108 XGetErrorText (last_error.display, last_error.error_code, buf, sizeof (buf));
1109 data = Fcons (build_string (buf), data);
1111 Fsignal (Qx_error, data);
1112 if (! resumable_p) goto again;
1117 x_IO_error_handler (Display *disp)
1119 /* This function can GC */
1121 struct device *d = get_device_from_display_1 (disp);
1124 d = device_being_initialized;
1127 XSETDEVICE (dev, d);
1129 if (NILP (find_nonminibuffer_frame_not_on_device (dev)))
1131 /* We're going down. */
1133 ("\n%s: Fatal I/O Error %d (%s) on display connection \"%s\"\n",
1134 (STRINGP (Vinvocation_name) ?
1135 (char *) XSTRING_DATA (Vinvocation_name) : "xemacs"),
1136 errno, strerror (errno), DisplayString (disp));
1138 (" after %lu requests (%lu known processed) with %d events remaining.\n",
1139 NextRequest (disp) - 1, LastKnownRequestProcessed (disp),
1141 /* assert (!_Xdebug); */
1147 "I/O Error %d (%s) on display connection\n"
1148 " \"%s\" after after %lu requests (%lu known processed)\n"
1149 " with %d events remaining.\n"
1150 " Throwing to top level.\n",
1151 errno, strerror (errno), DisplayString (disp),
1152 NextRequest (disp) - 1, LastKnownRequestProcessed (disp),
1156 /* According to X specs, we should not return from this function, or
1157 Xlib might just decide to exit(). So we mark the offending
1158 console for deletion and throw to top level. */
1160 enqueue_magic_eval_event (io_error_delete_device, dev);
1161 DEVICE_X_BEING_DELETED (d) = 1;
1162 Fthrow (Qtop_level, Qnil);
1164 return 0; /* not reached */
1167 DEFUN ("x-debug-mode", Fx_debug_mode, 1, 2, 0, /*
1168 With a true arg, make the connection to the X server synchronous.
1169 With false, make it asynchronous. Synchronous connections are much slower,
1170 but are useful for debugging. (If you get X errors, make the connection
1171 synchronous, and use a debugger to set a breakpoint on `x_error_handler'.
1172 Your backtrace of the C stack will now be useful. In asynchronous mode,
1173 the stack above `x_error_handler' isn't helpful because of buffering.)
1174 If DEVICE is not specified, the selected device is assumed.
1176 Calling this function is the same as calling the C function `XSynchronize',
1177 or starting the program with the `-sync' command line argument.
1181 struct device *d = decode_x_device (device);
1183 XSynchronize (DEVICE_X_DISPLAY (d), !NILP (arg));
1186 message ("X connection is synchronous");
1188 message ("X connection is asynchronous");
1194 /************************************************************************/
1196 /************************************************************************/
1198 #if 0 /* bah humbug. The whole "widget == resource" stuff is such
1199 a crock of shit that I'm just going to ignore it all. */
1201 /* If widget is NULL, we are retrieving device or global face data. */
1204 construct_name_list (Display *display, Widget widget, char *fake_name,
1205 char *fake_class, char *name, char *class)
1207 char *stack [100][2];
1210 char *name_tail, *class_tail;
1214 for (this = widget; this; this = XtParent (this))
1216 stack [count][0] = this->core.name;
1217 stack [count][1] = XtClass (this)->core_class.class_name;
1222 else if (fake_name && fake_class)
1224 stack [count][0] = fake_name;
1225 stack [count][1] = fake_class;
1229 /* The root widget is an application shell; resource lookups use the
1230 specified application name and application class in preference to
1231 the name/class of that widget (which is argv[0] / "ApplicationShell").
1232 Generally the app name and class will be argv[0] / "Emacs" but
1233 the former can be set via the -name command-line option, and the
1234 latter can be set by changing `x-emacs-application-class' in
1237 XtGetApplicationNameAndClass (display,
1246 for (; count >= 0; count--)
1248 strcat (name_tail, stack [count][0]);
1249 for (; *name_tail; name_tail++)
1250 if (*name_tail == '.') *name_tail = '_';
1251 strcat (name_tail, ".");
1254 strcat (class_tail, stack [count][1]);
1255 for (; *class_tail; class_tail++)
1256 if (*class_tail == '.') *class_tail = '_';
1257 strcat (class_tail, ".");
1264 /* strcasecmp() is not sufficiently portable or standard,
1265 and it's easier just to write our own. */
1267 ascii_strcasecmp (const char *s1, const char *s2)
1273 if (c1 >= 'A' && c1 <= 'Z') c1 += 'a' - 'A';
1274 if (c2 >= 'A' && c2 <= 'Z') c2 += 'a' - 'A';
1275 if (c1 != c2) return c1 - c2;
1276 if (c1 == '\0') return 0;
1280 static char_dynarr *name_char_dynarr;
1281 static char_dynarr *class_char_dynarr;
1283 /* Given a locale and device specification from x-get-resource or
1284 x-get-resource-prefix, return the resource prefix and display to
1285 fetch the resource on. */
1288 x_get_resource_prefix (Lisp_Object locale, Lisp_Object device,
1289 Display **display_out, char_dynarr *name,
1294 if (NILP (Fvalid_specifier_locale_p (locale)))
1295 signal_simple_error ("Invalid locale", locale);
1296 if (WINDOWP (locale))
1297 /* #### I can't come up with any coherent way of naming windows.
1298 By relative position? That seems tricky because windows
1299 can change position, be split, etc. By order of creation?
1300 That seems less than useful. */
1301 signal_simple_error ("Windows currently can't be resourced", locale);
1303 if (!NILP (device) && !DEVICEP (device))
1304 CHECK_DEVICE (device);
1305 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device)))
1309 device = DFW_DEVICE (locale);
1310 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device)))
1313 device = Vdefault_x_device;
1321 *display_out = DEVICE_X_DISPLAY (XDEVICE (device));
1324 char *appname, *appclass;
1325 int name_len, class_len;
1326 XtGetApplicationNameAndClass (*display_out, &appname, &appclass);
1327 name_len = strlen (appname);
1328 class_len = strlen (appclass);
1329 Dynarr_add_many (name , appname, name_len);
1330 Dynarr_add_many (class, appclass, class_len);
1331 validify_resource_component (Dynarr_atp (name, 0), name_len);
1332 validify_resource_component (Dynarr_atp (class, 0), class_len);
1335 if (EQ (locale, Qglobal))
1337 if (BUFFERP (locale))
1339 Dynarr_add_literal_string (name, ".buffer.");
1340 /* we know buffer is live; otherwise we got an error above. */
1341 Dynarr_add_validified_lisp_string (name, Fbuffer_name (locale));
1342 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsBuffer");
1344 else if (FRAMEP (locale))
1346 Dynarr_add_literal_string (name, ".frame.");
1347 /* we know frame is live; otherwise we got an error above. */
1348 Dynarr_add_validified_lisp_string (name, Fframe_name (locale));
1349 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsFrame");
1353 assert (DEVICEP (locale));
1354 Dynarr_add_literal_string (name, ".device.");
1355 /* we know device is live; otherwise we got an error above. */
1356 Dynarr_add_validified_lisp_string (name, Fdevice_name (locale));
1357 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsDevice");
1362 DEFUN ("x-get-resource", Fx_get_resource, 3, 6, 0, /*
1363 Retrieve an X resource from the resource manager.
1365 The first arg is the name of the resource to retrieve, such as "font".
1366 The second arg is the class of the resource to retrieve, such as "Font".
1367 The third arg must be one of the symbols 'string, 'integer, 'natnum, or
1368 'boolean, specifying the type of object that the database is searched for.
1369 The fourth arg is the locale to search for the resources on, and can
1370 currently be a buffer, a frame, a device, or 'global. If omitted, it
1371 defaults to 'global.
1372 The fifth arg is the device to search for the resources on. (The resource
1373 database for a particular device is constructed by combining non-device-
1374 specific resources such as any command-line resources specified and any
1375 app-defaults files found [or the fallback resources supplied by XEmacs,
1376 if no app-defaults file is found] with device-specific resources such as
1377 those supplied using xrdb.) If omitted, it defaults to the device of
1378 LOCALE, if a device can be derived (i.e. if LOCALE is a frame or device),
1379 and otherwise defaults to the value of `default-x-device'.
1380 The sixth arg NOERROR, if non-nil, means do not signal an error if a
1381 bogus resource specification was retrieved (e.g. if a non-integer was
1382 given when an integer was requested). In this case, a warning is issued
1383 instead, unless NOERROR is t, in which case no warning is issued.
1385 The resource names passed to this function are looked up relative to the
1388 If you want to search for a subresource, you just need to specify the
1389 resource levels in NAME and CLASS. For example, NAME could be
1390 "modeline.attributeFont", and CLASS "Face.AttributeFont".
1394 1) If LOCALE is a buffer, a call
1396 (x-get-resource "foreground" "Foreground" 'string SOME-BUFFER)
1398 is an interface to a C call something like
1400 XrmGetResource (db, "xemacs.buffer.BUFFER-NAME.foreground",
1401 "Emacs.EmacsLocaleType.EmacsBuffer.Foreground",
1404 2) If LOCALE is a frame, a call
1406 (x-get-resource "foreground" "Foreground" 'string SOME-FRAME)
1408 is an interface to a C call something like
1410 XrmGetResource (db, "xemacs.frame.FRAME-NAME.foreground",
1411 "Emacs.EmacsLocaleType.EmacsFrame.Foreground",
1414 3) If LOCALE is a device, a call
1416 (x-get-resource "foreground" "Foreground" 'string SOME-DEVICE)
1418 is an interface to a C call something like
1420 XrmGetResource (db, "xemacs.device.DEVICE-NAME.foreground",
1421 "Emacs.EmacsLocaleType.EmacsDevice.Foreground",
1424 4) If LOCALE is 'global, a call
1426 (x-get-resource "foreground" "Foreground" 'string 'global)
1428 is an interface to a C call something like
1430 XrmGetResource (db, "xemacs.foreground",
1434 Note that for 'global, no prefix is added other than that of the
1435 application itself; thus, you can use this locale to retrieve
1436 arbitrary application resources, if you really want to.
1438 The returned value of this function is nil if the queried resource is not
1439 found. If the third arg is `string', a string is returned, and if it is
1440 `integer', an integer is returned. If the third arg is `boolean', then the
1441 returned value is the list (t) for true, (nil) for false, and is nil to
1442 mean ``unspecified''.
1444 (name, class, type, locale, device, noerror))
1446 char* name_string, *class_string;
1450 Error_behavior errb = decode_error_behavior_flag (noerror);
1452 CHECK_STRING (name);
1453 CHECK_STRING (class);
1454 CHECK_SYMBOL (type);
1456 Dynarr_reset (name_char_dynarr);
1457 Dynarr_reset (class_char_dynarr);
1459 x_get_resource_prefix (locale, device, &display,
1460 name_char_dynarr, class_char_dynarr);
1464 db = XtDatabase (display);
1466 Dynarr_add (name_char_dynarr, '.');
1467 Dynarr_add_lisp_string (name_char_dynarr, name);
1468 Dynarr_add (class_char_dynarr, '.');
1469 Dynarr_add_lisp_string (class_char_dynarr, class);
1470 Dynarr_add (name_char_dynarr, '\0');
1471 Dynarr_add (class_char_dynarr, '\0');
1473 name_string = Dynarr_atp (name_char_dynarr, 0);
1474 class_string = Dynarr_atp (class_char_dynarr, 0);
1478 XrmName namelist[100];
1479 XrmClass classlist[100];
1480 XrmName *namerest = namelist;
1481 XrmClass *classrest = classlist;
1482 XrmRepresentation xrm_type;
1483 XrmRepresentation string_quark;
1485 XrmStringToNameList (name_string, namelist);
1486 XrmStringToClassList (class_string, classlist);
1487 string_quark = XrmStringToQuark ("String");
1489 /* ensure that they have the same length */
1490 while (namerest[0] && classrest[0])
1491 namerest++, classrest++;
1492 if (namerest[0] || classrest[0])
1493 signal_simple_error_2
1494 ("class list and name list must be the same length", name, class);
1495 result = XrmQGetResource (db, namelist, classlist, &xrm_type, &xrm_value);
1497 if (result != True || xrm_type != string_quark)
1499 raw_result = (char *) xrm_value.addr;
1502 if (EQ (type, Qstring))
1503 return build_string (raw_result);
1504 else if (EQ (type, Qboolean))
1506 if (!ascii_strcasecmp (raw_result, "off") ||
1507 !ascii_strcasecmp (raw_result, "false") ||
1508 !ascii_strcasecmp (raw_result, "no"))
1509 return Fcons (Qnil, Qnil);
1510 if (!ascii_strcasecmp (raw_result, "on") ||
1511 !ascii_strcasecmp (raw_result, "true") ||
1512 !ascii_strcasecmp (raw_result, "yes"))
1513 return Fcons (Qt, Qnil);
1514 return maybe_continuable_error
1516 "can't convert %s: %s to a Boolean", name_string, raw_result);
1518 else if (EQ (type, Qinteger) || EQ (type, Qnatnum))
1522 if (1 != sscanf (raw_result, "%d%c", &i, &c))
1523 return maybe_continuable_error
1525 "can't convert %s: %s to an integer", name_string, raw_result);
1526 else if (EQ (type, Qnatnum) && i < 0)
1527 return maybe_continuable_error
1529 "invalid numerical value %d for resource %s", i, name_string);
1531 return make_int (i);
1535 return maybe_signal_continuable_error
1536 (Qwrong_type_argument,
1537 list2 (build_translated_string
1538 ("should be string, integer, natnum or boolean"),
1544 DEFUN ("x-get-resource-prefix", Fx_get_resource_prefix, 1, 2, 0, /*
1545 Return the resource prefix for LOCALE on DEVICE.
1546 The resource prefix is the strings used to prefix resources if
1547 the LOCALE and DEVICE arguments were passed to `x-get-resource'.
1548 The returned value is a cons of a name prefix and a class prefix.
1549 For example, if LOCALE is a frame, the returned value might be
1550 \("xemacs.frame.FRAME-NAME" . "Emacs.EmacsLocaleType.EmacsFrame").
1551 If no valid X device for resourcing can be obtained, this function
1552 returns nil. (In such a case, `x-get-resource' would always return nil.)
1558 Dynarr_reset (name_char_dynarr );
1559 Dynarr_reset (class_char_dynarr);
1561 x_get_resource_prefix (locale, device, &display,
1562 name_char_dynarr, class_char_dynarr);
1566 return Fcons (make_string ((Bufbyte *) Dynarr_atp (name_char_dynarr, 0),
1567 Dynarr_length (name_char_dynarr)),
1568 make_string ((Bufbyte *) Dynarr_atp (class_char_dynarr, 0),
1569 Dynarr_length (class_char_dynarr)));
1572 DEFUN ("x-put-resource", Fx_put_resource, 1, 2, 0, /*
1573 Add a resource to the resource database for DEVICE.
1574 RESOURCE-LINE specifies the resource to add and should be a
1575 standard resource specification.
1577 (resource_line, device))
1579 struct device *d = decode_device (device);
1580 char *str, *colon_pos;
1582 CHECK_STRING (resource_line);
1583 str = (char *) XSTRING_DATA (resource_line);
1584 if (!(colon_pos = strchr (str, ':')) || strchr (str, '\n'))
1586 signal_simple_error ("Invalid resource line", resource_line);
1588 /* Only the following chars are allowed before the colon */
1589 " \t.*?abcdefghijklmnopqrstuvwxyz"
1590 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
1591 != (size_t) (colon_pos - str))
1596 XrmDatabase db = XtDatabase (DEVICE_X_DISPLAY (d));
1597 XrmPutLineResource (&db, str);
1604 /************************************************************************/
1605 /* display information functions */
1606 /************************************************************************/
1608 DEFUN ("default-x-device", Fdefault_x_device, 0, 0, 0, /*
1609 Return the default X device for resourcing.
1610 This is the first-created X device that still exists.
1614 return Vdefault_x_device;
1617 DEFUN ("x-display-visual-class", Fx_display_visual_class, 0, 1, 0, /*
1618 Return the visual class of the X display DEVICE is using.
1619 This can be altered from the default at startup using the XResource "EmacsVisual".
1620 The returned value will be one of the symbols `static-gray', `gray-scale',
1621 `static-color', `pseudo-color', `true-color', or `direct-color'.
1625 Visual *vis = DEVICE_X_VISUAL (decode_x_device (device));
1628 case StaticGray: return intern ("static-gray");
1629 case GrayScale: return intern ("gray-scale");
1630 case StaticColor: return intern ("static-color");
1631 case PseudoColor: return intern ("pseudo-color");
1632 case TrueColor: return intern ("true-color");
1633 case DirectColor: return intern ("direct-color");
1635 error ("display has an unknown visual class");
1636 return Qnil; /* suppress compiler warning */
1640 DEFUN ("x-display-visual-depth", Fx_display_visual_depth, 0, 1, 0, /*
1641 Return the bitplane depth of the visual the X display DEVICE is using.
1645 return make_int (DEVICE_X_DEPTH (decode_x_device (device)));
1649 x_device_system_metrics (struct device *d,
1650 enum device_metrics m)
1652 Display *dpy = DEVICE_X_DISPLAY (d);
1656 case DM_size_device:
1657 return Fcons (make_int (DisplayWidth (dpy, DefaultScreen (dpy))),
1658 make_int (DisplayHeight (dpy, DefaultScreen (dpy))));
1659 case DM_size_device_mm:
1660 return Fcons (make_int (DisplayWidthMM (dpy, DefaultScreen (dpy))),
1661 make_int (DisplayHeightMM (dpy, DefaultScreen (dpy))));
1662 case DM_num_bit_planes:
1663 return make_int (DisplayPlanes (dpy, DefaultScreen (dpy)));
1664 case DM_num_color_cells:
1665 return make_int (DisplayCells (dpy, DefaultScreen (dpy)));
1666 default: /* No such device metric property for X devices */
1671 DEFUN ("x-server-vendor", Fx_server_vendor, 0, 1, 0, /*
1672 Return the vendor ID string of the X server DEVICE is on.
1673 Return the empty string if the vendor ID string cannot be determined.
1677 Display *dpy = get_x_display (device);
1678 char *vendor = ServerVendor (dpy);
1680 return build_string (vendor ? vendor : "");
1683 DEFUN ("x-server-version", Fx_server_version, 0, 1, 0, /*
1684 Return the version numbers of the X server DEVICE is on.
1685 The returned value is a list of three integers: the major and minor
1686 version numbers of the X Protocol in use, and the vendor-specific release
1687 number. See also `x-server-vendor'.
1691 Display *dpy = get_x_display (device);
1693 return list3 (make_int (ProtocolVersion (dpy)),
1694 make_int (ProtocolRevision (dpy)),
1695 make_int (VendorRelease (dpy)));
1698 DEFUN ("x-valid-keysym-name-p", Fx_valid_keysym_name_p, 1, 1, 0, /*
1699 Return true if KEYSYM names a keysym that the X library knows about.
1700 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1701 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1705 const char *keysym_ext;
1707 CHECK_STRING (keysym);
1708 LISP_STRING_TO_EXTERNAL (keysym, keysym_ext, Qctext);
1710 return XStringToKeysym (keysym_ext) ? Qt : Qnil;
1713 DEFUN ("x-keysym-hash-table", Fx_keysym_hash_table, 0, 1, 0, /*
1714 Return a hash table containing a key for all keysyms on DEVICE.
1715 DEVICE must be an X11 display device. See `x-keysym-on-keyboard-p'.
1719 struct device *d = decode_device (device);
1720 if (!DEVICE_X_P (d))
1721 signal_simple_error ("Not an X device", device);
1723 return DEVICE_X_DATA (d)->x_keysym_map_hash_table;
1726 DEFUN ("x-keysym-on-keyboard-sans-modifiers-p", Fx_keysym_on_keyboard_sans_modifiers_p,
1728 Return true if KEYSYM names a key on the keyboard of DEVICE.
1729 More precisely, return true if pressing a physical key
1730 on the keyboard of DEVICE without any modifier keys generates KEYSYM.
1731 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1732 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1733 The keysym name can be provided in two forms:
1734 - if keysym is a string, it must be the name as known to X windows.
1735 - if keysym is a symbol, it must be the name as known to XEmacs.
1736 The two names differ in capitalization and underscoring.
1740 struct device *d = decode_device (device);
1741 if (!DEVICE_X_P (d))
1742 signal_simple_error ("Not an X device", device);
1744 return (EQ (Qsans_modifiers,
1745 Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ?
1750 DEFUN ("x-keysym-on-keyboard-p", Fx_keysym_on_keyboard_p, 1, 2, 0, /*
1751 Return true if KEYSYM names a key on the keyboard of DEVICE.
1752 More precisely, return true if some keystroke (possibly including modifiers)
1753 on the keyboard of DEVICE keys generates KEYSYM.
1754 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1755 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1756 The keysym name can be provided in two forms:
1757 - if keysym is a string, it must be the name as known to X windows.
1758 - if keysym is a symbol, it must be the name as known to XEmacs.
1759 The two names differ in capitalization and underscoring.
1763 struct device *d = decode_device (device);
1764 if (!DEVICE_X_P (d))
1765 signal_simple_error ("Not an X device", device);
1767 return (NILP (Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASH_TABLE (d), Qnil)) ?
1772 /************************************************************************/
1773 /* grabs and ungrabs */
1774 /************************************************************************/
1776 DEFUN ("x-grab-pointer", Fx_grab_pointer, 0, 3, 0, /*
1777 Grab the pointer and restrict it to its current window.
1778 If optional DEVICE argument is nil, the default device will be used.
1779 If optional CURSOR argument is non-nil, change the pointer shape to that
1780 until `x-ungrab-pointer' is called (it should be an object returned by the
1781 `make-cursor-glyph' function).
1782 If the second optional argument IGNORE-KEYBOARD is non-nil, ignore all
1783 keyboard events during the grab.
1784 Returns t if the grab is successful, nil otherwise.
1786 (device, cursor, ignore_keyboard))
1789 int pointer_mode, result;
1790 struct device *d = decode_x_device (device);
1794 CHECK_POINTER_GLYPH (cursor);
1795 cursor = glyph_image_instance (cursor, device, ERROR_ME, 0);
1798 if (!NILP (ignore_keyboard))
1799 pointer_mode = GrabModeSync;
1801 pointer_mode = GrabModeAsync;
1803 w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d)));
1805 /* #### Possibly this needs to gcpro the cursor somehow, but it doesn't
1806 seem to cause a problem if XFreeCursor is called on a cursor in use
1807 in a grab; I suppose the X server counts the grab as a reference
1808 and doesn't free it until it exits? */
1809 result = XGrabPointer (DEVICE_X_DISPLAY (d), w,
1814 PointerMotionHintMask,
1815 GrabModeAsync, /* Keep pointer events flowing */
1816 pointer_mode, /* Stall keyboard events */
1817 w, /* Stay in this window */
1819 : XIMAGE_INSTANCE_X_CURSOR (cursor)),
1821 return (result == GrabSuccess) ? Qt : Qnil;
1824 DEFUN ("x-ungrab-pointer", Fx_ungrab_pointer, 0, 1, 0, /*
1825 Release a pointer grab made with `x-grab-pointer'.
1826 If optional first arg DEVICE is nil the default device is used.
1827 If it is t the pointer will be released on all X devices.
1831 if (!EQ (device, Qt))
1833 Display *dpy = get_x_display (device);
1834 XUngrabPointer (dpy, CurrentTime);
1838 Lisp_Object devcons, concons;
1840 DEVICE_LOOP_NO_BREAK (devcons, concons)
1842 struct device *d = XDEVICE (XCAR (devcons));
1845 XUngrabPointer (DEVICE_X_DISPLAY (d), CurrentTime);
1852 DEFUN ("x-grab-keyboard", Fx_grab_keyboard, 0, 1, 0, /*
1853 Grab the keyboard on the given device (defaulting to the selected one).
1854 So long as the keyboard is grabbed, all keyboard events will be delivered
1855 to emacs -- it is not possible for other X clients to eavesdrop on them.
1856 Ungrab the keyboard with `x-ungrab-keyboard' (use an unwind-protect).
1857 Returns t if the grab is successful, nil otherwise.
1861 struct device *d = decode_x_device (device);
1862 Window w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d)));
1863 Display *dpy = DEVICE_X_DISPLAY (d);
1866 status = XGrabKeyboard (dpy, w, True,
1867 /* I don't really understand sync-vs-async
1868 grabs, but this is what xterm does. */
1869 GrabModeAsync, GrabModeAsync,
1870 /* Use the timestamp of the last user action
1871 read by emacs proper; xterm uses CurrentTime
1872 but there's a comment that says "wrong"...
1873 (Despite the name this is the time of the
1874 last key or mouse event.) */
1875 DEVICE_X_MOUSE_TIMESTAMP (d));
1876 if (status == GrabSuccess)
1878 /* The XUngrabKeyboard should generate a FocusIn back to this
1879 window but it doesn't unless we explicitly set focus to the
1880 window first (which should already have it. The net result
1881 is that without this call when x-ungrab-keyboard is called
1882 the selected frame ends up not having focus. */
1883 XSetInputFocus (dpy, w, RevertToParent, DEVICE_X_MOUSE_TIMESTAMP (d));
1890 DEFUN ("x-ungrab-keyboard", Fx_ungrab_keyboard, 0, 1, 0, /*
1891 Release a keyboard grab made with `x-grab-keyboard'.
1895 Display *dpy = get_x_display (device);
1896 XUngrabKeyboard (dpy, CurrentTime);
1900 DEFUN ("x-get-font-path", Fx_get_font_path, 0, 1, 0, /*
1901 Get the X Server's font path.
1903 See also `x-set-font-path'.
1907 Display *dpy = get_x_display (device);
1909 const char **directories = (const char **) XGetFontPath (dpy, &ndirs_return);
1910 Lisp_Object font_path = Qnil;
1913 signal_simple_error ("Can't get X font path", device);
1915 while (ndirs_return--)
1916 font_path = Fcons (build_ext_string (directories[ndirs_return],
1923 DEFUN ("x-set-font-path", Fx_set_font_path, 1, 2, 0, /*
1924 Set the X Server's font path to FONT-PATH.
1926 There is only one font path per server, not one per client. Use this
1927 sparingly. It uncaches all of the X server's font information.
1929 Font directories should end in the path separator and should contain
1930 a file called fonts.dir usually created with the program mkfontdir.
1932 Setting the FONT-PATH to nil tells the X server to use the default
1935 See also `x-get-font-path'.
1937 (font_path, device))
1939 Display *dpy = get_x_display (device);
1940 Lisp_Object path_entry;
1941 const char **directories;
1944 EXTERNAL_LIST_LOOP (path_entry, font_path)
1946 CHECK_STRING (XCAR (path_entry));
1950 directories = alloca_array (const char *, ndirs);
1952 EXTERNAL_LIST_LOOP (path_entry, font_path)
1954 LISP_STRING_TO_EXTERNAL (XCAR (path_entry), directories[i++], Qfile_name);
1957 expect_x_error (dpy);
1958 XSetFontPath (dpy, (char **) directories, ndirs);
1959 signal_if_x_error (dpy, 1/*resumable_p*/);
1965 /************************************************************************/
1966 /* initialization */
1967 /************************************************************************/
1970 syms_of_device_x (void)
1972 DEFSUBR (Fx_debug_mode);
1973 DEFSUBR (Fx_get_resource);
1974 DEFSUBR (Fx_get_resource_prefix);
1975 DEFSUBR (Fx_put_resource);
1977 DEFSUBR (Fdefault_x_device);
1978 DEFSUBR (Fx_display_visual_class);
1979 DEFSUBR (Fx_display_visual_depth);
1980 DEFSUBR (Fx_server_vendor);
1981 DEFSUBR (Fx_server_version);
1982 DEFSUBR (Fx_valid_keysym_name_p);
1983 DEFSUBR (Fx_keysym_hash_table);
1984 DEFSUBR (Fx_keysym_on_keyboard_p);
1985 DEFSUBR (Fx_keysym_on_keyboard_sans_modifiers_p);
1987 DEFSUBR (Fx_grab_pointer);
1988 DEFSUBR (Fx_ungrab_pointer);
1989 DEFSUBR (Fx_grab_keyboard);
1990 DEFSUBR (Fx_ungrab_keyboard);
1992 DEFSUBR (Fx_get_font_path);
1993 DEFSUBR (Fx_set_font_path);
1995 defsymbol (&Qx_error, "x-error");
1996 defsymbol (&Qinit_pre_x_win, "init-pre-x-win");
1997 defsymbol (&Qinit_post_x_win, "init-post-x-win");
2001 reinit_console_type_create_device_x (void)
2003 /* Initialize variables to speed up X resource interactions */
2004 const char *valid_resource_chars =
2005 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
2006 while (*valid_resource_chars)
2007 valid_resource_char_p[(unsigned int) (*valid_resource_chars++)] = 1;
2009 name_char_dynarr = Dynarr_new (char);
2010 class_char_dynarr = Dynarr_new (char);
2014 console_type_create_device_x (void)
2016 reinit_console_type_create_device_x ();
2017 CONSOLE_HAS_METHOD (x, init_device);
2018 CONSOLE_HAS_METHOD (x, finish_init_device);
2019 CONSOLE_HAS_METHOD (x, mark_device);
2020 CONSOLE_HAS_METHOD (x, delete_device);
2021 CONSOLE_HAS_METHOD (x, device_system_metrics);
2025 reinit_vars_of_device_x (void)
2030 in_resource_setting = 0;
2034 vars_of_device_x (void)
2036 reinit_vars_of_device_x ();
2038 DEFVAR_LISP ("x-emacs-application-class", &Vx_emacs_application_class /*
2039 The X application class of the XEmacs process.
2040 This controls, among other things, the name of the `app-defaults' file
2041 that XEmacs will use. For changes to this variable to take effect, they
2042 must be made before the connection to the X server is initialized, that is,
2043 this variable may only be changed before emacs is dumped, or by setting it
2044 in the file lisp/term/x-win.el.
2046 If this variable is nil before the connection to the X server is first
2047 initialized (which it is by default), the X resource database will be
2048 consulted and the value will be set according to whether any resources
2049 are found for the application class `XEmacs'. If the user has set any
2050 resources for the XEmacs application class, the XEmacs process will use
2051 the application class `XEmacs'. Otherwise, the XEmacs process will use
2052 the application class `Emacs' which is backwards compatible to previous
2053 XEmacs versions but may conflict with resources intended for GNU Emacs.
2055 Vx_emacs_application_class = Qnil;
2057 DEFVAR_LISP ("x-initial-argv-list", &Vx_initial_argv_list /*
2058 You don't want to know.
2059 This is used during startup to communicate the remaining arguments in
2060 `command-line-args-left' to the C code, which passes the args to
2061 the X initialization code, which removes some args, and then the
2062 args are placed back into `x-initial-arg-list' and thence into
2063 `command-line-args-left'. Perhaps `command-line-args-left' should
2066 Vx_initial_argv_list = Qnil;
2068 #if defined(MULE) && (defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET))
2069 DEFVAR_LISP ("x-app-defaults-directory", &Vx_app_defaults_directory /*
2070 Used by the Lisp code to communicate to the low level X initialization
2071 where the localized init files are.
2073 Vx_app_defaults_directory = Qnil;
2078 staticpro (&Vdefault_x_device);
2079 Vdefault_x_device = Qnil;