1 /* The event_stream interface for X11 with Xt, and/or tty frames.
2 Copyright (C) 1991-5, 1997 Free Software Foundation, Inc.
3 Copyright (C) 1995 Sun Microsystems, Inc.
4 Copyright (C) 1996 Ben Wing.
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Not in FSF. */
28 #include "console-x.h"
29 #include "../lwlib/lwlib.h"
30 #include "EmacsFrame.h"
32 #include "blocktype.h"
35 #include "console-tty.h"
38 #include "objects-x.h"
40 #include "redisplay.h"
44 #include "sysproc.h" /* for MAXDESC */
46 #include "xintrinsicp.h" /* CoreP.h needs this */
47 #include <X11/CoreP.h> /* Numerous places access the fields of
48 a core widget directly. We could
49 use XtGetValues(), but ... */
50 #include <X11/ShellP.h>
57 #include "file-coding.h"
64 #if defined (HAVE_OFFIX_DND)
69 /* Hmm, under unix we want X modifiers, under NT we want X modifiers if
70 we are running X and Windows modifiers otherwise.
71 gak. This is a kludge until we support multiple native GUIs!
78 #include "events-mod.h"
80 static void enqueue_Xt_dispatch_event (Lisp_Object event);
82 static struct event_stream *Xt_event_stream;
84 /* With the new event model, all events go through XtDispatchEvent()
85 and are picked up by an event handler that is added to each frame
86 widget. (This is how it's supposed to be.) In the old method,
87 Emacs sucks out events directly from XtNextEvent() and only
88 dispatches the events that it doesn't need to deal with. This
89 old way has lots of corresponding junk that is no longer
90 necessary: lwlib extensions, synthetic XAnyEvents, unnecessary
93 /* The one and only one application context that Emacs uses. */
94 XtAppContext Xt_app_con;
96 /* Do we accept events sent by other clients? */
97 int x_allow_sendevents;
99 int modifier_keys_are_sticky;
105 static int process_events_occurred;
106 static int tty_events_occurred;
108 /* Mask of bits indicating the descriptors that we wait for input on */
109 extern SELECT_TYPE input_wait_mask, process_only_mask, tty_only_mask;
111 static CONST String x_fallback_resources[] =
113 /* This file is automatically generated from the app-defaults file
114 in ../etc/Emacs.ad. These resources are consulted only if no
115 app-defaults file is found at all.
117 #include <Emacs.ad.h>
121 static Lisp_Object x_keysym_to_emacs_keysym (KeySym keysym, int simple_p);
122 void emacs_Xt_mapping_action (Widget w, XEvent *event);
123 void debug_process_finalization (struct Lisp_Process *p);
124 void emacs_Xt_event_handler (Widget wid, XtPointer closure, XEvent *event,
125 Boolean *continue_to_dispatch);
127 static int last_quit_check_signal_tick_count;
129 Lisp_Object Qkey_mapping;
130 Lisp_Object Qsans_modifiers;
133 /************************************************************************/
134 /* keymap handling */
135 /************************************************************************/
137 /* X bogusly doesn't define the interpretations of any bits besides
138 ModControl, ModShift, and ModLock; so the Interclient Communication
139 Conventions Manual says that we have to bend over backwards to figure
140 out what the other modifier bits mean. According to ICCCM:
142 - Any keycode which is assigned ModControl is a "control" key.
144 - Any modifier bit which is assigned to a keycode which generates Meta_L
145 or Meta_R is the modifier bit meaning "meta". Likewise for Super, Hyper,
148 - Any keypress event which contains ModControl in its state should be
149 interpreted as a "control" character.
151 - Any keypress event which contains a modifier bit in its state which is
152 generated by a keycode whose corresponding keysym is Meta_L or Meta_R
153 should be interpreted as a "meta" character. Likewise for Super, Hyper,
156 - It is illegal for a keysym to be associated with more than one modifier
159 This means that the only thing that emacs can reasonably interpret as a
160 "meta" key is a key whose keysym is Meta_L or Meta_R, and which generates
161 one of the modifier bits Mod1-Mod5.
163 Unfortunately, many keyboards don't have Meta keys in their default
164 configuration. So, if there are no Meta keys, but there are "Alt" keys,
165 emacs will interpret Alt as Meta. If there are both Meta and Alt keys,
166 then the Meta keys mean "Meta", and the Alt keys mean "Alt" (it used to
167 mean "Symbol," but that just confused the hell out of way too many people).
169 This works with the default configurations of the 19 keyboard-types I've
172 Emacs detects keyboard configurations which violate the above rules, and
173 prints an error message on the standard-error-output. (Perhaps it should
174 use a pop-up-window instead.)
178 x_reset_key_mapping (struct device *d)
180 Display *display = DEVICE_X_DISPLAY (d);
181 struct x_device *xd = DEVICE_X_DATA (d);
182 KeySym *keysym, *keysym_end;
183 Lisp_Object hash_table;
184 int key_code_count, keysyms_per_code;
186 if (xd->x_keysym_map)
187 XFree ((char *) xd->x_keysym_map);
188 XDisplayKeycodes (display,
189 &xd->x_keysym_map_min_code,
190 &xd->x_keysym_map_max_code);
191 key_code_count = xd->x_keysym_map_max_code - xd->x_keysym_map_min_code + 1;
193 XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count,
194 &xd->x_keysym_map_keysyms_per_code);
196 hash_table = xd->x_keysym_map_hash_table;
197 if (HASH_TABLEP (hash_table))
198 Fclrhash (hash_table);
200 xd->x_keysym_map_hash_table = hash_table =
201 make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
203 for (keysym = xd->x_keysym_map,
204 keysyms_per_code = xd->x_keysym_map_keysyms_per_code,
205 keysym_end = keysym + (key_code_count * keysyms_per_code);
207 keysym += keysyms_per_code)
211 if (keysym[0] == NoSymbol)
215 char *name = XKeysymToString (keysym[0]);
216 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[0], 0);
219 Fputhash (build_string (name), Qsans_modifiers, hash_table);
220 Fputhash (sym, Qsans_modifiers, hash_table);
224 for (j = 1; j < keysyms_per_code; j++)
226 if (keysym[j] != keysym[0] &&
227 keysym[j] != NoSymbol)
229 char *name = XKeysymToString (keysym[j]);
230 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[j], 0);
231 if (name && NILP (Fgethash (sym, hash_table, Qnil)))
233 Fputhash (build_string (name), Qt, hash_table);
234 Fputhash (sym, Qt, hash_table);
242 index_to_name (int indice)
246 case ShiftMapIndex: return "ModShift";
247 case LockMapIndex: return "ModLock";
248 case ControlMapIndex: return "ModControl";
249 case Mod1MapIndex: return "Mod1";
250 case Mod2MapIndex: return "Mod2";
251 case Mod3MapIndex: return "Mod3";
252 case Mod4MapIndex: return "Mod4";
253 case Mod5MapIndex: return "Mod5";
254 default: return "???";
258 /* Boy, I really wish C had local functions... */
259 struct c_doesnt_have_closures /* #### not yet used */
261 int warned_about_overlapping_modifiers;
262 int warned_about_predefined_modifiers;
263 int warned_about_duplicate_modifiers;
272 x_reset_modifier_mapping (struct device *d)
274 Display *display = DEVICE_X_DISPLAY (d);
275 struct x_device *xd = DEVICE_X_DATA (d);
276 int modifier_index, modifier_key, column, mkpm;
277 int warned_about_overlapping_modifiers = 0;
278 int warned_about_predefined_modifiers = 0;
279 int warned_about_duplicate_modifiers = 0;
286 xd->lock_interpretation = 0;
288 if (xd->x_modifier_keymap)
289 XFreeModifiermap (xd->x_modifier_keymap);
291 x_reset_key_mapping (d);
293 xd->x_modifier_keymap = XGetModifierMapping (display);
295 /* Boy, I really wish C had local functions...
298 /* The call to warn_when_safe must be on the same line as the string or
299 make-msgfile won't pick it up properly (the newline doesn't confuse
300 it, but the backslash does). */
302 #define modwarn(name,old,other) \
303 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is generated by %s.", \
304 name, code, index_to_name (old), other), \
305 warned_about_overlapping_modifiers = 1
307 #define modbarf(name,other) \
308 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
309 name, code, other), \
310 warned_about_predefined_modifiers = 1
312 #define check_modifier(name,mask) \
313 if ((1<<modifier_index) != mask) \
314 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
315 name, code, index_to_name (modifier_index)), \
316 warned_about_predefined_modifiers = 1
318 #define store_modifier(name,old) \
319 if (old && old != modifier_index) \
320 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates both %s and %s, which is nonsensical.",\
321 name, code, index_to_name (old), \
322 index_to_name (modifier_index)), \
323 warned_about_duplicate_modifiers = 1; \
324 if (modifier_index == ShiftMapIndex) modbarf (name,"ModShift"); \
325 else if (modifier_index == LockMapIndex) modbarf (name,"ModLock"); \
326 else if (modifier_index == ControlMapIndex) modbarf (name,"ModControl"); \
327 else if (sym == XK_Mode_switch) \
328 mode_bit = modifier_index; /* Mode_switch is special, see below... */ \
329 else if (modifier_index == meta_bit && old != meta_bit) \
330 modwarn (name, meta_bit, "Meta"); \
331 else if (modifier_index == super_bit && old != super_bit) \
332 modwarn (name, super_bit, "Super"); \
333 else if (modifier_index == hyper_bit && old != hyper_bit) \
334 modwarn (name, hyper_bit, "Hyper"); \
335 else if (modifier_index == alt_bit && old != alt_bit) \
336 modwarn (name, alt_bit, "Alt"); \
338 old = modifier_index;
340 mkpm = xd->x_modifier_keymap->max_keypermod;
341 for (modifier_index = 0; modifier_index < 8; modifier_index++)
342 for (modifier_key = 0; modifier_key < mkpm; modifier_key++) {
344 for (column = 0; column < 4; column += 2) {
345 KeyCode code = xd->x_modifier_keymap->modifiermap[modifier_index * mkpm
347 KeySym sym = (code ? XKeycodeToKeysym (display, code, column) : 0);
348 if (sym == last_sym) continue;
351 case XK_Mode_switch:store_modifier ("Mode_switch", mode_bit); break;
352 case XK_Meta_L: store_modifier ("Meta_L", meta_bit); break;
353 case XK_Meta_R: store_modifier ("Meta_R", meta_bit); break;
354 case XK_Super_L: store_modifier ("Super_L", super_bit); break;
355 case XK_Super_R: store_modifier ("Super_R", super_bit); break;
356 case XK_Hyper_L: store_modifier ("Hyper_L", hyper_bit); break;
357 case XK_Hyper_R: store_modifier ("Hyper_R", hyper_bit); break;
358 case XK_Alt_L: store_modifier ("Alt_L", alt_bit); break;
359 case XK_Alt_R: store_modifier ("Alt_R", alt_bit); break;
360 case XK_Control_L: check_modifier ("Control_L", ControlMask); break;
361 case XK_Control_R: check_modifier ("Control_R", ControlMask); break;
362 case XK_Shift_L: check_modifier ("Shift_L", ShiftMask); break;
363 case XK_Shift_R: check_modifier ("Shift_R", ShiftMask); break;
364 case XK_Shift_Lock: check_modifier ("Shift_Lock", LockMask);
365 xd->lock_interpretation = XK_Shift_Lock; break;
366 case XK_Caps_Lock: check_modifier ("Caps_Lock", LockMask);
367 xd->lock_interpretation = XK_Caps_Lock; break;
369 /* It probably doesn't make any sense for a modifier bit to be
370 assigned to a key that is not one of the above, but OpenWindows
371 assigns modifier bits to a couple of random function keys for
372 no reason that I can discern, so printing a warning here would
377 #undef store_modifier
378 #undef check_modifier
382 /* If there was no Meta key, then try using the Alt key instead.
383 If there is both a Meta key and an Alt key, then the Alt key
384 is not disturbed and remains an Alt key. */
385 if (! meta_bit && alt_bit)
386 meta_bit = alt_bit, alt_bit = 0;
388 /* mode_bit overrides everything, since it's processed down inside of
389 XLookupString() instead of by us. If Meta and Mode_switch both
390 generate the same modifier bit (which is an error), then we don't
391 interpret that bit as Meta, because we can't make XLookupString()
392 not interpret it as Mode_switch; and interpreting it as both would
396 CONST char *warn = 0;
397 if (mode_bit == meta_bit) warn = "Meta", meta_bit = 0;
398 else if (mode_bit == hyper_bit) warn = "Hyper", hyper_bit = 0;
399 else if (mode_bit == super_bit) warn = "Super", super_bit = 0;
400 else if (mode_bit == alt_bit) warn = "Alt", alt_bit = 0;
404 (Qkey_mapping, Qwarning,
405 "XEmacs: %s is being used for both Mode_switch and %s.",
406 index_to_name (mode_bit), warn),
407 warned_about_overlapping_modifiers = 1;
412 xd->MetaMask = (meta_bit ? (1 << meta_bit) : 0);
413 xd->HyperMask = (hyper_bit ? (1 << hyper_bit) : 0);
414 xd->SuperMask = (super_bit ? (1 << super_bit) : 0);
415 xd->AltMask = (alt_bit ? (1 << alt_bit) : 0);
416 xd->ModeMask = (mode_bit ? (1 << mode_bit) : 0); /* unused */
419 if (warned_about_overlapping_modifiers)
420 warn_when_safe (Qkey_mapping, Qwarning, "\n"
421 " Two distinct modifier keys (such as Meta and Hyper) cannot generate\n"
422 " the same modifier bit, because Emacs won't be able to tell which\n"
423 " modifier was actually held down when some other key is pressed. It\n"
424 " won't be able to tell Meta-x and Hyper-x apart, for example. Change\n"
425 " one of these keys to use some other modifier bit. If you intend for\n"
426 " these keys to have the same behavior, then change them to have the\n"
427 " same keysym as well as the same modifier bit.");
429 if (warned_about_predefined_modifiers)
430 warn_when_safe (Qkey_mapping, Qwarning, "\n"
431 " The semantics of the modifier bits ModShift, ModLock, and ModControl\n"
432 " are predefined. It does not make sense to assign ModControl to any\n"
433 " keysym other than Control_L or Control_R, or to assign any modifier\n"
434 " bits to the \"control\" keysyms other than ModControl. You can't\n"
435 " turn a \"control\" key into a \"meta\" key (or vice versa) by simply\n"
436 " assigning the key a different modifier bit. You must also make that\n"
437 " key generate an appropriate keysym (Control_L, Meta_L, etc).");
439 /* No need to say anything more for warned_about_duplicate_modifiers. */
441 if (warned_about_overlapping_modifiers || warned_about_predefined_modifiers)
442 warn_when_safe (Qkey_mapping, Qwarning, "\n"
443 " The meanings of the modifier bits Mod1 through Mod5 are determined\n"
444 " by the keysyms used to control those bits. Mod1 does NOT always\n"
445 " mean Meta, although some non-ICCCM-compliant programs assume that.");
449 x_init_modifier_mapping (struct device *d)
451 struct x_device *xd = DEVICE_X_DATA (d);
452 xd->x_keysym_map_hash_table = Qnil;
453 xd->x_keysym_map = NULL;
454 xd->x_modifier_keymap = NULL;
455 x_reset_modifier_mapping (d);
459 x_key_is_modifier_p (KeyCode keycode, struct device *d)
461 struct x_device *xd = DEVICE_X_DATA (d);
465 if (keycode < xd->x_keysym_map_min_code ||
466 keycode > xd->x_keysym_map_max_code)
469 syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
470 xd->x_keysym_map_keysyms_per_code];
471 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
472 if (IsModifierKey (syms [i]) ||
473 syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */
478 /* key-handling code is always ugly. It just ends up working out
481 Here are some pointers:
483 -- DOWN_MASK indicates which modifiers should be treated as "down"
484 when the corresponding upstroke happens. It gets reset for
485 a particular modifier when that modifier goes up, and reset
486 for all modifiers when a non-modifier key is pressed. Example:
488 I press Control-A-Shift and then release Control-A-Shift.
489 I want the Shift key to be sticky but not the Control key.
491 -- LAST_DOWNKEY and RELEASE_TIME are used to keep track of
492 auto-repeat -- see below.
494 -- If a modifier key is sticky, I can unstick it by pressing
495 the modifier key again. */
498 x_handle_sticky_modifiers (XEvent *ev, struct device *d)
504 if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */
507 xd = DEVICE_X_DATA (d);
508 keycode = ev->xkey.keycode;
511 if (keycode < xd->x_keysym_map_min_code ||
512 keycode > xd->x_keysym_map_max_code)
515 if (! ((type == KeyPress || type == KeyRelease) &&
516 x_key_is_modifier_p (keycode, d)))
517 { /* Not a modifier key */
518 Bool key_event_p = (type == KeyPress || type == KeyRelease);
520 if (type == KeyPress && !xd->last_downkey)
521 xd->last_downkey = keycode;
522 else if (type == ButtonPress ||
523 (type == KeyPress && xd->last_downkey &&
524 (keycode != xd->last_downkey ||
525 ev->xkey.time != xd->release_time)))
527 xd->need_to_add_mask = 0;
528 xd->last_downkey = 0;
530 if (type == KeyPress)
531 xd->release_time = 0;
532 if (type == KeyPress || type == ButtonPress)
536 ev->xkey.state |= xd->need_to_add_mask;
538 ev->xbutton.state |= xd->need_to_add_mask;
540 if (type == KeyRelease && keycode == xd->last_downkey)
541 /* If I hold press-and-release the Control key and then press
542 and hold down the right arrow, I want it to auto-repeat
543 Control-Right. On the other hand, if I do the same but
544 manually press the Right arrow a bunch of times, I want
545 to see one Control-Right and then a bunch of Rights.
546 This means that we need to distinguish between an
547 auto-repeated key and a key pressed and released a bunch
550 Naturally, the designers of the X spec didn't see fit
551 to provide an obvious way to distinguish these cases.
552 So we assume that if the release and the next press
553 occur at the same time, the key was actually auto-
554 repeated. Under Open-Windows, at least, this works. */
555 xd->release_time = key_event_p ? ev->xkey.time : ev->xbutton.time;
557 else /* Modifier key pressed */
560 KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
561 xd->x_keysym_map_keysyms_per_code];
563 /* If a non-modifier key was pressed in the middle of a bunch
564 of modifiers, then it unsticks all the modifiers that were
565 previously pressed. We cannot unstick the modifiers until
566 now because we want to check for auto-repeat of the
569 if (xd->last_downkey)
571 xd->last_downkey = 0;
572 xd->need_to_add_mask = 0;
577 if (type == KeyPress) \
579 /* If modifier key is already sticky, \
580 then unstick it. Note that we do \
581 not test down_mask to deal with the \
582 unlikely but possible case that the \
583 modifier key auto-repeats. */ \
584 if (xd->need_to_add_mask & mask) \
586 xd->need_to_add_mask &= ~mask; \
587 xd->down_mask &= ~mask; \
590 xd->down_mask |= mask; \
594 if (xd->down_mask & mask) \
596 xd->down_mask &= ~mask; \
597 xd->need_to_add_mask |= mask; \
602 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
605 case XK_Control_L: case XK_Control_R: FROB (ControlMask); break;
606 case XK_Shift_L: case XK_Shift_R: FROB (ShiftMask); break;
607 case XK_Meta_L: case XK_Meta_R: FROB (xd->MetaMask); break;
608 case XK_Super_L: case XK_Super_R: FROB (xd->SuperMask); break;
609 case XK_Hyper_L: case XK_Hyper_R: FROB (xd->HyperMask); break;
610 case XK_Alt_L: case XK_Alt_R: FROB (xd->AltMask); break;
617 clear_sticky_modifiers (struct device *d)
619 struct x_device *xd = DEVICE_X_DATA (d);
621 xd->need_to_add_mask = 0;
622 xd->last_downkey = 0;
623 xd->release_time = 0;
628 keysym_obeys_caps_lock_p (KeySym sym, struct device *d)
630 struct x_device *xd = DEVICE_X_DATA (d);
631 /* Eeeeevil hack. Don't apply Caps_Lock to things that aren't alphabetic
632 characters, where "alphabetic" means something more than simply A-Z.
633 That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC.
634 But if shift-lock is down, then it does. */
635 if (xd->lock_interpretation == XK_Shift_Lock)
639 ((sym >= XK_A) && (sym <= XK_Z)) ||
640 ((sym >= XK_a) && (sym <= XK_z)) ||
641 ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) ||
642 ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) ||
643 ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) ||
644 ((sym >= XK_oslash) && (sym <= XK_thorn));
647 /* called from EmacsFrame.c (actually from Xt itself) when a
648 MappingNotify event is received. In its infinite wisdom, Xt
649 decided that Xt event handlers never get MappingNotify events.
650 O'Reilly Xt Programming Manual 9.1.2 says:
652 MappingNotify is automatically handled by Xt, so it isn't passed
653 to event handlers and you don't need to worry about it.
655 Of course, we DO worry about it, so we need a special translation. */
657 emacs_Xt_mapping_action (Widget w, XEvent* event)
659 struct device *d = get_device_from_display (event->xany.display);
661 if (DEVICE_X_BEING_DELETED (d))
664 /* nyet. Now this is handled by Xt. */
665 XRefreshKeyboardMapping (&event->xmapping);
667 /* xmodmap generates about a billion MappingKeyboard events, followed
668 by a single MappingModifier event, so it might be worthwhile to
669 take extra MappingKeyboard events out of the queue before requesting
670 the current keymap from the server. */
671 switch (event->xmapping.request)
673 case MappingKeyboard: x_reset_key_mapping (d); break;
674 case MappingModifier: x_reset_modifier_mapping (d); break;
675 case MappingPointer: /* Do something here? */ break;
681 /************************************************************************/
682 /* X to Emacs event conversion */
683 /************************************************************************/
686 x_keysym_to_emacs_keysym (KeySym keysym, int simple_p)
689 if (keysym >= XK_exclam && keysym <= XK_asciitilde)
690 /* We must assume that the X keysym numbers for the ASCII graphic
691 characters are the same as their ASCII codes. */
692 return make_char (keysym);
696 /* These would be handled correctly by the default case, but by
697 special-casing them here we don't garbage a string or call
699 case XK_BackSpace: return QKbackspace;
700 case XK_Tab: return QKtab;
701 case XK_Linefeed: return QKlinefeed;
702 case XK_Return: return QKreturn;
703 case XK_Escape: return QKescape;
704 case XK_space: return QKspace;
705 case XK_Delete: return QKdelete;
708 if (simple_p) return Qnil;
709 /* !!#### not Mule-ized */
710 name = XKeysymToString (keysym);
711 if (!name || !name[0])
712 /* This happens if there is a mismatch between the Xlib of
713 XEmacs and the Xlib of the X server...
715 Let's hard-code in some knowledge of common keysyms introduced
716 in recent X11 releases. Snarfed from X11/keysymdef.h
718 Probably we should add some stuff here for X11R6. */
721 case 0xFF95: return KEYSYM ("kp-home");
722 case 0xFF96: return KEYSYM ("kp-left");
723 case 0xFF97: return KEYSYM ("kp-up");
724 case 0xFF98: return KEYSYM ("kp-right");
725 case 0xFF99: return KEYSYM ("kp-down");
726 case 0xFF9A: return KEYSYM ("kp-prior");
727 case 0xFF9B: return KEYSYM ("kp-next");
728 case 0xFF9C: return KEYSYM ("kp-end");
729 case 0xFF9D: return KEYSYM ("kp-begin");
730 case 0xFF9E: return KEYSYM ("kp-insert");
731 case 0xFF9F: return KEYSYM ("kp-delete");
733 case 0x1005FF10: return KEYSYM ("SunF36"); /* labeled F11 */
734 case 0x1005FF11: return KEYSYM ("SunF37"); /* labeled F12 */
738 sprintf (buf, "unknown-keysym-0x%X", (int) keysym);
742 /* If it's got a one-character name, that's good enough. */
744 return make_char (name[0]);
746 /* If it's in the "Keyboard" character set, downcase it.
747 The case of those keysyms is too totally random for us to
748 force anyone to remember them.
749 The case of the other character sets is significant, however.
751 if ((((unsigned int) keysym) & (~0x1FF)) == ((unsigned int) 0xFE00))
755 for (s1 = name, s2 = buf; *s1; s1++, s2++) {
759 *s2 = tolower (* (unsigned char *) s1);
765 return KEYSYM (name);
770 x_to_emacs_keysym (XKeyPressedEvent *event, int simple_p)
771 /* simple_p means don't try too hard (ASCII only) */
778 char *bufptr = buffer;
779 int bufsiz = sizeof (buffer);
782 XIC xic = FRAME_X_XIC (x_any_window_to_frame
783 (get_device_from_display (event->display),
785 #endif /* XIM_XLIB */
786 #endif /* HAVE_XIM */
788 /* We use XLookupString if we're not using XIM, or are using
789 XIM_XLIB but input context creation failed. */
790 #if ! (defined (HAVE_XIM) && defined (XIM_MOTIF))
791 #if defined (HAVE_XIM) && defined (XIM_XLIB)
793 #endif /* XIM_XLIB */
795 /* Apparently it's necessary to specify a dummy here (rather
796 than passing in 0) to avoid crashes on German IRIX */
798 XLookupString (event, dummy, 200, &keysym, 0);
799 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
800 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
802 #endif /* ! XIM_MOTIF */
805 Lookup_String: /* Come-From XBufferOverflow */
807 len = XmImMbLookupString (XtWindowToWidget (event->display, event->window),
808 event, bufptr, bufsiz, &keysym, &status);
810 len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
811 #endif /* HAVE_XIM */
814 if (x_debug_events > 0)
816 stderr_out (" status=");
817 #define print_status_when(S) if (status == S) stderr_out (#S)
818 print_status_when (XLookupKeySym);
819 print_status_when (XLookupBoth);
820 print_status_when (XLookupChars);
821 print_status_when (XLookupNone);
822 print_status_when (XBufferOverflow);
824 if (status == XLookupKeySym || status == XLookupBoth)
825 stderr_out (" keysym=%s", XKeysymToString (keysym));
826 if (status == XLookupChars || status == XLookupBoth)
831 stderr_out (" chars=\"");
832 for (j=0; j<len; j++)
833 stderr_out ("%c", bufptr[j]);
836 else if (bufptr[0] <= 32 || bufptr[0] >= 127)
837 stderr_out (" char=0x%x", bufptr[0]);
839 stderr_out (" char=%c", bufptr[0]);
843 #endif /* DEBUG_XEMACS */
849 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
850 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
854 /* Generate multiple emacs events */
855 struct device *d = get_device_from_display (event->display);
857 Lisp_Object instream, fb_instream;
859 struct gcpro gcpro1, gcpro2;
862 make_fixed_buffer_input_stream ((unsigned char *) bufptr, len);
864 /* ### Use Fget_coding_system (Vcomposed_input_coding_system) */
866 make_decoding_input_stream (XLSTREAM (fb_instream),
867 Fget_coding_system (Qundecided));
869 istr = XLSTREAM (instream);
871 GCPRO2 (instream, fb_instream);
872 while ((ch = Lstream_get_emchar (istr)) != EOF)
874 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
875 struct Lisp_Event *ev = XEVENT (emacs_event);
876 ev->channel = DEVICE_CONSOLE (d);
877 ev->event_type = key_press_event;
878 ev->timestamp = event->time;
879 ev->event.key.modifiers = 0;
880 ev->event.key.keysym = make_char (ch);
881 enqueue_Xt_dispatch_event (emacs_event);
883 Lstream_close (istr);
885 Lstream_delete (istr);
886 Lstream_delete (XLSTREAM (fb_instream));
889 case XLookupNone: return Qnil;
890 case XBufferOverflow:
891 bufptr = (char *) alloca (len+1);
895 return Qnil; /* not reached */
896 #endif /* HAVE_XIM */
900 set_last_server_timestamp (struct device *d, XEvent *x_event)
903 switch (x_event->type)
906 case KeyRelease: t = x_event->xkey.time; break;
908 case ButtonRelease: t = x_event->xbutton.time; break;
910 case LeaveNotify: t = x_event->xcrossing.time; break;
911 case MotionNotify: t = x_event->xmotion.time; break;
912 case PropertyNotify: t = x_event->xproperty.time; break;
913 case SelectionClear: t = x_event->xselectionclear.time; break;
914 case SelectionRequest: t = x_event->xselectionrequest.time; break;
915 case SelectionNotify: t = x_event->xselection.time; break;
918 DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t;
922 x_event_to_emacs_event (XEvent *x_event, struct Lisp_Event *emacs_event)
924 Display *display = x_event->xany.display;
925 struct device *d = get_device_from_display (display);
926 struct x_device *xd = DEVICE_X_DATA (d);
928 if (DEVICE_X_BEING_DELETED (d))
929 /* #### Uh, is this 0 correct? */
932 set_last_server_timestamp (d, x_event);
934 switch (x_event->type)
937 x_handle_sticky_modifiers (x_event, d);
944 unsigned int modifiers = 0;
946 Bool key_event_p = (x_event->type == KeyPress);
947 unsigned int *state =
948 key_event_p ? &x_event->xkey.state : &x_event->xbutton.state;
950 /* If this is a synthetic KeyPress or Button event, and the user
951 has expressed a disinterest in this security hole, then drop
954 ? x_event->xkey.send_event
955 : x_event->xbutton.send_event)
956 #ifdef EXTERNAL_WIDGET
957 /* ben: events get sent to an ExternalShell using XSendEvent.
958 This is not a perfect solution. */
959 && !FRAME_X_EXTERNAL_WINDOW_P
960 (x_any_window_to_frame (d, x_event->xany.window))
962 && !x_allow_sendevents)
965 DEVICE_X_MOUSE_TIMESTAMP (d) =
966 DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
967 key_event_p ? x_event->xkey.time : x_event->xbutton.time;
969 x_handle_sticky_modifiers (x_event, d);
971 if (*state & ControlMask) modifiers |= MOD_CONTROL;
972 if (*state & xd->MetaMask) modifiers |= MOD_META;
973 if (*state & xd->SuperMask) modifiers |= MOD_SUPER;
974 if (*state & xd->HyperMask) modifiers |= MOD_HYPER;
975 if (*state & xd->AltMask) modifiers |= MOD_ALT;
977 /* Ignore the Caps_Lock key if:
978 - any other modifiers are down, so that Caps_Lock doesn't
979 turn C-x into C-X, which would suck.
980 - the event was a mouse event. */
981 if (modifiers || ! key_event_p)
982 *state &= (~LockMask);
984 shift_p = *state & ShiftMask;
985 lock_p = *state & LockMask;
987 if (shift_p || lock_p)
988 modifiers |= MOD_SHIFT;
993 XKeyEvent *ev = &x_event->xkey;
994 /* This used to compute the frame from the given X window and
995 store it here, but we really don't care about the frame. */
996 emacs_event->channel = DEVICE_CONSOLE (d);
997 keysym = x_to_emacs_keysym (&x_event->xkey, 0);
999 /* If the emacs keysym is nil, then that means that the X
1000 keysym was either a Modifier or NoSymbol, which
1001 probably means that we're in the midst of reading a
1002 Multi_key sequence, or a "dead" key prefix, or XIM
1003 input. Ignore it. */
1007 /* More Caps_Lock garbage: Caps_Lock should *only* add the
1008 shift modifier to two-case keys (that is, A-Z and
1009 related characters). So at this point (after looking up
1010 the keysym) if the keysym isn't a dual-case alphabetic,
1011 and if the caps lock key was down but the shift key
1012 wasn't, then turn off the shift modifier. Gag barf */
1013 /* #### type lossage: assuming equivalence of emacs and
1015 /* !!#### maybe fix for Mule */
1016 if (lock_p && !shift_p &&
1017 ! (CHAR_OR_CHAR_INTP (keysym)
1018 && keysym_obeys_caps_lock_p
1019 ((KeySym) XCHAR_OR_CHAR_INT (keysym), d)))
1020 modifiers &= (~MOD_SHIFT);
1022 /* If this key contains two distinct keysyms, that is,
1023 "shift" generates a different keysym than the
1024 non-shifted key, then don't apply the shift modifier
1025 bit: it's implicit. Otherwise, if there would be no
1026 other way to tell the difference between the shifted
1027 and unshifted version of this key, apply the shift bit.
1028 Non-graphics, like Backspace and F1 get the shift bit
1029 in the modifiers slot. Neither the characters "a",
1030 "A", "2", nor "@" normally have the shift bit set.
1031 However, "F1" normally does. */
1032 if (modifiers & MOD_SHIFT)
1034 int Mode_switch_p = *state & xd->ModeMask;
1035 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0);
1036 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1);
1037 if (top && bot && top != bot)
1038 modifiers &= ~MOD_SHIFT;
1040 emacs_event->event_type = key_press_event;
1041 emacs_event->timestamp = ev->time;
1042 emacs_event->event.key.modifiers = modifiers;
1043 emacs_event->event.key.keysym = keysym;
1045 else /* Mouse press/release event */
1047 XButtonEvent *ev = &x_event->xbutton;
1048 struct frame *frame = x_window_to_frame (d, ev->window);
1050 return 0; /* not for us */
1051 XSETFRAME (emacs_event->channel, frame);
1053 emacs_event->event_type = (x_event->type == ButtonPress) ?
1054 button_press_event : button_release_event;
1056 emacs_event->event.button.modifiers = modifiers;
1057 emacs_event->timestamp = ev->time;
1058 emacs_event->event.button.button = ev->button;
1059 emacs_event->event.button.x = ev->x;
1060 emacs_event->event.button.y = ev->y;
1068 XMotionEvent *ev = &x_event->xmotion;
1069 struct frame *frame = x_window_to_frame (d, ev->window);
1070 unsigned int modifiers = 0;
1071 XMotionEvent event2;
1074 return 0; /* not for us */
1076 /* We use MotionHintMask, so we will get only one motion event
1077 until the next time we call XQueryPointer or the user
1078 clicks the mouse. So call XQueryPointer now (meaning that
1079 the event will be in sync with the server just before
1080 Fnext_event() returns). If the mouse is still in motion,
1081 then the server will immediately generate exactly one more
1082 motion event, which will be on the queue waiting for us
1083 next time around. */
1085 if (XQueryPointer (event2.display, event2.window,
1086 &event2.root, &event2.subwindow,
1087 &event2.x_root, &event2.y_root,
1088 &event2.x, &event2.y,
1090 ev = &event2; /* only one structure copy */
1092 DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
1094 XSETFRAME (emacs_event->channel, frame);
1095 emacs_event->event_type = pointer_motion_event;
1096 emacs_event->timestamp = ev->time;
1097 emacs_event->event.motion.x = ev->x;
1098 emacs_event->event.motion.y = ev->y;
1099 if (ev->state & ShiftMask) modifiers |= MOD_SHIFT;
1100 if (ev->state & ControlMask) modifiers |= MOD_CONTROL;
1101 if (ev->state & xd->MetaMask) modifiers |= MOD_META;
1102 if (ev->state & xd->SuperMask) modifiers |= MOD_SUPER;
1103 if (ev->state & xd->HyperMask) modifiers |= MOD_HYPER;
1104 if (ev->state & xd->AltMask) modifiers |= MOD_ALT;
1105 /* Currently ignores Shift_Lock but probably shouldn't
1106 (but it definitely should ignore Caps_Lock). */
1107 emacs_event->event.motion.modifiers = modifiers;
1113 /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
1114 passed as the timestamp of the TAKE_FOCUS, which the ICCCM
1115 explicitly prohibits. */
1116 XClientMessageEvent *ev = &x_event->xclient;
1117 #ifdef HAVE_OFFIX_DND
1118 if (DndIsDropMessage(x_event))
1120 unsigned int state, modifiers = 0, button=0;
1121 struct frame *frame = x_any_window_to_frame (d, ev->window);
1123 unsigned long size, dtype;
1124 Lisp_Object l_type = Qnil, l_data = Qnil;
1125 Lisp_Object l_dndlist = Qnil, l_item = Qnil;
1126 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1128 GCPRO4 (l_type, l_data, l_dndlist, l_item);
1131 return 0; /* not for us */
1132 XSETFRAME (emacs_event->channel, frame);
1134 emacs_event->event_type = misc_user_event;
1135 emacs_event->timestamp = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1137 state=DndDragButtons(x_event);
1139 if (state & ShiftMask) modifiers |= MOD_SHIFT;
1140 if (state & ControlMask) modifiers |= MOD_CONTROL;
1141 if (state & xd->MetaMask) modifiers |= MOD_META;
1142 if (state & xd->SuperMask) modifiers |= MOD_SUPER;
1143 if (state & xd->HyperMask) modifiers |= MOD_HYPER;
1144 if (state & xd->AltMask) modifiers |= MOD_ALT;
1146 if (state & Button5Mask) button = Button5;
1147 if (state & Button4Mask) button = Button4;
1148 if (state & Button3Mask) button = Button3;
1149 if (state & Button2Mask) button = Button2;
1150 if (state & Button1Mask) button = Button1;
1152 emacs_event->event.misc.modifiers = modifiers;
1153 emacs_event->event.misc.button = button;
1155 DndDropCoordinates(FRAME_X_TEXT_WIDGET(frame), x_event,
1156 &(emacs_event->event.misc.x),
1157 &(emacs_event->event.misc.y) );
1159 DndGetData(x_event,&data,&size);
1161 dtype=DndDataType(x_event);
1164 case DndFiles: /* null terminated strings, end null */
1171 len = strlen ((char*)data);
1172 hurl = dnd_url_hexify_string ((char *)data, "file:");
1173 l_item = make_string ((Bufbyte *)hurl, strlen (hurl));
1174 l_dndlist = Fcons (l_item, l_dndlist);
1178 l_type = Qdragdrop_URL;
1182 l_type = Qdragdrop_MIME;
1183 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
1184 make_string ((Bufbyte *)"8bit", 4),
1185 make_ext_string ((Extbyte *)data,
1186 strlen((char *)data),
1190 /* we have to parse this in some way to extract
1191 content-type and params (in the tm way) and
1193 OR: if data is string, let tm do the job
1194 if data is list[2], give the first two
1197 l_type = Qdragdrop_MIME;
1198 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1199 strlen((char *)data),
1207 char *hurl = dnd_url_hexify_string ((char *) data, "file:");
1209 l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
1211 l_type = Qdragdrop_URL;
1217 /* as it is a real URL it should already be escaped
1218 and escaping again will break them (cause % is unsave) */
1219 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1220 strlen ((char *)data),
1222 l_type = Qdragdrop_URL;
1224 default: /* Unknown, RawData and any other type */
1225 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"application/octet-stream", 24) ),
1226 make_string ((Bufbyte *)"8bit", 4),
1227 make_ext_string ((Extbyte *)data,
1230 l_type = Qdragdrop_MIME;
1234 emacs_event->event.misc.function = Qdragdrop_drop_dispatch;
1235 emacs_event->event.misc.object = Fcons (l_type, l_dndlist);
1241 #endif /* HAVE_OFFIX_DND */
1242 if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
1243 && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
1244 && (Atom) (ev->data.l[1]) == 0)
1246 ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1251 default: /* it's a magic event */
1253 struct frame *frame;
1255 XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
1257 #define FROB(event_member, window_member) \
1258 x_event_copy->event_member = x_event->event_member; \
1259 w = x_event->event_member.window_member
1261 switch (x_event->type)
1263 case SelectionRequest: FROB(xselectionrequest, owner); break;
1264 case SelectionClear: FROB(xselectionclear, window); break;
1265 case SelectionNotify: FROB(xselection, requestor); break;
1266 case PropertyNotify: FROB(xproperty, window); break;
1267 case ClientMessage: FROB(xclient, window); break;
1268 case ConfigureNotify: FROB(xconfigure, window); break;
1270 case GraphicsExpose: FROB(xexpose, window); break;
1272 case UnmapNotify: FROB(xmap, window); break;
1274 case LeaveNotify: FROB(xcrossing, window); break;
1276 case FocusOut: FROB(xfocus, window); break;
1277 case VisibilityNotify: FROB(xvisibility, window); break;
1279 w = x_event->xany.window;
1280 *x_event_copy = *x_event;
1284 frame = x_any_window_to_frame (d, w);
1289 emacs_event->event_type = magic_event;
1290 XSETFRAME (emacs_event->channel, frame);
1300 /************************************************************************/
1301 /* magic-event handling */
1302 /************************************************************************/
1305 handle_focus_event_1 (struct frame *f, int in_p)
1308 XIM_focus_event (f, in_p);
1309 #endif /* HAVE_XIM */
1311 /* On focus change, clear all memory of sticky modifiers
1312 to avoid non-intuitive behavior. */
1313 clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f)));
1315 /* We don't want to handle the focus change now, because we might
1316 be in an accept-process-output, sleep-for, or sit-for. So
1319 Actually, we half handle it: we handle it as far as changing the
1320 box cursor for redisplay, but we don't call any hooks or do any
1321 select-frame stuff until after the sit-for.
1326 struct gcpro gcpro1;
1329 conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
1331 emacs_handle_focus_change_preliminary (conser);
1332 enqueue_magic_eval_event (emacs_handle_focus_change_final,
1338 /* This is called from the external-widget code */
1340 void emacs_Xt_handle_focus_event (XEvent *event);
1342 emacs_Xt_handle_focus_event (XEvent *event)
1344 struct device *d = get_device_from_display (event->xany.display);
1347 if (DEVICE_X_BEING_DELETED (d))
1351 * It's curious that we're using x_any_window_to_frame() instead
1352 * of x_window_to_frame(). I don't know what the impact of this is.
1354 f = x_any_window_to_frame (d, event->xfocus.window);
1356 /* focus events are sometimes generated just before
1357 a frame is destroyed. */
1359 handle_focus_event_1 (f, event->type == FocusIn);
1362 /* both MapNotify and VisibilityNotify can cause this
1363 JV is_visible has the same semantics as f->visible*/
1365 change_frame_visibility (struct frame *f, int is_visible)
1369 XSETFRAME (frame, f);
1371 if (!FRAME_VISIBLE_P (f) && is_visible)
1373 FRAME_VISIBLE_P (f) = is_visible;
1374 /* This improves the double flicker when uniconifying a frame
1375 some. A lot of it is not showing a buffer which has changed
1376 while the frame was iconified. To fix it further requires
1377 the good 'ol double redisplay structure. */
1378 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1379 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1381 else if (FRAME_VISIBLE_P (f) && !is_visible)
1383 FRAME_VISIBLE_P (f) = 0;
1384 va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
1386 else if (FRAME_VISIBLE_P (f) * is_visible < 0)
1388 FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f);
1389 if (FRAME_REPAINT_P(f))
1390 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1391 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1396 handle_map_event (struct frame *f, XEvent *event)
1400 XSETFRAME (frame, f);
1401 if (event->type == MapNotify)
1403 XWindowAttributes xwa;
1405 /* Bleagh!!!!!! Apparently some window managers (e.g. MWM)
1406 send synthetic MapNotify events when a window is first
1407 created, EVENT IF IT'S CREATED ICONIFIED OR INVISIBLE.
1408 Or something like that. We initially tried a different
1409 solution below, but that ran into a different window-
1412 It seems that the only reliable way is to treat a
1413 MapNotify event as a "hint" that the window might or
1414 might not be visible, and check explicitly. */
1416 XGetWindowAttributes (event->xany.display, event->xmap.window,
1418 if (xwa.map_state != IsViewable)
1420 /* Calling Fframe_iconified_p is the only way we have to
1421 correctly update FRAME_ICONIFIED_P */
1422 Fframe_iconified_p (frame);
1426 FRAME_X_TOTALLY_VISIBLE_P (f) = 1;
1428 /* Bleagh again!!!! We initially tried the following hack
1429 around the MWM problem, but it turns out that TWM
1430 has a race condition when you un-iconify, where it maps
1431 the window and then tells the server that the window
1432 is un-iconified. Usually, XEmacs wakes up between
1433 those two occurrences, and thus thinks that un-iconified
1434 windows are still iconified.
1436 Ah, the joys of X. */
1438 /* By Emacs definition, a frame that is iconified is not
1439 visible. Marking a frame as visible will automatically cause
1440 frame-iconified-p to return nil, regardless of whether the
1441 frame is actually iconified. Therefore, we have to ignore
1442 MapNotify events on iconified frames. (It's not obvious
1443 to me why these are being sent, but it happens at startup
1444 with frames that are initially iconified; perhaps they are
1445 synthetic MapNotify events coming from the window manager.)
1446 Note that `frame-iconified-p' queries the server
1447 to determine whether the frame is currently iconified,
1448 rather than consulting some internal (and likely
1449 inaccurate) state flag. Therefore, ignoring the MapNotify
1451 if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (frame)))
1453 change_frame_visibility (f, 1);
1457 FRAME_X_TOTALLY_VISIBLE_P (f) = 0;
1458 change_frame_visibility (f, 0);
1459 /* Calling Fframe_iconified_p is the only way we have to
1460 correctly update FRAME_ICONIFIED_P */
1461 Fframe_iconified_p (frame);
1466 handle_client_message (struct frame *f, XEvent *event)
1468 struct device *d = XDEVICE (FRAME_DEVICE (f));
1471 XSETFRAME (frame, f);
1473 if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1474 (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d))
1476 /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages,
1477 such as WM_TAKE_FOCUS, are eval events. That's because delete-window
1478 was probably executed with a mouse click, while the others could
1479 have been sent as a result of mouse motion or some other implicit
1480 action. (Call this a "heuristic"...) The reason for caring about
1481 this is so that clicking on the close-box will make emacs prompt
1482 using a dialog box instead of the minibuffer if there are unsaved
1485 enqueue_misc_user_event (frame, Qeval,
1486 list3 (Qdelete_frame, frame, Qt));
1488 else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1489 (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
1491 handle_focus_event_1 (f, 1);
1493 /* If there is a dialog box up, focus on it.
1495 #### Actually, we're raising it too, which is wrong. We should
1496 #### just focus on it, but lwlib doesn't currently give us an
1497 #### easy way to do that. This should be fixed.
1499 unsigned long take_focus_timestamp = event->xclient.data.l[1];
1500 Widget widget = lw_raise_all_pop_up_widgets ();
1503 /* kludge: raise_all returns bottommost widget, but we really
1504 want the topmost. So just raise it for now. */
1505 XMapRaised (XtDisplay (widget), XtWindow (widget));
1506 /* Grab the focus with the timestamp of the TAKE_FOCUS. */
1507 XSetInputFocus (XtDisplay (widget), XtWindow (widget),
1508 RevertToParent, take_focus_timestamp);
1515 emacs_Xt_handle_magic_event (struct Lisp_Event *emacs_event)
1517 /* This function can GC */
1518 XEvent *event = &emacs_event->event.magic.underlying_x_event;
1519 struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
1521 if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
1524 switch (event->type)
1526 case SelectionRequest:
1527 x_handle_selection_request (&event->xselectionrequest);
1530 case SelectionClear:
1531 x_handle_selection_clear (&event->xselectionclear);
1534 case SelectionNotify:
1535 x_handle_selection_notify (&event->xselection);
1538 case PropertyNotify:
1539 x_handle_property_notify (&event->xproperty);
1543 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1544 event->xexpose.width, event->xexpose.height);
1547 case GraphicsExpose: /* This occurs when an XCopyArea's source area was
1548 obscured or not available. */
1549 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1550 event->xexpose.width, event->xexpose.height);
1555 handle_map_event (f, event);
1559 if (event->xcrossing.detail != NotifyInferior)
1563 XSETFRAME (frame, f);
1564 /* FRAME_X_MOUSE_P (f) = 1; */
1565 va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
1570 if (event->xcrossing.detail != NotifyInferior)
1574 XSETFRAME (frame, f);
1575 /* FRAME_X_MOUSE_P (f) = 0; */
1576 va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
1582 #ifdef EXTERNAL_WIDGET
1583 /* External widget lossage: Ben said:
1584 YUCK. The only way to make focus changes work properly is to
1585 completely ignore all FocusIn/FocusOut events and depend only
1586 on notifications from the ExternalClient widget. */
1587 if (FRAME_X_EXTERNAL_WINDOW_P (f))
1590 handle_focus_event_1 (f, event->type == FocusIn);
1594 handle_client_message (f, event);
1597 case VisibilityNotify: /* window visibility has changed */
1598 if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
1600 FRAME_X_TOTALLY_VISIBLE_P (f) =
1601 (event->xvisibility.state == VisibilityUnobscured);
1602 /* Note that the fvwm pager only sends VisibilityNotify when
1603 changing pages. Is this all we need to do ? JV */
1604 /* Nope. We must at least trigger a redisplay here.
1605 Since this case seems similar to MapNotify, I've
1606 factored out some code to change_frame_visibility().
1607 This triggers the necessary redisplay and runs
1608 (un)map-frame-hook. - dkindred@cs.cmu.edu */
1609 /* Changed it again to support the tristate visibility flag */
1610 change_frame_visibility (f, (event->xvisibility.state
1611 != VisibilityFullyObscured) ? 1 : -1);
1615 case ConfigureNotify:
1617 XIM_SetGeometry (f);
1627 /************************************************************************/
1628 /* timeout events */
1629 /************************************************************************/
1631 static int timeout_id_tick;
1633 /* Xt interval id's might not fit into an int (they're pointers, as it
1634 happens), so we need to provide a conversion list. */
1639 XtIntervalId interval_id;
1640 struct Xt_timeout *next;
1641 } *pending_timeouts, *completed_timeouts;
1643 struct Xt_timeout_blocktype
1645 Blocktype_declare (struct Xt_timeout);
1646 } *the_Xt_timeout_blocktype;
1648 /* called by XtAppNextEvent() */
1650 Xt_timeout_callback (XtPointer closure, XtIntervalId *id)
1652 struct Xt_timeout *timeout = (struct Xt_timeout *) closure;
1653 struct Xt_timeout *t2 = pending_timeouts;
1654 /* Remove this one from the list of pending timeouts */
1656 pending_timeouts = pending_timeouts->next;
1659 while (t2->next && t2->next != timeout) t2 = t2->next;
1661 t2->next = t2->next->next;
1663 /* Add this one to the list of completed timeouts */
1664 timeout->next = completed_timeouts;
1665 completed_timeouts = timeout;
1669 emacs_Xt_add_timeout (EMACS_TIME thyme)
1671 struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype);
1672 EMACS_TIME current_time;
1675 timeout->id = timeout_id_tick++;
1676 timeout->next = pending_timeouts;
1677 pending_timeouts = timeout;
1678 EMACS_GET_TIME (current_time);
1679 EMACS_SUB_TIME (thyme, thyme, current_time);
1680 milliseconds = EMACS_SECS (thyme) * 1000 +
1681 EMACS_USECS (thyme) / 1000;
1682 if (milliseconds < 1)
1684 timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds,
1685 Xt_timeout_callback,
1686 (XtPointer) timeout);
1691 emacs_Xt_remove_timeout (int id)
1693 struct Xt_timeout *timeout, *t2;
1697 /* Find the timeout on the list of pending ones, if it's still there. */
1698 if (pending_timeouts)
1700 if (id == pending_timeouts->id)
1702 timeout = pending_timeouts;
1703 pending_timeouts = pending_timeouts->next;
1707 t2 = pending_timeouts;
1708 while (t2->next && t2->next->id != id) t2 = t2->next;
1709 if ( t2->next) /*found it */
1712 t2->next = t2->next->next;
1715 /* if it was pending, we have removed it from the list */
1717 XtRemoveTimeOut (timeout->interval_id);
1720 /* It could be that the Xt call back was already called but we didn't convert
1721 into an Emacs event yet */
1722 if (!timeout && completed_timeouts)
1724 /* Code duplication! */
1725 if (id == completed_timeouts->id)
1727 timeout = completed_timeouts;
1728 completed_timeouts = completed_timeouts->next;
1732 t2 = completed_timeouts;
1733 while (t2->next && t2->next->id != id) t2 = t2->next;
1734 if ( t2->next) /*found it */
1737 t2->next = t2->next->next;
1742 /* If we found the thing on the lists of timeouts,
1743 and removed it, deallocate
1746 Blocktype_free (the_Xt_timeout_blocktype, timeout);
1750 Xt_timeout_to_emacs_event (struct Lisp_Event *emacs_event)
1752 struct Xt_timeout *timeout = completed_timeouts;
1754 completed_timeouts = completed_timeouts->next;
1755 emacs_event->event_type = timeout_event;
1756 /* timeout events have nil as channel */
1757 emacs_event->timestamp = 0; /* #### wrong!! */
1758 emacs_event->event.timeout.interval_id = timeout->id;
1759 emacs_event->event.timeout.function = Qnil;
1760 emacs_event->event.timeout.object = Qnil;
1761 Blocktype_free (the_Xt_timeout_blocktype, timeout);
1765 /************************************************************************/
1766 /* process and tty events */
1767 /************************************************************************/
1769 struct what_is_ready_closure
1776 static Lisp_Object *filedesc_with_input;
1777 static struct what_is_ready_closure **filedesc_to_what_closure;
1780 init_what_input_once (void)
1784 filedesc_with_input = xnew_array (Lisp_Object, MAXDESC);
1785 filedesc_to_what_closure =
1786 xnew_array (struct what_is_ready_closure *, MAXDESC);
1788 for (i = 0; i < MAXDESC; i++)
1790 filedesc_to_what_closure[i] = 0;
1791 filedesc_with_input[i] = Qnil;
1794 process_events_occurred = 0;
1795 tty_events_occurred = 0;
1799 mark_what_as_being_ready (struct what_is_ready_closure *closure)
1801 if (NILP (filedesc_with_input[closure->fd]))
1803 SELECT_TYPE temp_mask;
1804 FD_ZERO (&temp_mask);
1805 FD_SET (closure->fd, &temp_mask);
1806 /* Check to make sure there's *really* input available.
1807 Sometimes things seem to get confused and this gets called
1808 for the tty fd when there's really only input available
1809 on some process's fd. (It will subsequently get called
1810 for that process's fd, so returning without setting any
1811 flags will take care of it.) To see the problem, uncomment
1812 the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
1813 down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
1814 and press return repeatedly. (Seen under AIX & Linux.)
1815 -dkindred@cs.cmu.edu */
1816 if (!poll_fds_for_input (temp_mask))
1819 stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
1824 filedesc_with_input[closure->fd] = closure->what;
1825 if (PROCESSP (closure->what))
1826 /* Don't increment this if the current process is already marked
1827 * as having input. */
1828 process_events_occurred++;
1830 tty_events_occurred++;
1835 Xt_what_callback (void *closure, int *source, XtInputId *id)
1837 /* If closure is 0, then we got a fake event from a signal handler.
1838 The only purpose of this is to make XtAppProcessEvent() stop
1841 mark_what_as_being_ready ((struct what_is_ready_closure *) closure);
1844 fake_event_occurred++;
1845 drain_signal_event_pipe ();
1850 select_filedesc (int fd, Lisp_Object what)
1852 struct what_is_ready_closure *closure;
1854 /* If somebody is trying to select something that's already selected
1855 for, then something went wrong. The generic routines ought to
1856 detect this and error before here. */
1857 assert (!filedesc_to_what_closure[fd]);
1859 closure = xnew (struct what_is_ready_closure);
1861 closure->what = what;
1863 XtAppAddInput (Xt_app_con, fd,
1864 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
1865 Xt_what_callback, closure);
1866 filedesc_to_what_closure[fd] = closure;
1870 unselect_filedesc (int fd)
1872 struct what_is_ready_closure *closure = filedesc_to_what_closure[fd];
1875 if (!NILP (filedesc_with_input[fd]))
1877 /* We are unselecting this process before we have drained the rest of
1878 the input from it, probably from status_notify() in the command loop.
1879 This can happen like so:
1881 - We are waiting in XtAppNextEvent()
1882 - Process generates output
1883 - Process is marked as being ready
1884 - Process dies, SIGCHLD gets generated before we return (!?)
1885 It could happen I guess.
1886 - sigchld_handler() marks process as dead
1887 - Somehow we end up getting a new KeyPress event on the queue
1888 at the same time (I'm really so sure how that happens but I'm
1889 not sure it can't either so let's assume it can...).
1890 - Key events have priority so we return that instead of the proc.
1891 - Before dispatching the lisp key event we call status_notify()
1892 - Which deselects the process that SIGCHLD marked as dead.
1894 Thus we never remove it from _with_input and turn it into a lisp
1895 event, so we need to do it here. But this does not mean that we're
1896 throwing away the last block of output - status_notify() has already
1897 taken care of running the proc filter or whatever.
1899 filedesc_with_input[fd] = Qnil;
1900 if (PROCESSP (closure->what))
1902 assert (process_events_occurred > 0);
1903 process_events_occurred--;
1907 assert (tty_events_occurred > 0);
1908 tty_events_occurred--;
1911 XtRemoveInput (closure->id);
1913 filedesc_to_what_closure[fd] = 0;
1917 emacs_Xt_select_process (struct Lisp_Process *p)
1919 Lisp_Object process;
1920 int infd = event_stream_unixoid_select_process (p);
1922 XSETPROCESS (process, p);
1923 select_filedesc (infd, process);
1927 emacs_Xt_unselect_process (struct Lisp_Process *p)
1929 int infd = event_stream_unixoid_unselect_process (p);
1931 unselect_filedesc (infd);
1935 emacs_Xt_create_stream_pair (void* inhandle, void* outhandle,
1936 Lisp_Object* instream, Lisp_Object* outstream, int flags)
1938 USID u = event_stream_unixoid_create_stream_pair
1939 (inhandle, outhandle, instream, outstream, flags);
1940 if (u != USID_ERROR)
1946 emacs_Xt_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream)
1948 event_stream_unixoid_delete_stream_pair (instream, outstream);
1949 return USID_DONTHASH;
1952 /* This is called from GC when a process object is about to be freed.
1953 If we've still got pointers to it in this file, we're gonna lose hard.
1956 debug_process_finalization (struct Lisp_Process *p)
1960 Lisp_Object instr, outstr;
1962 get_process_streams (p, &instr, &outstr);
1963 /* if it still has fds, then it hasn't been killed yet. */
1964 assert (NILP(instr));
1965 assert (NILP(outstr));
1966 /* Better not still be in the "with input" table; we know it's got no fds. */
1967 for (i = 0; i < MAXDESC; i++)
1969 Lisp_Object process = filedesc_fds_with_input [i];
1970 assert (!PROCESSP (process) || XPROCESS (process) != p);
1976 Xt_process_to_emacs_event (struct Lisp_Event *emacs_event)
1979 Lisp_Object process;
1981 assert (process_events_occurred > 0);
1982 for (i = 0; i < MAXDESC; i++)
1984 process = filedesc_with_input[i];
1985 if (PROCESSP (process))
1988 assert (i < MAXDESC);
1989 filedesc_with_input[i] = Qnil;
1990 process_events_occurred--;
1991 /* process events have nil as channel */
1992 emacs_event->event_type = process_event;
1993 emacs_event->timestamp = 0; /* #### */
1994 emacs_event->event.process.process = process;
1998 emacs_Xt_select_console (struct console *con)
2000 Lisp_Object console;
2006 if (CONSOLE_X_P (con))
2007 return; /* X consoles are automatically selected for when we
2008 initialize them in Xt */
2009 infd = event_stream_unixoid_select_console (con);
2010 XSETCONSOLE (console, con);
2011 select_filedesc (infd, console);
2013 /* On a stream device (ie: noninteractive), bad things can happen. */
2014 if (EQ (CONSOLE_TYPE (con), Qtty)) {
2015 mousefd = CONSOLE_TTY_MOUSE_FD (con);
2016 /* We check filedesc_to_what_closure[fd] here because if you run
2017 ** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
2018 ** if you run gnuattach to connect to another TTY, it will fire up
2019 ** GPM again, and try to reselect the mouse fd. GPM uses the same
2020 ** fd for every connection apparently, and select_filedesc will
2021 ** fail its assertion if we try to select it twice.
2023 if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
2024 select_filedesc (mousefd, console);
2031 emacs_Xt_unselect_console (struct console *con)
2033 Lisp_Object console;
2039 if (CONSOLE_X_P (con))
2040 return; /* X consoles are automatically selected for when we
2041 initialize them in Xt */
2042 infd = event_stream_unixoid_unselect_console (con);
2043 XSETCONSOLE (console, con);
2044 unselect_filedesc (infd);
2046 /* On a stream device (ie: noninteractive), bad things can happen. */
2047 if (EQ (CONSOLE_TYPE (con), Qtty)) {
2048 mousefd = CONSOLE_TTY_MOUSE_FD (con);
2050 unselect_filedesc (mousefd);
2056 /* read an event from a tty, if one is available. Returns non-zero
2057 if an event was available. Note that when this function is
2058 called, there should always be a tty marked as ready for input.
2059 However, the input condition might actually be EOF, so there
2060 may not really be any input available. (In this case,
2061 read_event_from_tty_or_stream_desc() will arrange for the TTY device
2065 Xt_tty_to_emacs_event (struct Lisp_Event *emacs_event)
2069 assert (tty_events_occurred > 0);
2070 for (i = 0; i < MAXDESC; i++)
2072 Lisp_Object console = filedesc_with_input[i];
2073 if (CONSOLEP (console))
2075 assert (tty_events_occurred > 0);
2076 tty_events_occurred--;
2077 filedesc_with_input[i] = Qnil;
2078 if (read_event_from_tty_or_stream_desc
2079 (emacs_event, XCONSOLE (console), i))
2088 /************************************************************************/
2089 /* debugging functions to decipher an event */
2090 /************************************************************************/
2093 #include "xintrinsicp.h" /* only describe_event() needs this */
2094 #include <X11/Xproto.h> /* only describe_event() needs this */
2097 describe_event_window (Window window, Display *display)
2101 stderr_out (" window: 0x%lx", (unsigned long) window);
2102 w = XtWindowToWidget (display, window);
2104 stderr_out (" %s", w->core.widget_class->core_class.class_name);
2105 f = x_any_window_to_frame (get_device_from_display (display), window);
2108 char *buf = alloca_array (char, XSTRING_LENGTH (f->name) + 4);
2109 sprintf (buf, " \"%s\"", XSTRING_DATA (f->name));
2110 write_string_to_stdio_stream (stderr, 0, (Bufbyte *) buf, 0,
2111 strlen (buf), FORMAT_TERMINAL);
2117 XEvent_mode_to_string (int mode)
2121 case NotifyNormal: return "Normal";
2122 case NotifyGrab: return "Grab";
2123 case NotifyUngrab: return "Ungrab";
2124 case NotifyWhileGrabbed: return "WhileGrabbed";
2125 default: return "???";
2130 XEvent_detail_to_string (int detail)
2134 case NotifyAncestor: return "Ancestor";
2135 case NotifyInferior: return "Inferior";
2136 case NotifyNonlinear: return "Nonlinear";
2137 case NotifyNonlinearVirtual: return "NonlinearVirtual";
2138 case NotifyPointer: return "Pointer";
2139 case NotifyPointerRoot: return "PointerRoot";
2140 case NotifyDetailNone: return "DetailNone";
2141 default: return "???";
2146 XEvent_visibility_to_string (int state)
2150 case VisibilityFullyObscured: return "FullyObscured";
2151 case VisibilityPartiallyObscured: return "PartiallyObscured";
2152 case VisibilityUnobscured: return "Unobscured";
2153 default: return "???";
2158 describe_event (XEvent *event)
2161 struct device *d = get_device_from_display (event->xany.display);
2163 sprintf (buf, "%s%s", x_event_name (event->type),
2164 event->xany.send_event ? " (send)" : "");
2165 stderr_out ("%-30s", buf);
2166 switch (event->type)
2171 XFocusChangeEvent *ev = &event->xfocus;
2172 describe_event_window (ev->window, ev->display);
2173 stderr_out (" mode: %s\n", XEvent_mode_to_string (ev->mode));
2174 stderr_out (" detail: %s\n", XEvent_detail_to_string(ev->detail));
2180 XKeyEvent *ev = &event->xkey;
2181 unsigned int state = ev->state;
2183 describe_event_window (ev->window, ev->display);
2184 stderr_out (" subwindow: %ld\n", ev->subwindow);
2185 stderr_out (" state: ");
2186 /* Complete list of modifier key masks */
2187 if (state & ShiftMask) stderr_out ("Shift ");
2188 if (state & LockMask) stderr_out ("Lock ");
2189 if (state & ControlMask) stderr_out ("Control ");
2190 if (state & Mod1Mask) stderr_out ("Mod1 ");
2191 if (state & Mod2Mask) stderr_out ("Mod2 ");
2192 if (state & Mod3Mask) stderr_out ("Mod3 ");
2193 if (state & Mod4Mask) stderr_out ("Mod4 ");
2194 if (state & Mod5Mask) stderr_out ("Mod5 ");
2197 stderr_out ("vanilla\n");
2200 if (x_key_is_modifier_p (ev->keycode, d))
2201 stderr_out (" Modifier key");
2202 stderr_out (" keycode: 0x%x\n", ev->keycode);
2207 if (x_debug_events > 1)
2209 XExposeEvent *ev = &event->xexpose;
2210 describe_event_window (ev->window, ev->display);
2211 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2212 ev->x, ev->y, ev->width, ev->height);
2213 stderr_out (" count: %d\n", ev->count);
2219 case GraphicsExpose:
2220 if (x_debug_events > 1)
2222 XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
2223 describe_event_window (ev->drawable, ev->display);
2224 stderr_out (" major: %s\n",
2225 (ev ->major_code == X_CopyArea ? "CopyArea" :
2226 (ev->major_code == X_CopyPlane ? "CopyPlane" : "?")));
2227 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2228 ev->x, ev->y, ev->width, ev->height);
2229 stderr_out (" count: %d\n", ev->count);
2237 if (x_debug_events > 1)
2239 XCrossingEvent *ev = &event->xcrossing;
2240 describe_event_window (ev->window, ev->display);
2242 stderr_out(" subwindow: 0x%x\n", ev->subwindow);
2243 stderr_out(" pos: %d %d\n", ev->x, ev->y);
2244 stderr_out(" root pos: %d %d\n", ev->x_root, ev->y_root);
2246 stderr_out(" mode: %s\n", XEvent_mode_to_string(ev->mode));
2247 stderr_out(" detail: %s\n", XEvent_detail_to_string(ev->detail));
2248 stderr_out(" focus: %d\n", ev->focus);
2250 stderr_out(" state: 0x%x\n", ev->state);
2257 case ConfigureNotify:
2258 if (x_debug_events > 1)
2260 XConfigureEvent *ev = &event->xconfigure;
2261 describe_event_window (ev->window, ev->display);
2262 stderr_out(" above: 0x%lx\n", ev->above);
2263 stderr_out(" size: %d %d %d %d\n", ev->x, ev->y,
2264 ev->width, ev->height);
2265 stderr_out(" redirect: %d\n", ev->override_redirect);
2271 case VisibilityNotify:
2272 if (x_debug_events > 1)
2274 XVisibilityEvent *ev = &event->xvisibility;
2275 describe_event_window (ev->window, ev->display);
2276 stderr_out(" state: %s\n", XEvent_visibility_to_string(ev->state));
2284 XClientMessageEvent *ev = &event->xclient;
2285 char *name = XGetAtomName (ev->display, ev->message_type);
2286 stderr_out ("%s", name);
2287 if (!strcmp (name, "WM_PROTOCOLS")) {
2288 char *protname = XGetAtomName (ev->display, ev->data.l[0]);
2289 stderr_out ("(%s)", protname);
2305 #endif /* include describe_event definition */
2308 /************************************************************************/
2309 /* get the next event from Xt */
2310 /************************************************************************/
2312 static Lisp_Object dispatch_event_queue, dispatch_event_queue_tail;
2315 enqueue_Xt_dispatch_event (Lisp_Object event)
2317 enqueue_event (event, &dispatch_event_queue, &dispatch_event_queue_tail);
2321 dequeue_Xt_dispatch_event (void)
2323 return dequeue_event (&dispatch_event_queue, &dispatch_event_queue_tail);
2326 /* This business exists because menu events "happen" when
2327 menubar_selection_callback() is called from somewhere deep
2328 within XtAppProcessEvent in emacs_Xt_next_event(). The
2329 callback needs to terminate the modal loop in that function
2330 or else it will continue waiting until another event is
2333 Same business applies to scrollbar events. */
2336 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
2339 Lisp_Object event = Fmake_event (Qnil, Qnil);
2341 XEVENT (event)->event_type = misc_user_event;
2342 XEVENT (event)->channel = channel;
2343 XEVENT (event)->event.eval.function = function;
2344 XEVENT (event)->event.eval.object = object;
2346 enqueue_Xt_dispatch_event (event);
2350 emacs_Xt_next_event (struct Lisp_Event *emacs_event)
2352 we_didnt_get_an_event:
2354 while (NILP (dispatch_event_queue) &&
2355 !completed_timeouts &&
2356 !fake_event_occurred &&
2357 !process_events_occurred &&
2358 !tty_events_occurred)
2361 /* Stupid logic in XtAppProcessEvent() dictates that, if process
2362 events and X events are both available, the process event gets
2363 taken first. This will cause an infinite loop if we're being
2364 called from Fdiscard_input().
2366 if (XtAppPending (Xt_app_con) & XtIMXEvent)
2367 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2370 Lisp_Object devcons, concons;
2372 /* We're about to block. Xt has a bug in it (big surprise,
2373 there) in that it blocks using select() and doesn't
2374 flush the Xlib output buffers (XNextEvent() does this
2375 automatically before blocking). So it's necessary
2376 for us to do this ourselves. If we don't do it, then
2377 display output may not be seen until the next time
2378 an X event is received. (This happens esp. with
2379 subprocess output that gets sent to a visible buffer.)
2381 #### The above comment may not have any validity. */
2383 DEVICE_LOOP_NO_BREAK (devcons, concons)
2386 d = XDEVICE (XCAR (devcons));
2388 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2389 /* emacs may be exiting */
2390 XFlush (DEVICE_X_DISPLAY (d));
2392 XtAppProcessEvent (Xt_app_con, XtIMAll);
2396 if (!NILP (dispatch_event_queue))
2398 Lisp_Object event, event2;
2399 XSETEVENT (event2, emacs_event);
2400 event = dequeue_Xt_dispatch_event ();
2401 Fcopy_event (event, event2);
2402 Fdeallocate_event (event);
2404 else if (tty_events_occurred)
2406 if (!Xt_tty_to_emacs_event (emacs_event))
2407 goto we_didnt_get_an_event;
2409 else if (completed_timeouts)
2410 Xt_timeout_to_emacs_event (emacs_event);
2411 else if (fake_event_occurred)
2413 /* A dummy event, so that a cycle of the command loop will occur. */
2414 fake_event_occurred = 0;
2415 /* eval events have nil as channel */
2416 emacs_event->event_type = eval_event;
2417 emacs_event->event.eval.function = Qidentity;
2418 emacs_event->event.eval.object = Qnil;
2420 else /* if (process_events_occurred) */
2421 Xt_process_to_emacs_event (emacs_event);
2423 /* No need to call XFilterEvent; Xt does it for us */
2427 emacs_Xt_event_handler (Widget wid /* unused */,
2428 XtPointer closure /* unused */,
2430 Boolean *continue_to_dispatch /* unused */)
2432 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
2435 if (x_debug_events > 0)
2437 describe_event (event);
2439 #endif /* DEBUG_XEMACS */
2440 if (x_event_to_emacs_event (event, XEVENT (emacs_event)))
2441 enqueue_Xt_dispatch_event (emacs_event);
2443 Fdeallocate_event (emacs_event);
2447 /************************************************************************/
2448 /* input pending / C-g checking */
2449 /************************************************************************/
2452 quit_char_predicate (Display *display, XEvent *event, XPointer data)
2454 struct device *d = get_device_from_display (display);
2455 struct x_device *xd = DEVICE_X_DATA (d);
2457 Bool *critical = (Bool *) data;
2462 if ((event->type != KeyPress) ||
2463 (! x_any_window_to_frame (d, event->xany.window)) ||
2465 & (xd->MetaMask | xd->HyperMask | xd->SuperMask | xd->AltMask)))
2468 /* This duplicates some code that exists elsewhere, but it's relatively
2469 fast and doesn't cons. */
2470 keysym = x_to_emacs_keysym (&event->xkey, 1);
2471 if (NILP (keysym)) return 0;
2472 if (CHAR_OR_CHAR_INTP (keysym))
2473 c = XCHAR_OR_CHAR_INT (keysym);
2474 /* Highly doubtful that these are the quit character, but... */
2475 else if (EQ (keysym, QKbackspace)) c = '\b';
2476 else if (EQ (keysym, QKtab)) c = '\t';
2477 else if (EQ (keysym, QKlinefeed)) c = '\n';
2478 else if (EQ (keysym, QKreturn)) c = '\r';
2479 else if (EQ (keysym, QKescape)) c = 27;
2480 else if (EQ (keysym, QKspace)) c = ' ';
2481 else if (EQ (keysym, QKdelete)) c = 127;
2484 if (event->xkey.state & xd->MetaMask) c |= 0x80;
2485 if ((event->xkey.state & ControlMask) && !(c >= 'A' && c <= 'Z'))
2486 c &= 0x1F; /* unshifted control characters */
2487 quit_char = CONSOLE_QUIT_CHAR (XCONSOLE (DEVICE_CONSOLE (d)));
2490 /* If we've got Control-Shift-G instead of Control-G, that means
2491 we have a critical_quit. Caps_Lock is its own modifier, so it
2492 won't cause ^G to act differently than before. */
2493 if (event->xkey.state & ControlMask) c &= 0x1F;
2496 if (critical) *critical = True;
2502 /* This scans the X input queue for a KeyPress event that matches the
2503 quit character, and sets Vquit_flag. This is called from the
2504 QUIT macro to determine whether we should quit.
2506 In a SIGIO world, this won't be called unless a SIGIO has happened
2507 since the last time we checked.
2509 In a non-SIGIO world, this is called from emacs_Xt_event_pending_p
2510 (which is called from input_pending_p).
2513 x_check_for_quit_char (Display *display)
2517 Bool critical_quit = False;
2518 XEventsQueued (display, QueuedAfterReading);
2519 queued = XCheckIfEvent (display, &event,
2520 quit_char_predicate,
2521 (char *) &critical_quit);
2524 Vquit_flag = (critical_quit ? Qcritical : Qt);
2525 /* don't put the event back onto the queue. Those functions that
2526 wanted to read a ^G directly have arranged to do this. */
2531 check_for_tty_quit_char (struct device *d)
2533 SELECT_TYPE temp_mask;
2534 int infd = DEVICE_INFD (d);
2535 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
2536 Emchar quit_char = CONSOLE_QUIT_CHAR (con);
2538 FD_ZERO (&temp_mask);
2539 FD_SET (infd, &temp_mask);
2546 if (!poll_fds_for_input (temp_mask))
2549 event = Fmake_event (Qnil, Qnil);
2550 if (!read_event_from_tty_or_stream_desc (XEVENT (event), con, infd))
2551 /* EOF, or something ... */
2553 /* #### bogus. quit-char should be allowed to be any sort
2555 the_char = event_to_character (XEVENT (event), 1, 0, 0);
2556 if (the_char >= 0 && the_char == quit_char)
2559 /* do not queue the C-g. See above. */
2563 /* queue the read event to be read for real later. */
2564 enqueue_Xt_dispatch_event (event);
2569 emacs_Xt_quit_p (void)
2571 Lisp_Object devcons, concons;
2572 CONSOLE_LOOP (concons)
2574 struct console *con = XCONSOLE (XCAR (concons));
2575 if (!con->input_enabled)
2578 CONSOLE_DEVICE_LOOP (devcons, con)
2581 d = XDEVICE (XCAR (devcons));
2583 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2584 /* emacs may be exiting */
2585 x_check_for_quit_char (DEVICE_X_DISPLAY (d));
2586 else if (DEVICE_TTY_P (d))
2587 check_for_tty_quit_char (d);
2593 drain_X_queue (void)
2595 while (XtAppPending (Xt_app_con) & XtIMXEvent)
2596 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2600 emacs_Xt_event_pending_p (int user_p)
2605 /* If `user_p' is false, then this function returns whether there are any
2606 X, timeout, or fd events pending (that is, whether emacs_Xt_next_event()
2607 would return immediately without blocking).
2609 if `user_p' is true, then this function returns whether there are any
2610 *user generated* events available (that is, whether there are keyboard
2611 or mouse-click events ready to be read). This also implies that
2612 emacs_Xt_next_event() would not block.
2614 In a non-SIGIO world, this also checks whether the user has typed ^G,
2615 since this is a convenient place to do so. We don't need to do this
2616 in a SIGIO world, since input causes an interrupt.
2620 /* I don't think there's any point to this and it will nullify
2621 the speed gains achieved by the sigio_happened checking below.
2622 Its only advantage is that it may possibly make C-g response
2623 a bit faster. The C-g will be noticed within 0.25 second, anyway,
2624 even without this. */
2626 /* First check for C-g if necessary */
2631 /* This function used to simply check whether there were any X
2632 events (or if user_p was 1, it iterated over all the pending
2633 X events using XCheckIfEvent(), looking for keystrokes and
2634 button events). That worked in the old cheesoid event loop,
2635 which didn't go through XtAppDispatchEvent(), but it doesn't
2636 work any more -- X events may not result in anything. For
2637 example, a button press in a blank part of the menubar appears
2638 as an X event but will not result in any Emacs events (a
2639 button press that activates the menubar results in an Emacs
2640 event through the stop_next_event mechanism).
2642 The only accurate way of determining whether these X events
2643 translate into Emacs events is to go ahead and dispatch them
2644 until there's something on the dispatch queue. */
2646 /* See if there are any user events already on the queue. */
2647 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2648 if (!user_p || command_event_p (event))
2651 /* See if there's any TTY input available.
2653 if (poll_fds_for_input (tty_only_mask))
2658 /* If not user_p and there are any timer or file-desc events
2659 pending, we know there will be an event so we're through. */
2660 XtInputMask pending_value;
2662 /* Note that formerly we just checked the value of XtAppPending()
2663 to determine if there was file-desc input. This doesn't
2664 work any more with the signal_event_pipe; XtAppPending()
2665 will says "yes" in this case but there isn't really any
2666 input. Another way of fixing this problem is for the
2667 signal_event_pipe to generate actual input in the form
2668 of an identity eval event or something. (#### maybe this
2669 actually happens?) */
2671 if (poll_fds_for_input (process_only_mask))
2674 pending_value = XtAppPending (Xt_app_con);
2676 if (pending_value & XtIMTimer)
2680 /* XtAppPending() can be super-slow, esp. over a network connection.
2681 Quantify results have indicated that in some cases the
2682 call to detect_input_pending() completely dominates the
2683 running time of redisplay(). Fortunately, in a SIGIO world
2684 we can more quickly determine whether there are any X events:
2685 if an event has happened since the last time we checked, then
2686 a SIGIO will have happened. On a machine with broken SIGIO,
2687 we'll still be in an OK state -- the sigio_happened flag
2688 will get set at least once a second, so we'll be no more than
2689 one second behind reality. (In general it's OK if we
2690 erroneously report no input pending when input is actually
2691 pending() -- preemption is just a bit less efficient, that's
2692 all. It's bad bad bad if you err the other way -- you've
2693 promised that `next-event' won't block but it actually will,
2694 and some action might get delayed until the next time you
2698 /* quit_check_signal_tick_count is volatile so try to avoid race conditions
2699 by using a temporary variable */
2700 tick_count_val = quit_check_signal_tick_count;
2701 if (last_quit_check_signal_tick_count != tick_count_val)
2703 last_quit_check_signal_tick_count = tick_count_val;
2705 /* We need to drain the entire queue now -- if we only
2706 drain part of it, we may later on end up with events
2707 actually pending but detect_input_pending() returning
2708 false because there wasn't another SIGIO. */
2711 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2712 if (!user_p || command_event_p (event))
2720 /************************************************************************/
2721 /* replacement for standard string-to-pixel converter */
2722 /************************************************************************/
2724 /* This was constructed by ripping off the standard string-to-pixel
2725 converter from Converters.c in the Xt source code and modifying
2730 /* This is exported by the Xt library (at least by mine). If this
2731 isn't the case somewhere, rename this appropriately and remove
2732 the '#if 0'. Note, however, that I got "unknown structure"
2733 errors when I tried this. */
2734 XtConvertArgRec Const colorConvertArgs[] = {
2735 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
2737 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
2743 #define done(type, value) \
2744 if (toVal->addr != NULL) { \
2745 if (toVal->size < sizeof(type)) { \
2746 toVal->size = sizeof(type); \
2749 *(type*)(toVal->addr) = (value); \
2751 static type static_val; \
2752 static_val = (value); \
2753 toVal->addr = (XPointer)&static_val; \
2755 toVal->size = sizeof(type); \
2756 return True /* Caller supplies `;' */
2758 /* JH: We use this because I think there's a possibility this
2759 is called before the device is properly set up, in which case
2760 I don't want to abort. */
2761 extern struct device *get_device_from_display_1 (Display *dpy);
2764 Boolean EmacsXtCvtStringToPixel (
2768 XrmValuePtr fromVal,
2770 XtPointer *closure_ret)
2772 String str = (String)fromVal->addr;
2781 Cardinal num_params = 1;
2782 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
2784 if (*num_args != 2) {
2785 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
2787 "String to pixel conversion needs screen and colormap arguments",
2788 (String *)NULL, (Cardinal *)NULL);
2792 screen = *((Screen **) args[0].addr);
2793 colormap = *((Colormap *) args[1].addr);
2795 /* The original uses the private function CompareISOLatin1().
2796 Use XmuCompareISOLatin1() if you want, but I don't think it
2797 makes any difference here. */
2798 if (strcmp(str, XtDefaultBackground) == 0) {
2799 *closure_ret = False;
2800 /* This refers to the display's "*reverseVideo" resource.
2801 These display resources aren't documented anywhere that
2802 I can find, so I'm going to ignore this. */
2803 /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */
2804 done(Pixel, WhitePixelOfScreen(screen));
2806 if (strcmp(str, XtDefaultForeground) == 0) {
2807 *closure_ret = False;
2808 /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */
2809 done(Pixel, BlackPixelOfScreen(screen));
2812 /* Originally called XAllocNamedColor() here. */
2813 if ((d = get_device_from_display_1(dpy))) {
2814 visual = DEVICE_X_VISUAL(d);
2815 if (colormap != DEVICE_X_COLORMAP(d)) {
2816 XtAppWarningMsg(the_app_con, "wierdColormap", "cvtStringToPixel",
2818 "The colormap passed to cvtStringToPixel doesn't match the one registerd to the device.\n",
2820 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2822 status = XParseColor (dpy, colormap, (char*)str, &screenColor);
2824 status = allocate_nearest_color (dpy, colormap, visual, &screenColor);
2828 /* We haven't set up this device totally yet, so just punt */
2829 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2833 /* Server returns a specific error code but Xlib discards it. Ugh */
2834 if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
2835 &exactColor, &screenColor)) {
2836 XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
2838 "Cannot allocate colormap entry for \"%s\"",
2839 params, &num_params);
2842 XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
2844 "Color name \"%s\" is not defined", params, &num_params);
2847 *closure_ret = False;
2850 *closure_ret = (char*)True;
2851 done(Pixel, screenColor.pixel);
2856 static void EmacsFreePixel (
2863 if (*num_args != 2) {
2864 XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError",
2865 "Freeing a pixel requires screen and colormap arguments",
2866 (String *)NULL, (Cardinal *)NULL);
2871 Screen *screen = *((Screen **) args[0].addr);
2872 Colormap colormap = *((Colormap *) args[1].addr);
2873 XFreeColors(DisplayOfScreen(screen), colormap,
2874 (unsigned long*)toVal->addr, 1, (unsigned long)0);
2879 /************************************************************************/
2880 /* initialization */
2881 /************************************************************************/
2884 syms_of_event_Xt (void)
2886 defsymbol (&Qkey_mapping, "key-mapping");
2887 defsymbol (&Qsans_modifiers, "sans-modifiers");
2891 vars_of_event_Xt (void)
2893 dispatch_event_queue = Qnil;
2894 staticpro (&dispatch_event_queue);
2895 dispatch_event_queue_tail = Qnil;
2897 /* this function only makes safe calls */
2898 init_what_input_once ();
2900 Xt_event_stream = xnew (struct event_stream);
2901 Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p;
2902 Xt_event_stream->next_event_cb = emacs_Xt_next_event;
2903 Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
2904 Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout;
2905 Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout;
2906 Xt_event_stream->select_console_cb = emacs_Xt_select_console;
2907 Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console;
2908 Xt_event_stream->select_process_cb = emacs_Xt_select_process;
2909 Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process;
2910 Xt_event_stream->quit_p_cb = emacs_Xt_quit_p;
2911 Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
2912 Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
2914 DEFVAR_BOOL ("modifier-keys-are-sticky", &modifier_keys_are_sticky /*
2915 *Non-nil makes modifier keys sticky.
2916 This means that you can release the modifier key before pressing down
2917 the key that you wish to be modified. Although this is non-standard
2918 behavior, it is recommended because it reduces the strain on your hand,
2919 thus reducing the incidence of the dreaded Emacs-pinky syndrome.
2921 modifier_keys_are_sticky = 0;
2923 DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /*
2924 *Non-nil means to allow synthetic events. Nil means they are ignored.
2925 Beware: allowing emacs to process SendEvents opens a big security hole.
2927 x_allow_sendevents = 0;
2930 DEFVAR_INT ("x-debug-events", &x_debug_events /*
2931 If non-zero, display debug information about X events that XEmacs sees.
2932 Information is displayed on stderr. Currently defined values are:
2934 1 == non-verbose output
2940 the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
2942 last_quit_check_signal_tick_count = 0;
2945 /* This mess is a hack that patches the shell widget to treat visual inheritance
2946 the same as colormap and depth inheritance */
2948 static XtInitProc orig_shell_init_proc;
2950 static void ShellVisualPatch(Widget wanted, Widget new,
2951 ArgList args, Cardinal *num_args)
2954 ShellWidget w = (ShellWidget) new;
2956 /* first, call the original setup */
2957 (*orig_shell_init_proc)(wanted, new, args, num_args);
2959 /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */
2960 if (w->shell.visual == CopyFromParent) {
2962 while (p && !XtIsShell(p)) p = XtParent(p);
2963 if (p) w->shell.visual = ((ShellWidget)p)->shell.visual;
2968 init_event_Xt_late (void) /* called when already initialized */
2970 timeout_id_tick = 1;
2971 pending_timeouts = 0;
2972 completed_timeouts = 0;
2974 event_stream = Xt_event_stream;
2976 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
2977 Initialize_Locale();
2978 #endif /* HAVE_XIM || USE_XFONTSET */
2980 XtToolkitInitialize ();
2981 Xt_app_con = XtCreateApplicationContext ();
2982 XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
2985 x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
2986 XSetErrorHandler (x_error_handler);
2987 XSetIOErrorHandler (x_IO_error_handler);
2990 XtAppAddInput (Xt_app_con, signal_event_pipe[0],
2991 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
2992 Xt_what_callback, 0);
2995 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel,
2996 EmacsXtCvtStringToPixel,
2997 (XtConvertArgList) colorConvertArgs,
2998 2, XtCacheByDisplay, EmacsFreePixel);
3001 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
3002 EmacsXtCvtStringToXIMStyles,
3004 XtCacheByDisplay, EmacsFreeXIMStyles);
3005 #endif /* XIM_XLIB */
3007 /* insert the visual inheritance patch/hack described above */
3008 orig_shell_init_proc = shellClassRec.core_class.initialize;
3009 shellClassRec.core_class.initialize = ShellVisualPatch;