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 /* Original authors: Jamie Zawinski and the FSF */
25 /* Rewritten by Ben Wing and Chuck Thompson. */
30 #include "console-x.h"
31 #include "xintrinsicp.h" /* CoreP.h needs this */
32 #include <X11/CoreP.h> /* Numerous places access the fields of
33 a core widget directly. We could
34 use XtGetValues(), but ... */
36 #include <X11/Shell.h>
39 #include "objects-x.h"
45 #include "redisplay.h"
56 Lisp_Object Vdefault_x_device;
57 #if defined(MULE) && (defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET))
58 Lisp_Object Vx_app_defaults_directory;
61 /* Qdisplay in general.c */
63 Lisp_Object Qinit_pre_x_win, Qinit_post_x_win;
65 /*
\e$B@ZJ"
\e(B, n. Japanese ritual suicide. */
66 int x_seppuku_on_epipe;
68 /* The application class of Emacs. */
69 Lisp_Object Vx_emacs_application_class;
71 Lisp_Object Vx_initial_argv_list; /* #### ugh! */
73 static XrmOptionDescRec emacs_options[] =
75 {"-geometry", ".geometry", XrmoptionSepArg, NULL},
76 {"-iconic", ".iconic", XrmoptionNoArg, "yes"},
78 {"-internal-border-width", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL},
79 {"-ib", "*EmacsFrame.internalBorderWidth", XrmoptionSepArg, NULL},
80 {"-scrollbar-width", "*EmacsFrame.scrollBarWidth", XrmoptionSepArg, NULL},
81 {"-scrollbar-height", "*EmacsFrame.scrollBarHeight", XrmoptionSepArg, NULL},
83 {"-privatecolormap", ".privateColormap", XrmoptionNoArg, "yes"},
84 {"-visual", ".EmacsVisual", XrmoptionSepArg, NULL},
86 /* #### Beware! If the type of the shell changes, update this. */
87 {"-T", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
88 {"-wn", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
89 {"-title", "*TopLevelEmacsShell.title", XrmoptionSepArg, NULL},
91 {"-iconname", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL},
92 {"-in", "*TopLevelEmacsShell.iconName", XrmoptionSepArg, NULL},
93 {"-mc", "*pointerColor", XrmoptionSepArg, NULL},
94 {"-cr", "*cursorColor", XrmoptionSepArg, NULL},
95 {"-fontset", "*FontSet", XrmoptionSepArg, NULL},
98 /* Functions to synchronize mirroring resources and specifiers */
99 int in_resource_setting;
101 /************************************************************************/
102 /* helper functions */
103 /************************************************************************/
105 /* JH 97/11/25 removed the static declaration because I need it during setup in event-Xt... */
106 struct device * get_device_from_display_1 (Display *dpy);
108 get_device_from_display_1 (Display *dpy)
110 Lisp_Object devcons, concons;
112 DEVICE_LOOP_NO_BREAK (devcons, concons)
114 struct device *d = XDEVICE (XCAR (devcons));
115 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d) == dpy)
123 get_device_from_display (Display *dpy)
125 struct device *d = get_device_from_display_1 (dpy);
127 #if !defined(INFODOCK)
128 # define FALLBACK_RESOURCE_NAME "xemacs"
130 # define FALLBACK_RESOURCE_NAME "infodock"
134 /* This isn't one of our displays. Let's crash? */
136 ("\n%s: Fatal X Condition. Asked about display we don't own: \"%s\"\n",
137 (STRINGP (Vinvocation_name) ?
138 (char *) XSTRING_DATA (Vinvocation_name) : FALLBACK_RESOURCE_NAME),
139 DisplayString (dpy) ? DisplayString (dpy) : "???");
143 #undef FALLBACK_RESOURCE_NAME
149 decode_x_device (Lisp_Object device)
151 XSETDEVICE (device, decode_device (device));
152 CHECK_X_DEVICE (device);
153 return XDEVICE (device);
157 get_x_display (Lisp_Object device)
159 return DEVICE_X_DISPLAY (decode_x_device (device));
163 /************************************************************************/
164 /* initializing an X connection */
165 /************************************************************************/
168 allocate_x_device_struct (struct device *d)
170 d->device_data = xnew_and_zero (struct x_device);
174 Xatoms_of_device_x (struct device *d)
176 Display *D = DEVICE_X_DISPLAY (d);
178 DEVICE_XATOM_WM_PROTOCOLS (d) = XInternAtom (D, "WM_PROTOCOLS", False);
179 DEVICE_XATOM_WM_DELETE_WINDOW(d) = XInternAtom (D, "WM_DELETE_WINDOW",False);
180 DEVICE_XATOM_WM_SAVE_YOURSELF(d) = XInternAtom (D, "WM_SAVE_YOURSELF",False);
181 DEVICE_XATOM_WM_TAKE_FOCUS (d) = XInternAtom (D, "WM_TAKE_FOCUS", False);
182 DEVICE_XATOM_WM_STATE (d) = XInternAtom (D, "WM_STATE", False);
186 sanity_check_geometry_resource (Display *dpy)
188 char *app_name, *app_class, *s;
189 char buf1 [255], buf2 [255];
192 XtGetApplicationNameAndClass (dpy, &app_name, &app_class);
193 strcpy (buf1, app_name);
194 strcpy (buf2, app_class);
195 for (s = buf1; *s; s++) if (*s == '.') *s = '_';
196 strcat (buf1, "._no_._such_._resource_.geometry");
197 strcat (buf2, "._no_._such_._resource_.Geometry");
198 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True)
200 warn_when_safe (Qgeometry, Qerror,
202 "Apparently \"%s*geometry: %s\" or \"%s*geometry: %s\" was\n"
203 "specified in the resource database. Specifying \"*geometry\" will make\n"
204 "XEmacs (and most other X programs) malfunction in obscure ways. (i.e.\n"
205 "the Xt or Xm libraries will probably crash, which is a very bad thing.)\n"
206 "You should always use \".geometry\" or \"*EmacsFrame.geometry\" instead.\n",
207 app_name, (char *) value.addr,
208 app_class, (char *) value.addr);
209 suppress_early_error_handler_backtrace = 1;
210 error ("Invalid geometry resource");
215 x_init_device_class (struct device *d)
217 if (DEVICE_X_DEPTH(d) > 2)
219 switch (DEVICE_X_VISUAL(d)->class)
223 DEVICE_CLASS (d) = Qgrayscale;
226 DEVICE_CLASS (d) = Qcolor;
230 DEVICE_CLASS (d) = Qmono;
234 * Figure out what application name to use for xemacs
236 * Since we have decomposed XtOpenDisplay into XOpenDisplay and
237 * XtDisplayInitialize, we no longer get this for free.
239 * If there is a `-name' argument in argv, use that.
240 * Otherwise use the last component of argv[0].
242 * I have removed the gratuitous use of getenv("RESOURCE_NAME")
243 * which was in X11R5, but left the matching of any prefix of `-name'.
244 * Finally, if all else fails, return `xemacs', as it is more
245 * appropriate (X11R5 returns `main').
248 compute_x_app_name (int argc, char **argv)
253 for (i = 1; i < argc - 1; i++)
254 if (!strncmp(argv[i], "-name", max (2, strlen (argv[1]))))
257 if (argc > 0 && argv[0] && *argv[0])
258 return (ptr = strrchr (argv[0], '/')) ? ++ptr : argv[0];
264 * This function figures out whether the user has any resources of the
265 * form "XEmacs.foo" or "XEmacs*foo".
267 * Currently we only consult the display's global resources; to look
268 * for screen specific resources, we would need to also consult:
269 * xdefs = XScreenResourceString(ScreenOfDisplay(dpy, scrno));
272 have_xemacs_resources_in_xrdb (Display *dpy)
287 xdefs = XResourceManagerString (dpy); /* don't free - owned by X */
288 while (xdefs && *xdefs)
290 if (strncmp (xdefs, key, len) == 0 &&
291 (xdefs[len] == '*' || xdefs[len] == '.'))
294 while (*xdefs && *xdefs++ != '\n') /* find start of next entry.. */
301 /* Only the characters [-_A-Za-z0-9] are allowed in the individual
302 components of a resource. Convert invalid characters to `-' */
304 static char valid_resource_char_p[256];
307 validify_resource_component (char *str, size_t len)
309 for (; len; len--, str++)
310 if (!valid_resource_char_p[(unsigned char) (*str)])
315 Dynarr_add_validified_lisp_string (char_dynarr *cda, Lisp_Object str)
317 Bytecount len = XSTRING_LENGTH (str);
318 Dynarr_add_many (cda, (char *) XSTRING_DATA (str), len);
319 validify_resource_component (Dynarr_atp (cda, Dynarr_length (cda) - len), len);
323 x_init_device (struct device *d, Lisp_Object props)
331 CONST char *app_class;
332 CONST char *app_name;
333 CONST char *disp_name;
336 Visual *visual = NULL;
337 int depth = 8; /* shut up the compiler */
341 XSETDEVICE (device, d);
342 display = DEVICE_CONNECTION (d);
344 allocate_x_device_struct (d);
346 make_argc_argv (Vx_initial_argv_list, &argc, &argv);
348 GET_C_STRING_CTEXT_DATA_ALLOCA (display, disp_name);
351 * Break apart the old XtOpenDisplay call into XOpenDisplay and
352 * XtDisplayInitialize so we can figure out whether there
353 * are any XEmacs resources in the resource database before
354 * we intitialize Xt. This is so we can automagically support
355 * both `Emacs' and `XEmacs' application classes.
357 slow_down_interrupts ();
358 /* May not be needed but XtOpenDisplay could not deal with signals here. */
359 dpy = DEVICE_X_DISPLAY (d) = XOpenDisplay (disp_name);
360 speed_up_interrupts ();
364 suppress_early_error_handler_backtrace = 1;
365 signal_simple_error ("X server not responding\n", display);
368 if (STRINGP (Vx_emacs_application_class) &&
369 XSTRING_LENGTH (Vx_emacs_application_class) > 0)
370 GET_C_STRING_CTEXT_DATA_ALLOCA (Vx_emacs_application_class, app_class);
373 app_class = (NILP (Vx_emacs_application_class) &&
374 have_xemacs_resources_in_xrdb (dpy))
381 /* need to update Vx_emacs_application_class: */
382 Vx_emacs_application_class = build_string (app_class);
385 slow_down_interrupts ();
386 /* May not be needed but XtOpenDisplay could not deal with signals here.
388 XtDisplayInitialize (Xt_app_con, dpy, compute_x_app_name (argc, argv),
389 app_class, emacs_options,
390 XtNumber (emacs_options), &argc, argv);
391 speed_up_interrupts ();
393 screen = DefaultScreen(dpy);
394 if (NILP (Vdefault_x_device))
395 Vdefault_x_device = device;
398 #if defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET)
400 /* Read in locale-specific resources from
401 data-directory/app-defaults/$LANG/Emacs.
402 This is in addition to the standard app-defaults files, and
403 does not override resources defined elsewhere */
404 CONST char *data_dir;
406 XrmDatabase db = XtDatabase (dpy); /* ### XtScreenDatabase(dpy) ? */
407 CONST char *locale = XrmLocaleOfDatabase (db);
409 if (STRINGP (Vx_app_defaults_directory) &&
410 XSTRING_LENGTH (Vx_app_defaults_directory) > 0)
412 GET_C_STRING_FILENAME_DATA_ALLOCA(Vx_app_defaults_directory, data_dir);
413 path = (char *)alloca (strlen (data_dir) + strlen (locale) + 7);
414 sprintf (path, "%s%s/Emacs", data_dir, locale);
415 if (!access (path, R_OK))
416 XrmCombineFileDatabase (path, &db, False);
418 else if (STRINGP (Vdata_directory) && XSTRING_LENGTH (Vdata_directory) > 0)
420 GET_C_STRING_FILENAME_DATA_ALLOCA (Vdata_directory, data_dir);
421 path = (char *)alloca (strlen (data_dir) + 13 + strlen (locale) + 7);
422 sprintf (path, "%sapp-defaults/%s/Emacs", data_dir, locale);
423 if (!access (path, R_OK))
424 XrmCombineFileDatabase (path, &db, False);
427 #endif /* LWLIB_MENUBARS_MOTIF or HAVE_XIM USE_XFONTSET */
430 if (NILP (DEVICE_NAME (d)))
431 DEVICE_NAME (d) = display;
433 /* We're going to modify the string in-place, so be a nice XEmacs */
434 DEVICE_NAME (d) = Fcopy_sequence (DEVICE_NAME (d));
435 /* colons and periods can't appear in individual elements of resource
438 XtGetApplicationNameAndClass (dpy, (char **) &app_name, (char **) &app_class);
439 /* search for a matching visual if requested by the user, or setup the display default */
442 char *buf1 = (char *)alloca (strlen (app_name) + 17);
443 char *buf2 = (char *)alloca (strlen (app_class) + 17);
447 sprintf (buf1, "%s.emacsVisual", app_name);
448 sprintf (buf2, "%s.EmacsVisual", app_class);
449 if (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True)
451 int cnt = 0, vis_class= PseudoColor;
453 char *res, *str = (char*)value.addr;
455 if (strncmp(str, "StaticGray", 10) == 0) cnt = 10, vis_class = StaticGray;
456 else if (strncmp(str, "StaticColor", 11) == 0) cnt = 11, vis_class = StaticColor;
457 else if (strncmp(str, "TrueColor", 9) == 0) cnt = 9, vis_class = TrueColor;
458 else if (strncmp(str, "GrayScale", 9) == 0) cnt = 9, vis_class = GrayScale;
459 else if (strncmp(str, "PseudoColor", 11) == 0) cnt = 11, vis_class = PseudoColor;
460 else if (strncmp(str, "DirectColor", 11) == 0) cnt = 11, vis_class = DirectColor;
467 stderr_out("Invalid Depth specification in %s... ignoring...\n",(char*)str);
471 if (XMatchVisualInfo(dpy, screen, depth, vis_class, &vinfo))
473 visual = vinfo.visual;
477 stderr_out("Can't match the requested visual %s... using defaults\n",str);
483 stderr_out("Invalid Visual specification in %s... ignoring.\n",(char*)str);
488 visual = DefaultVisual(dpy, screen);
489 depth = DefaultDepth(dpy, screen);
492 /* If we've got the same visual as the default and it's PseudoColor,
493 check to see if the user specified that we need a private colormap */
494 if (visual == DefaultVisual(dpy, screen))
496 sprintf (buf1, "%s.privateColormap", app_name);
497 sprintf (buf2, "%s.PrivateColormap", app_class);
498 if ((visual->class == PseudoColor) &&
499 (XrmGetResource (XtDatabase (dpy), buf1, buf2, &type, &value) == True))
501 cmap = XCopyColormapAndFree(dpy, DefaultColormap(dpy, screen));
505 cmap = DefaultColormap(dpy, screen);
510 /* We have to create a matching colormap anyway...
511 ### think about using standard colormaps (need the Xmu libs?) */
512 cmap = XCreateColormap(dpy, RootWindow(dpy, screen), visual, AllocNone);
513 XInstallColormap(dpy, cmap);
516 XtSetArg(xargs[numargs],XtNvisual, visual); numargs++;
517 XtSetArg(xargs[numargs],XtNdepth, depth); numargs++;
518 XtSetArg(xargs[numargs],XtNcolormap, cmap); numargs++;
519 DEVICE_X_VISUAL (d) = visual;
520 DEVICE_X_COLORMAP (d) = cmap;
521 DEVICE_X_DEPTH (d) = depth;
523 validify_resource_component ((char *) XSTRING_DATA (DEVICE_NAME (d)),
524 XSTRING_LENGTH (DEVICE_NAME (d)));
525 app_shell = XtAppCreateShell (NULL, app_class,
526 applicationShellWidgetClass,
527 dpy, xargs, numargs);
529 DEVICE_XT_APP_SHELL (d) = app_shell;
532 #endif /* HAVE_XIM */
534 /* Realize the app_shell so that its window exists for GC creation purposes,
535 and set it to the size of the root window for child placement purposes */
537 Screen *scrn = ScreenOfDisplay(dpy, screen);
538 int screen_width, screen_height;
539 screen_width = WidthOfScreen(scrn);
540 screen_height = HeightOfScreen(scrn);
542 XtSetArg (xargs[numargs], XtNmappedWhenManaged, False); numargs++;
543 XtSetArg (xargs[numargs], XtNx, 0); numargs++;
544 XtSetArg (xargs[numargs], XtNy, 0); numargs++;
545 XtSetArg (xargs[numargs], XtNwidth, screen_width); numargs++;
546 XtSetArg (xargs[numargs], XtNheight, screen_height); numargs++;
547 XtSetValues (app_shell, xargs, numargs);
548 XtRealizeWidget (app_shell);
554 make_argc_argv (Vcommand_line_args, &new_argc, &new_argv);
555 XSetCommand (XtDisplay (app_shell), XtWindow (app_shell), new_argv, new_argc);
556 free_argc_argv (new_argv);
558 #endif /* HAVE_SESSION */
561 #ifdef HAVE_OFFIX_DND
562 DndInitialize ( app_shell );
565 Vx_initial_argv_list = make_arg_list (argc, argv);
566 free_argc_argv (argv);
568 DEVICE_X_WM_COMMAND_FRAME (d) = Qnil;
570 sanity_check_geometry_resource (dpy);
573 x_init_modifier_mapping (d);
575 DEVICE_INFD (d) = DEVICE_OUTFD (d) = ConnectionNumber (dpy);
579 DEVICE_X_GC_CACHE (d) = make_gc_cache (dpy, XtWindow(app_shell));
580 DEVICE_X_GRAY_PIXMAP (d) = None;
581 Xatoms_of_device_x (d);
582 Xatoms_of_xselect (d);
583 Xatoms_of_objects_x (d);
584 x_init_device_class (d);
586 /* Run the elisp side of the X device initialization. */
587 call0 (Qinit_pre_x_win);
591 x_finish_init_device (struct device *d, Lisp_Object props)
593 call0 (Qinit_post_x_win);
597 x_mark_device (struct device *d, void (*markobj) (Lisp_Object))
599 ((markobj) (DEVICE_X_WM_COMMAND_FRAME (d)));
600 ((markobj) (DEVICE_X_DATA (d)->x_keysym_map_hashtable));
604 /************************************************************************/
605 /* closing an X connection */
606 /************************************************************************/
609 free_x_device_struct (struct device *d)
611 xfree (d->device_data);
615 x_delete_device (struct device *d)
620 extern void (*__free_hook)();
624 XSETDEVICE (device, d);
625 display = DEVICE_X_DISPLAY (d);
630 checking_free = (__free_hook != 0);
632 /* Disable strict free checking, to avoid bug in X library */
634 disable_strict_free_check ();
637 free_gc_cache (DEVICE_X_GC_CACHE (d));
638 if (DEVICE_X_DATA (d)->x_modifier_keymap)
639 XFreeModifiermap (DEVICE_X_DATA (d)->x_modifier_keymap);
640 if (DEVICE_X_DATA (d)->x_keysym_map)
641 XFree ((char *) DEVICE_X_DATA (d)->x_keysym_map);
643 XtCloseDisplay (display);
644 DEVICE_X_DISPLAY (d) = 0;
647 enable_strict_free_check ();
651 if (EQ (device, Vdefault_x_device))
653 Lisp_Object devcons, concons;
654 /* #### handle deleting last X device */
655 Vdefault_x_device = Qnil;
656 DEVICE_LOOP_NO_BREAK (devcons, concons)
658 if (DEVICE_X_P (XDEVICE (XCAR (devcons))) &&
659 !EQ (device, XCAR (devcons)))
661 Vdefault_x_device = XCAR (devcons);
667 free_x_device_struct (d);
671 /************************************************************************/
672 /* handle X errors */
673 /************************************************************************/
676 x_event_name (int event_type)
678 static CONST char *events[] =
718 if (event_type < 0 || event_type >= countof (events))
720 return events [event_type];
725 If an X error occurs which we are not expecting, we have no alternative
726 but to print it to stderr. It would be nice to stuff it into a pop-up
727 buffer, or to print it in the minibuffer, but that's not possible, because
728 one is not allowed to do any I/O on the display connection from an error
729 handler. The guts of Xlib expect these functions to either return or exit.
731 However, there are occasions when we might expect an error to reasonably
732 occur. The interface to this is as follows:
734 Before calling some X routine which may error, call
735 expect_x_error (dpy);
737 Just after calling the X routine, call either:
739 x_error_occurred_p (dpy);
741 to ask whether an error happened (and was ignored), or:
743 signal_if_x_error (dpy, resumable_p);
745 which will call Fsignal() with args appropriate to the X error, if there
746 was one. (Resumable_p is whether the debugger should be allowed to
747 continue from the call to signal.)
749 You must call one of these two routines immediately after calling the X
750 routine; think of them as bookends like BLOCK_INPUT and UNBLOCK_INPUT.
753 static int error_expected;
754 static int error_occurred;
755 static XErrorEvent last_error;
759 #ifdef EXTERNAL_WIDGET
761 x_error_handler_do_enqueue (Lisp_Object frame)
763 enqueue_magic_eval_event (io_error_delete_frame, frame);
768 x_error_handler_error (Lisp_Object data, Lisp_Object dummy)
772 #endif /* EXTERNAL_WIDGET */
775 x_error_handler (Display *disp, XErrorEvent *event)
785 #ifdef EXTERNAL_WIDGET
787 struct device *d = get_device_from_display (disp);
789 if ((event->error_code == BadWindow ||
790 event->error_code == BadDrawable)
791 && ((f = x_any_window_to_frame (d, event->resourceid)) != 0))
795 /* one of the windows comprising one of our frames has died.
796 This occurs particularly with ExternalShell frames when the
797 client that owns the ExternalShell's window dies.
799 We cannot do any I/O on the display connection so we need
800 to enqueue an eval event so that the deletion happens
803 Furthermore, we need to trap any errors (out-of-memory) that
804 may occur when Fenqueue_eval_event is called.
807 if (f->being_deleted)
809 XSETFRAME (frame, f);
810 if (!NILP (condition_case_1 (Qerror, x_error_handler_do_enqueue,
811 frame, x_error_handler_error, Qnil)))
813 f->being_deleted = 1;
818 #endif /* EXTERNAL_WIDGET */
820 stderr_out ("\n%s: ",
821 (STRINGP (Vinvocation_name)
822 ? (char *) XSTRING_DATA (Vinvocation_name)
824 XmuPrintDefaultErrorMessage (disp, event, stderr);
830 expect_x_error (Display *dpy)
832 assert (!error_expected);
833 XSync (dpy, 0); /* handle pending errors before setting flag */
839 x_error_occurred_p (Display *dpy)
842 XSync (dpy, 0); /* handle pending errors before setting flag */
843 val = error_occurred;
850 signal_if_x_error (Display *dpy, int resumable_p)
854 if (! x_error_occurred_p (dpy))
857 sprintf (buf, "0x%X", (unsigned int) last_error.resourceid);
858 data = Fcons (build_string (buf), data);
861 sprintf (num, "%d", last_error.request_code);
862 XGetErrorDatabaseText (last_error.display, "XRequest", num, "",
865 sprintf (buf, "Request-%d", last_error.request_code);
866 data = Fcons (build_string (buf), data);
868 XGetErrorText (last_error.display, last_error.error_code, buf, sizeof (buf));
869 data = Fcons (build_string (buf), data);
871 Fsignal (Qx_error, data);
872 if (! resumable_p) goto again;
877 x_IO_error_handler (Display *disp)
879 /* This function can GC */
881 struct device *d = get_device_from_display_1 (disp);
888 if (NILP (find_nonminibuffer_frame_not_on_device (dev)))
890 /* We're going down. */
892 ("\n%s: Fatal I/O Error %d (%s) on display connection \"%s\"\n",
893 (STRINGP (Vinvocation_name) ?
894 (char *) XSTRING_DATA (Vinvocation_name) : "xemacs"),
895 errno, strerror (errno), DisplayString (disp));
897 (" after %lu requests (%lu known processed) with %d events remaining.\n",
898 NextRequest (disp) - 1, LastKnownRequestProcessed (disp),
900 /* assert (!_Xdebug); */
906 "I/O Error %d (%s) on display connection \"%s\"\n"
907 " after %lu requests (%lu known processed) with "
908 "%d events remaining.\n",
909 errno, strerror (errno), DisplayString (disp),
910 NextRequest (disp) - 1, LastKnownRequestProcessed (disp),
915 enqueue_magic_eval_event (io_error_delete_device, dev);
917 /* CvE, July 16, 1996, XEmacs 19.14 */
918 /* Test for broken pipe error, which indicates X-server has gone down */
919 if (errno == EPIPE && x_seppuku_on_epipe)
921 /* Most probably X-server has gone down: Avoid infinite loop by just */
923 /* slb: This sounds really, really dangerous to do by default, so */
924 /* I'm adding a guard to avoid doing this as default behavior */
925 stderr_out( "\n\nXEmacs exiting on broken pipe (errno %d, %s)\n",
926 errno, strerror(errno));
933 DEFUN ("x-debug-mode", Fx_debug_mode, 1, 2, 0, /*
934 With a true arg, make the connection to the X server synchronous.
935 With false, make it asynchronous. Synchronous connections are much slower,
936 but are useful for debugging. (If you get X errors, make the connection
937 synchronous, and use a debugger to set a breakpoint on `x_error_handler'.
938 Your backtrace of the C stack will now be useful. In asynchronous mode,
939 the stack above `x_error_handler' isn't helpful because of buffering.)
940 If DEVICE is not specified, the selected device is assumed.
942 Calling this function is the same as calling the C function `XSynchronize',
943 or starting the program with the `-sync' command line argument.
947 struct device *d = decode_x_device (device);
949 XSynchronize (DEVICE_X_DISPLAY (d), !NILP (arg));
952 message ("X connection is synchronous");
954 message ("X connection is asynchronous");
960 /************************************************************************/
962 /************************************************************************/
964 #if 0 /* bah humbug. The whole "widget == resource" stuff is such
965 a crock of shit that I'm just going to ignore it all. */
967 /* If widget is NULL, we are retrieving device or global face data. */
970 construct_name_list (Display *display, Widget widget, char *fake_name,
971 char *fake_class, char *name, char *class)
973 char *stack [100][2];
976 char *name_tail, *class_tail;
980 for (this = widget; this; this = XtParent (this))
982 stack [count][0] = this->core.name;
983 stack [count][1] = XtClass (this)->core_class.class_name;
988 else if (fake_name && fake_class)
990 stack [count][0] = fake_name;
991 stack [count][1] = fake_class;
995 /* The root widget is an application shell; resource lookups use the
996 specified application name and application class in preference to
997 the name/class of that widget (which is argv[0] / "ApplicationShell").
998 Generally the app name and class will be argv[0] / "Emacs" but
999 the former can be set via the -name command-line option, and the
1000 latter can be set by changing `x-emacs-application-class' in
1003 XtGetApplicationNameAndClass (display,
1012 for (; count >= 0; count--)
1014 strcat (name_tail, stack [count][0]);
1015 for (; *name_tail; name_tail++)
1016 if (*name_tail == '.') *name_tail = '_';
1017 strcat (name_tail, ".");
1020 strcat (class_tail, stack [count][1]);
1021 for (; *class_tail; class_tail++)
1022 if (*class_tail == '.') *class_tail = '_';
1023 strcat (class_tail, ".");
1030 static char_dynarr *name_char_dynarr;
1031 static char_dynarr *class_char_dynarr;
1033 /* Given a locale and device specification from x-get-resource or
1034 x-get-resource-prefix, return the resource prefix and display to
1035 fetch the resource on. */
1038 x_get_resource_prefix (Lisp_Object locale, Lisp_Object device,
1039 Display **display_out, char_dynarr *name,
1044 if (NILP (Fvalid_specifier_locale_p (locale)))
1045 signal_simple_error ("Invalid locale", locale);
1046 if (WINDOWP (locale))
1047 /* #### I can't come up with any coherent way of naming windows.
1048 By relative position? That seems tricky because windows
1049 can change position, be split, etc. By order of creation?
1050 That seems less than useful. */
1051 signal_simple_error ("Windows currently can't be resourced", locale);
1053 if (!NILP (device) && !DEVICEP (device))
1054 CHECK_DEVICE (device);
1055 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device)))
1059 device = DFW_DEVICE (locale);
1060 if (DEVICEP (device) && !DEVICE_X_P (XDEVICE (device)))
1063 device = Vdefault_x_device;
1071 *display_out = DEVICE_X_DISPLAY (XDEVICE (device));
1074 char *appname, *appclass;
1075 int name_len, class_len;
1076 XtGetApplicationNameAndClass (*display_out, &appname, &appclass);
1077 name_len = strlen (appname);
1078 class_len = strlen (appclass);
1079 Dynarr_add_many (name , appname, name_len);
1080 Dynarr_add_many (class, appclass, class_len);
1081 validify_resource_component (Dynarr_atp (name, 0), name_len);
1082 validify_resource_component (Dynarr_atp (class, 0), class_len);
1085 if (EQ (locale, Qglobal))
1087 if (BUFFERP (locale))
1089 Dynarr_add_literal_string (name, ".buffer.");
1090 /* we know buffer is live; otherwise we got an error above. */
1091 Dynarr_add_validified_lisp_string (name, Fbuffer_name (locale));
1092 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsBuffer");
1094 else if (FRAMEP (locale))
1096 Dynarr_add_literal_string (name, ".frame.");
1097 /* we know frame is live; otherwise we got an error above. */
1098 Dynarr_add_validified_lisp_string (name, Fframe_name (locale));
1099 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsFrame");
1103 assert (DEVICEP (locale));
1104 Dynarr_add_literal_string (name, ".device.");
1105 /* we know device is live; otherwise we got an error above. */
1106 Dynarr_add_validified_lisp_string (name, Fdevice_name (locale));
1107 Dynarr_add_literal_string (class, ".EmacsLocaleType.EmacsDevice");
1112 DEFUN ("x-get-resource", Fx_get_resource, 3, 6, 0, /*
1113 Retrieve an X resource from the resource manager.
1115 The first arg is the name of the resource to retrieve, such as "font".
1116 The second arg is the class of the resource to retrieve, such as "Font".
1117 The third arg must be one of the symbols 'string, 'integer, 'natnum, or
1118 'boolean, specifying the type of object that the database is searched for.
1119 The fourth arg is the locale to search for the resources on, and can
1120 currently be a buffer, a frame, a device, or 'global. If omitted, it
1121 defaults to 'global.
1122 The fifth arg is the device to search for the resources on. (The resource
1123 database for a particular device is constructed by combining non-device-
1124 specific resources such as any command-line resources specified and any
1125 app-defaults files found [or the fallback resources supplied by XEmacs,
1126 if no app-defaults file is found] with device-specific resources such as
1127 those supplied using xrdb.) If omitted, it defaults to the device of
1128 LOCALE, if a device can be derived (i.e. if LOCALE is a frame or device),
1129 and otherwise defaults to the value of `default-x-device'.
1130 The sixth arg NOERROR, if non-nil, means do not signal an error if a
1131 bogus resource specification was retrieved (e.g. if a non-integer was
1132 given when an integer was requested). In this case, a warning is issued
1135 The resource names passed to this function are looked up relative to the
1138 If you want to search for a subresource, you just need to specify the
1139 resource levels in NAME and CLASS. For example, NAME could be
1140 "modeline.attributeFont", and CLASS "Face.AttributeFont".
1144 1) If LOCALE is a buffer, a call
1146 (x-get-resource "foreground" "Foreground" 'string SOME-BUFFER)
1148 is an interface to a C call something like
1150 XrmGetResource (db, "xemacs.buffer.BUFFER-NAME.foreground",
1151 "Emacs.EmacsLocaleType.EmacsBuffer.Foreground",
1154 2) If LOCALE is a frame, a call
1156 (x-get-resource "foreground" "Foreground" 'string SOME-FRAME)
1158 is an interface to a C call something like
1160 XrmGetResource (db, "xemacs.frame.FRAME-NAME.foreground",
1161 "Emacs.EmacsLocaleType.EmacsFrame.Foreground",
1164 3) If LOCALE is a device, a call
1166 (x-get-resource "foreground" "Foreground" 'string SOME-DEVICE)
1168 is an interface to a C call something like
1170 XrmGetResource (db, "xemacs.device.DEVICE-NAME.foreground",
1171 "Emacs.EmacsLocaleType.EmacsDevice.Foreground",
1174 4) If LOCALE is 'global, a call
1176 (x-get-resource "foreground" "Foreground" 'string 'global)
1178 is an interface to a C call something like
1180 XrmGetResource (db, "xemacs.foreground",
1184 Note that for 'global, no prefix is added other than that of the
1185 application itself; thus, you can use this locale to retrieve
1186 arbitrary application resources, if you really want to.
1188 The returned value of this function is nil if the queried resource is not
1189 found. If the third arg is `string', a string is returned, and if it is
1190 `integer', an integer is returned. If the third arg is `boolean', then the
1191 returned value is the list (t) for true, (nil) for false, and is nil to
1192 mean ``unspecified.''
1194 (name, class, type, locale, device, no_error))
1196 char* name_string, *class_string;
1200 Error_behavior errb = decode_error_behavior_flag (no_error);
1202 CHECK_STRING (name);
1203 CHECK_STRING (class);
1204 CHECK_SYMBOL (type);
1206 Dynarr_reset (name_char_dynarr);
1207 Dynarr_reset (class_char_dynarr);
1209 x_get_resource_prefix (locale, device, &display,
1210 name_char_dynarr, class_char_dynarr);
1214 db = XtDatabase (display);
1216 Dynarr_add (name_char_dynarr, '.');
1217 Dynarr_add_lisp_string (name_char_dynarr, name);
1218 Dynarr_add (class_char_dynarr, '.');
1219 Dynarr_add_lisp_string (class_char_dynarr, class);
1220 Dynarr_add (name_char_dynarr, '\0');
1221 Dynarr_add (class_char_dynarr, '\0');
1223 name_string = Dynarr_atp (name_char_dynarr, 0);
1224 class_string = Dynarr_atp (class_char_dynarr, 0);
1228 XrmName namelist[100];
1229 XrmClass classlist[100];
1230 XrmName *namerest = namelist;
1231 XrmClass *classrest = classlist;
1232 XrmRepresentation xrm_type;
1233 XrmRepresentation string_quark;
1235 XrmStringToNameList (name_string, namelist);
1236 XrmStringToClassList (class_string, classlist);
1237 string_quark = XrmStringToQuark ("String");
1239 /* ensure that they have the same length */
1240 while (namerest[0] && classrest[0])
1241 namerest++, classrest++;
1242 if (namerest[0] || classrest[0])
1243 signal_simple_error_2
1244 ("class list and name list must be the same length", name, class);
1245 result = XrmQGetResource (db, namelist, classlist, &xrm_type, &xrm_value);
1247 if (result != True || xrm_type != string_quark)
1249 raw_result = (char *) xrm_value.addr;
1252 if (EQ (type, Qstring))
1253 return build_string (raw_result);
1254 else if (EQ (type, Qboolean))
1256 if (!strcasecmp (raw_result, "off") ||
1257 !strcasecmp (raw_result, "false") ||
1258 !strcasecmp (raw_result, "no"))
1259 return Fcons (Qnil, Qnil);
1260 if (!strcasecmp (raw_result, "on") ||
1261 !strcasecmp (raw_result, "true") ||
1262 !strcasecmp (raw_result, "yes"))
1263 return Fcons (Qt, Qnil);
1264 return maybe_continuable_error
1266 "can't convert %s: %s to a Boolean", name_string, raw_result);
1268 else if (EQ (type, Qinteger) || EQ (type, Qnatnum))
1272 if (1 != sscanf (raw_result, "%d%c", &i, &c))
1273 return maybe_continuable_error
1275 "can't convert %s: %s to an integer", name_string, raw_result);
1276 else if (EQ (type, Qnatnum) && i < 0)
1277 return maybe_continuable_error
1279 "invalid numerical value %d for resource %s", i, name_string);
1281 return make_int (i);
1285 return maybe_signal_continuable_error
1286 (Qwrong_type_argument,
1287 list2 (build_translated_string
1288 ("should be string, integer, natnum or boolean"),
1294 DEFUN ("x-get-resource-prefix", Fx_get_resource_prefix, 1, 2, 0, /*
1295 Return the resource prefix for LOCALE on DEVICE.
1296 The resource prefix is the strings used to prefix resources if
1297 the LOCALE and DEVICE arguments were passed to `x-get-resource'.
1298 The returned value is a cons of a name prefix and a class prefix.
1299 For example, if LOCALE is a frame, the returned value might be
1300 \("xemacs.frame.FRAME-NAME" . "Emacs.EmacsLocaleType.EmacsFrame").
1301 If no valid X device for resourcing can be obtained, this function
1302 returns nil. (In such a case, `x-get-resource' would always return nil.)
1308 Dynarr_reset (name_char_dynarr );
1309 Dynarr_reset (class_char_dynarr);
1311 x_get_resource_prefix (locale, device, &display,
1312 name_char_dynarr, class_char_dynarr);
1316 return Fcons (make_string ((Bufbyte *) Dynarr_atp (name_char_dynarr, 0),
1317 Dynarr_length (name_char_dynarr)),
1318 make_string ((Bufbyte *) Dynarr_atp (class_char_dynarr, 0),
1319 Dynarr_length (class_char_dynarr)));
1322 DEFUN ("x-put-resource", Fx_put_resource, 1, 2, 0, /*
1323 Add a resource to the resource database for DEVICE.
1324 RESOURCE-LINE specifies the resource to add and should be a
1325 standard resource specification.
1327 (resource_line, device))
1329 struct device *d = decode_device (device);
1330 char *str, *colon_pos;
1332 CHECK_STRING (resource_line);
1333 str = (char *) XSTRING_DATA (resource_line);
1334 if (!(colon_pos = strchr (str, ':')) || strchr (str, '\n'))
1336 signal_simple_error ("Invalid resource line", resource_line);
1338 /* Only the following chars are allowed before the colon */
1339 " \t.*?abcdefghijklmnopqrstuvwxyz"
1340 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-")
1341 != (size_t) (colon_pos - str))
1346 XrmDatabase db = XtDatabase (DEVICE_X_DISPLAY (d));
1347 XrmPutLineResource (&db, str);
1354 /************************************************************************/
1355 /* display information functions */
1356 /************************************************************************/
1358 DEFUN ("default-x-device", Fdefault_x_device, 0, 0, 0, /*
1359 Return the default X device for resourcing.
1360 This is the first-created X device that still exists.
1364 return Vdefault_x_device;
1367 DEFUN ("x-display-visual-class", Fx_display_visual_class, 0, 1, 0, /*
1368 Return the visual class of the X display DEVICE is using.
1369 This can be altered from the default at startup using the XResource "EmacsVisual".
1370 The returned value will be one of the symbols `static-gray', `gray-scale',
1371 `static-color', `pseudo-color', `true-color', or `direct-color'.
1375 Visual *vis = DEVICE_X_VISUAL (decode_x_device (device));
1378 case StaticGray: return intern ("static-gray");
1379 case GrayScale: return intern ("gray-scale");
1380 case StaticColor: return intern ("static-color");
1381 case PseudoColor: return intern ("pseudo-color");
1382 case TrueColor: return intern ("true-color");
1383 case DirectColor: return intern ("direct-color");
1385 error ("display has an unknown visual class");
1386 return Qnil; /* suppress compiler warning */
1390 DEFUN ("x-display-visual-depth", Fx_display_visual_depth, 0, 1, 0, /*
1391 Return the bitplane depth of the visual the X display DEVICE is using.
1395 return make_int (DEVICE_X_DEPTH (decode_x_device (device)));
1399 x_device_system_metrics (struct device *d,
1400 enum device_metrics m)
1402 Display *dpy = DEVICE_X_DISPLAY (d);
1406 case DM_size_device:
1407 return Fcons (make_int (DisplayWidth (dpy, DefaultScreen (dpy))),
1408 make_int (DisplayHeight (dpy, DefaultScreen (dpy))));
1409 case DM_size_device_mm:
1410 return Fcons (make_int (DisplayWidthMM (dpy, DefaultScreen (dpy))),
1411 make_int (DisplayHeightMM (dpy, DefaultScreen (dpy))));
1412 case DM_num_bit_planes:
1413 return make_int (DisplayPlanes (dpy, DefaultScreen (dpy)));
1414 case DM_num_color_cells:
1415 return make_int (DisplayCells (dpy, DefaultScreen (dpy)));
1416 default: /* No such device metric property for X devices */
1421 DEFUN ("x-server-vendor", Fx_server_vendor, 0, 1, 0, /*
1422 Return the vendor ID string of the X server DEVICE is on.
1423 Return the empty string if the vendor ID string cannot be determined.
1427 Display *dpy = get_x_display (device);
1428 char *vendor = ServerVendor (dpy);
1430 return build_string (vendor ? vendor : "");
1433 DEFUN ("x-server-version", Fx_server_version, 0, 1, 0, /*
1434 Return the version numbers of the X server DEVICE is on.
1435 The returned value is a list of three integers: the major and minor
1436 version numbers of the X Protocol in use, and the vendor-specific release
1437 number. See also `x-server-vendor'.
1441 Display *dpy = get_x_display (device);
1443 return list3 (make_int (ProtocolVersion (dpy)),
1444 make_int (ProtocolRevision (dpy)),
1445 make_int (VendorRelease (dpy)));
1448 DEFUN ("x-valid-keysym-name-p", Fx_valid_keysym_name_p, 1, 1, 0, /*
1449 Return true if KEYSYM names a keysym that the X library knows about.
1450 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1451 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1455 CONST char *keysym_ext;
1457 CHECK_STRING (keysym);
1458 GET_C_STRING_CTEXT_DATA_ALLOCA (keysym, keysym_ext);
1460 return XStringToKeysym (keysym_ext) ? Qt : Qnil;
1463 DEFUN ("x-keysym-hashtable", Fx_keysym_hashtable, 0, 1, 0, /*
1464 Return a hashtable which contains a hash key for all keysyms which
1465 name keys on the keyboard. See `x-keysym-on-keyboard-p'.
1469 struct device *d = decode_device (device);
1470 if (!DEVICE_X_P (d))
1471 signal_simple_error ("Not an X device", device);
1473 return DEVICE_X_DATA (d)->x_keysym_map_hashtable;
1476 DEFUN ("x-keysym-on-keyboard-sans-modifiers-p", Fx_keysym_on_keyboard_sans_modifiers_p,
1478 Return true if KEYSYM names a key on the keyboard of DEVICE.
1479 More precisely, return true if pressing a physical key
1480 on the keyboard of DEVICE without any modifier keys generates KEYSYM.
1481 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1482 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1483 The keysym name can be provided in two forms:
1484 - if keysym is a string, it must be the name as known to X windows.
1485 - if keysym is a symbol, it must be the name as known to XEmacs.
1486 The two names differ in capitalization and underscoring.
1490 struct device *d = decode_device (device);
1491 if (!DEVICE_X_P (d))
1492 signal_simple_error ("Not an X device", device);
1494 return (EQ (Qsans_modifiers,
1495 Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASHTABLE (d), Qnil)) ?
1500 DEFUN ("x-keysym-on-keyboard-p", Fx_keysym_on_keyboard_p, 1, 2, 0, /*
1501 Return true if KEYSYM names a key on the keyboard of DEVICE.
1502 More precisely, return true if some keystroke (possibly including modifiers)
1503 on the keyboard of DEVICE keys generates KEYSYM.
1504 Valid keysyms are listed in the files /usr/include/X11/keysymdef.h and in
1505 /usr/lib/X11/XKeysymDB, or whatever the equivalents are on your system.
1506 The keysym name can be provided in two forms:
1507 - if keysym is a string, it must be the name as known to X windows.
1508 - if keysym is a symbol, it must be the name as known to XEmacs.
1509 The two names differ in capitalization and underscoring.
1513 struct device *d = decode_device (device);
1514 if (!DEVICE_X_P (d))
1515 signal_simple_error ("Not an X device", device);
1517 return (NILP (Fgethash (keysym, DEVICE_X_KEYSYM_MAP_HASHTABLE (d), Qnil)) ?
1522 /************************************************************************/
1523 /* grabs and ungrabs */
1524 /************************************************************************/
1526 DEFUN ("x-grab-pointer", Fx_grab_pointer, 0, 3, 0, /*
1527 Grab the pointer and restrict it to its current window.
1528 If optional DEVICE argument is nil, the default device will be used.
1529 If optional CURSOR argument is non-nil, change the pointer shape to that
1530 until `x-ungrab-pointer' is called (it should be an object returned by the
1531 `make-cursor-glyph' function).
1532 If the second optional argument IGNORE-KEYBOARD is non-nil, ignore all
1533 keyboard events during the grab.
1534 Returns t if the grab is successful, nil otherwise.
1536 (device, cursor, ignore_keyboard))
1539 int pointer_mode, result;
1540 struct device *d = decode_x_device (device);
1544 CHECK_POINTER_GLYPH (cursor);
1545 cursor = glyph_image_instance (cursor, device, ERROR_ME, 0);
1548 if (!NILP (ignore_keyboard))
1549 pointer_mode = GrabModeSync;
1551 pointer_mode = GrabModeAsync;
1553 w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d)));
1555 /* #### Possibly this needs to gcpro the cursor somehow, but it doesn't
1556 seem to cause a problem if XFreeCursor is called on a cursor in use
1557 in a grab; I suppose the X server counts the grab as a reference
1558 and doesn't free it until it exits? */
1559 result = XGrabPointer (DEVICE_X_DISPLAY (d), w,
1564 PointerMotionHintMask,
1565 GrabModeAsync, /* Keep pointer events flowing */
1566 pointer_mode, /* Stall keyboard events */
1567 w, /* Stay in this window */
1569 : XIMAGE_INSTANCE_X_CURSOR (cursor)),
1571 return (result == GrabSuccess) ? Qt : Qnil;
1574 DEFUN ("x-ungrab-pointer", Fx_ungrab_pointer, 0, 1, 0, /*
1575 Release a pointer grab made with `x-grab-pointer'.
1576 If optional first arg DEVICE is nil the default device is used.
1577 If it is t the pointer will be released on all X devices.
1581 if (!EQ (device, Qt))
1583 Display *dpy = get_x_display (device);
1584 XUngrabPointer (dpy, CurrentTime);
1588 Lisp_Object devcons, concons;
1590 DEVICE_LOOP_NO_BREAK (devcons, concons)
1592 struct device *d = XDEVICE (XCAR (devcons));
1595 XUngrabPointer (DEVICE_X_DISPLAY (d), CurrentTime);
1602 DEFUN ("x-grab-keyboard", Fx_grab_keyboard, 0, 1, 0, /*
1603 Grab the keyboard on the given device (defaulting to the selected one).
1604 So long as the keyboard is grabbed, all keyboard events will be delivered
1605 to emacs -- it is not possible for other X clients to eavesdrop on them.
1606 Ungrab the keyboard with `x-ungrab-keyboard' (use an unwind-protect).
1607 Returns t if the grab was successful; nil otherwise.
1611 struct device *d = decode_x_device (device);
1612 Window w = XtWindow (FRAME_X_TEXT_WIDGET (device_selected_frame (d)));
1613 Display *dpy = DEVICE_X_DISPLAY (d);
1616 status = XGrabKeyboard (dpy, w, True,
1617 /* I don't really understand sync-vs-async
1618 grabs, but this is what xterm does. */
1619 GrabModeAsync, GrabModeAsync,
1620 /* Use the timestamp of the last user action
1621 read by emacs proper; xterm uses CurrentTime
1622 but there's a comment that says "wrong"...
1623 (Despite the name this is the time of the
1624 last key or mouse event.) */
1625 DEVICE_X_MOUSE_TIMESTAMP (d));
1626 if (status == GrabSuccess)
1628 /* The XUngrabKeyboard should generate a FocusIn back to this
1629 window but it doesn't unless we explicitly set focus to the
1630 window first (which should already have it. The net result
1631 is that without this call when x-ungrab-keyboard is called
1632 the selected frame ends up not having focus. */
1633 XSetInputFocus (dpy, w, RevertToParent, DEVICE_X_MOUSE_TIMESTAMP (d));
1640 DEFUN ("x-ungrab-keyboard", Fx_ungrab_keyboard, 0, 1, 0, /*
1641 Release a keyboard grab made with `x-grab-keyboard'.
1645 Display *dpy = get_x_display (device);
1646 XUngrabKeyboard (dpy, CurrentTime);
1651 /************************************************************************/
1652 /* initialization */
1653 /************************************************************************/
1656 syms_of_device_x (void)
1658 DEFSUBR (Fx_debug_mode);
1659 DEFSUBR (Fx_get_resource);
1660 DEFSUBR (Fx_get_resource_prefix);
1661 DEFSUBR (Fx_put_resource);
1663 DEFSUBR (Fdefault_x_device);
1664 DEFSUBR (Fx_display_visual_class);
1665 DEFSUBR (Fx_display_visual_depth);
1666 DEFSUBR (Fx_server_vendor);
1667 DEFSUBR (Fx_server_version);
1668 DEFSUBR (Fx_valid_keysym_name_p);
1669 DEFSUBR (Fx_keysym_hashtable);
1670 DEFSUBR (Fx_keysym_on_keyboard_p);
1671 DEFSUBR (Fx_keysym_on_keyboard_sans_modifiers_p);
1673 DEFSUBR (Fx_grab_pointer);
1674 DEFSUBR (Fx_ungrab_pointer);
1675 DEFSUBR (Fx_grab_keyboard);
1676 DEFSUBR (Fx_ungrab_keyboard);
1678 defsymbol (&Qx_error, "x-error");
1679 defsymbol (&Qinit_pre_x_win, "init-pre-x-win");
1680 defsymbol (&Qinit_post_x_win, "init-post-x-win");
1684 console_type_create_device_x (void)
1686 CONSOLE_HAS_METHOD (x, init_device);
1687 CONSOLE_HAS_METHOD (x, finish_init_device);
1688 CONSOLE_HAS_METHOD (x, mark_device);
1689 CONSOLE_HAS_METHOD (x, delete_device);
1690 CONSOLE_HAS_METHOD (x, device_system_metrics);
1693 /* Initialize variables to speed up X resource interactions */
1694 CONST char *valid_resource_chars =
1695 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
1696 while (*valid_resource_chars)
1697 valid_resource_char_p[(unsigned int) (*valid_resource_chars++)] = 1;
1699 name_char_dynarr = Dynarr_new (char);
1700 class_char_dynarr = Dynarr_new (char);
1705 vars_of_device_x (void)
1707 DEFVAR_LISP ("x-emacs-application-class", &Vx_emacs_application_class /*
1708 The X application class of the XEmacs process.
1709 This controls, among other things, the name of the `app-defaults' file
1710 that XEmacs will use. For changes to this variable to take effect, they
1711 must be made before the connection to the X server is initialized, that is,
1712 this variable may only be changed before emacs is dumped, or by setting it
1713 in the file lisp/term/x-win.el.
1715 If this variable is nil before the connection to the X server is first
1716 initialized (which it is by default), the X resource database will be
1717 consulted and the value will be set according to whether any resources
1718 are found for the application class `XEmacs'. If the user has set any
1719 resources for the XEmacs application class, the XEmacs process will use
1720 the application class `XEmacs'. Otherwise, the XEmacs process will use
1721 the application class `Emacs' which is backwards compatible to previous
1722 XEmacs versions but may conflict with resources intended for GNU Emacs.
1724 Vx_emacs_application_class = Qnil;
1726 DEFVAR_LISP ("x-initial-argv-list", &Vx_initial_argv_list /*
1727 You don't want to know.
1728 This is used during startup to communicate the remaining arguments in
1729 `command-line-args-left' to the C code, which passes the args to
1730 the X initialization code, which removes some args, and then the
1731 args are placed back into `x-initial-arg-list' and thence into
1732 `command-line-args-left'. Perhaps `command-line-args-left' should
1735 Vx_initial_argv_list = Qnil;
1737 DEFVAR_BOOL ("x-seppuku-on-epipe", &x_seppuku_on_epipe /*
1738 When non-nil, terminate XEmacs immediately on SIGPIPE from the X server.
1739 XEmacs doesn't terminate properly on some systems.
1740 When this variable is non-nil, XEmacs will commit immediate suicide
1741 when it gets a sigpipe from the X Server.
1743 x_seppuku_on_epipe = 0;
1745 #if defined(MULE) && (defined(LWLIB_MENUBARS_MOTIF) || defined(HAVE_XIM) || defined (USE_XFONTSET))
1746 DEFVAR_LISP ("x-app-defaults-directory", &Vx_app_defaults_directory /*
1747 Used by the Lisp code to communicate to the low level X initialization
1748 where the localized init files are.
1750 Vx_app_defaults_directory = Qnil;
1755 staticpro (&Vdefault_x_device);
1756 Vdefault_x_device = Qnil;
1761 in_resource_setting = 0;