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);
81 static void handle_focus_event_1 (struct frame *f, int in_p);
83 static struct event_stream *Xt_event_stream;
85 /* With the new event model, all events go through XtDispatchEvent()
86 and are picked up by an event handler that is added to each frame
87 widget. (This is how it's supposed to be.) In the old method,
88 Emacs sucks out events directly from XtNextEvent() and only
89 dispatches the events that it doesn't need to deal with. This
90 old way has lots of corresponding junk that is no longer
91 necessary: lwlib extensions, synthetic XAnyEvents, unnecessary
94 /* The one and only one application context that Emacs uses. */
95 XtAppContext Xt_app_con;
97 /* Do we accept events sent by other clients? */
98 int x_allow_sendevents;
100 int modifier_keys_are_sticky;
106 static int process_events_occurred;
107 static int tty_events_occurred;
109 /* Mask of bits indicating the descriptors that we wait for input on */
110 extern SELECT_TYPE input_wait_mask, process_only_mask, tty_only_mask;
112 static CONST String x_fallback_resources[] =
114 /* This file is automatically generated from the app-defaults file
115 in ../etc/Emacs.ad. These resources are consulted only if no
116 app-defaults file is found at all.
118 #include <Emacs.ad.h>
122 static Lisp_Object x_keysym_to_emacs_keysym (KeySym keysym, int simple_p);
123 void emacs_Xt_mapping_action (Widget w, XEvent *event);
124 void debug_process_finalization (struct Lisp_Process *p);
125 void emacs_Xt_event_handler (Widget wid, XtPointer closure, XEvent *event,
126 Boolean *continue_to_dispatch);
128 static int last_quit_check_signal_tick_count;
130 Lisp_Object Qkey_mapping;
131 Lisp_Object Qsans_modifiers;
134 /************************************************************************/
135 /* keymap handling */
136 /************************************************************************/
138 /* X bogusly doesn't define the interpretations of any bits besides
139 ModControl, ModShift, and ModLock; so the Interclient Communication
140 Conventions Manual says that we have to bend over backwards to figure
141 out what the other modifier bits mean. According to ICCCM:
143 - Any keycode which is assigned ModControl is a "control" key.
145 - Any modifier bit which is assigned to a keycode which generates Meta_L
146 or Meta_R is the modifier bit meaning "meta". Likewise for Super, Hyper,
149 - Any keypress event which contains ModControl in its state should be
150 interpreted as a "control" character.
152 - Any keypress event which contains a modifier bit in its state which is
153 generated by a keycode whose corresponding keysym is Meta_L or Meta_R
154 should be interpreted as a "meta" character. Likewise for Super, Hyper,
157 - It is illegal for a keysym to be associated with more than one modifier
160 This means that the only thing that emacs can reasonably interpret as a
161 "meta" key is a key whose keysym is Meta_L or Meta_R, and which generates
162 one of the modifier bits Mod1-Mod5.
164 Unfortunately, many keyboards don't have Meta keys in their default
165 configuration. So, if there are no Meta keys, but there are "Alt" keys,
166 emacs will interpret Alt as Meta. If there are both Meta and Alt keys,
167 then the Meta keys mean "Meta", and the Alt keys mean "Alt" (it used to
168 mean "Symbol," but that just confused the hell out of way too many people).
170 This works with the default configurations of the 19 keyboard-types I've
173 Emacs detects keyboard configurations which violate the above rules, and
174 prints an error message on the standard-error-output. (Perhaps it should
175 use a pop-up-window instead.)
179 x_reset_key_mapping (struct device *d)
181 Display *display = DEVICE_X_DISPLAY (d);
182 struct x_device *xd = DEVICE_X_DATA (d);
183 KeySym *keysym, *keysym_end;
184 Lisp_Object hash_table;
185 int key_code_count, keysyms_per_code;
187 if (xd->x_keysym_map)
188 XFree ((char *) xd->x_keysym_map);
189 XDisplayKeycodes (display,
190 &xd->x_keysym_map_min_code,
191 &xd->x_keysym_map_max_code);
192 key_code_count = xd->x_keysym_map_max_code - xd->x_keysym_map_min_code + 1;
194 XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count,
195 &xd->x_keysym_map_keysyms_per_code);
197 hash_table = xd->x_keysym_map_hash_table;
198 if (HASH_TABLEP (hash_table))
199 Fclrhash (hash_table);
201 xd->x_keysym_map_hash_table = hash_table =
202 make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
204 for (keysym = xd->x_keysym_map,
205 keysyms_per_code = xd->x_keysym_map_keysyms_per_code,
206 keysym_end = keysym + (key_code_count * keysyms_per_code);
208 keysym += keysyms_per_code)
212 if (keysym[0] == NoSymbol)
216 char *name = XKeysymToString (keysym[0]);
217 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[0], 0);
220 Fputhash (build_string (name), Qsans_modifiers, hash_table);
221 Fputhash (sym, Qsans_modifiers, hash_table);
225 for (j = 1; j < keysyms_per_code; j++)
227 if (keysym[j] != keysym[0] &&
228 keysym[j] != NoSymbol)
230 char *name = XKeysymToString (keysym[j]);
231 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[j], 0);
232 if (name && NILP (Fgethash (sym, hash_table, Qnil)))
234 Fputhash (build_string (name), Qt, hash_table);
235 Fputhash (sym, Qt, hash_table);
243 index_to_name (int indice)
247 case ShiftMapIndex: return "ModShift";
248 case LockMapIndex: return "ModLock";
249 case ControlMapIndex: return "ModControl";
250 case Mod1MapIndex: return "Mod1";
251 case Mod2MapIndex: return "Mod2";
252 case Mod3MapIndex: return "Mod3";
253 case Mod4MapIndex: return "Mod4";
254 case Mod5MapIndex: return "Mod5";
255 default: return "???";
259 /* Boy, I really wish C had local functions... */
260 struct c_doesnt_have_closures /* #### not yet used */
262 int warned_about_overlapping_modifiers;
263 int warned_about_predefined_modifiers;
264 int warned_about_duplicate_modifiers;
273 x_reset_modifier_mapping (struct device *d)
275 Display *display = DEVICE_X_DISPLAY (d);
276 struct x_device *xd = DEVICE_X_DATA (d);
277 int modifier_index, modifier_key, column, mkpm;
278 int warned_about_overlapping_modifiers = 0;
279 int warned_about_predefined_modifiers = 0;
280 int warned_about_duplicate_modifiers = 0;
287 xd->lock_interpretation = 0;
289 if (xd->x_modifier_keymap)
290 XFreeModifiermap (xd->x_modifier_keymap);
292 x_reset_key_mapping (d);
294 xd->x_modifier_keymap = XGetModifierMapping (display);
296 /* Boy, I really wish C had local functions...
299 /* The call to warn_when_safe must be on the same line as the string or
300 make-msgfile won't pick it up properly (the newline doesn't confuse
301 it, but the backslash does). */
303 #define modwarn(name,old,other) \
304 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is generated by %s.", \
305 name, code, index_to_name (old), other), \
306 warned_about_overlapping_modifiers = 1
308 #define modbarf(name,other) \
309 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
310 name, code, other), \
311 warned_about_predefined_modifiers = 1
313 #define check_modifier(name,mask) \
314 if ((1<<modifier_index) != mask) \
315 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
316 name, code, index_to_name (modifier_index)), \
317 warned_about_predefined_modifiers = 1
319 #define store_modifier(name,old) \
320 if (old && old != modifier_index) \
321 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates both %s and %s, which is nonsensical.",\
322 name, code, index_to_name (old), \
323 index_to_name (modifier_index)), \
324 warned_about_duplicate_modifiers = 1; \
325 if (modifier_index == ShiftMapIndex) modbarf (name,"ModShift"); \
326 else if (modifier_index == LockMapIndex) modbarf (name,"ModLock"); \
327 else if (modifier_index == ControlMapIndex) modbarf (name,"ModControl"); \
328 else if (sym == XK_Mode_switch) \
329 mode_bit = modifier_index; /* Mode_switch is special, see below... */ \
330 else if (modifier_index == meta_bit && old != meta_bit) \
331 modwarn (name, meta_bit, "Meta"); \
332 else if (modifier_index == super_bit && old != super_bit) \
333 modwarn (name, super_bit, "Super"); \
334 else if (modifier_index == hyper_bit && old != hyper_bit) \
335 modwarn (name, hyper_bit, "Hyper"); \
336 else if (modifier_index == alt_bit && old != alt_bit) \
337 modwarn (name, alt_bit, "Alt"); \
339 old = modifier_index;
341 mkpm = xd->x_modifier_keymap->max_keypermod;
342 for (modifier_index = 0; modifier_index < 8; modifier_index++)
343 for (modifier_key = 0; modifier_key < mkpm; modifier_key++) {
345 for (column = 0; column < 4; column += 2) {
346 KeyCode code = xd->x_modifier_keymap->modifiermap[modifier_index * mkpm
348 KeySym sym = (code ? XKeycodeToKeysym (display, code, column) : 0);
349 if (sym == last_sym) continue;
352 case XK_Mode_switch:store_modifier ("Mode_switch", mode_bit); break;
353 case XK_Meta_L: store_modifier ("Meta_L", meta_bit); break;
354 case XK_Meta_R: store_modifier ("Meta_R", meta_bit); break;
355 case XK_Super_L: store_modifier ("Super_L", super_bit); break;
356 case XK_Super_R: store_modifier ("Super_R", super_bit); break;
357 case XK_Hyper_L: store_modifier ("Hyper_L", hyper_bit); break;
358 case XK_Hyper_R: store_modifier ("Hyper_R", hyper_bit); break;
359 case XK_Alt_L: store_modifier ("Alt_L", alt_bit); break;
360 case XK_Alt_R: store_modifier ("Alt_R", alt_bit); break;
361 case XK_Control_L: check_modifier ("Control_L", ControlMask); break;
362 case XK_Control_R: check_modifier ("Control_R", ControlMask); break;
363 case XK_Shift_L: check_modifier ("Shift_L", ShiftMask); break;
364 case XK_Shift_R: check_modifier ("Shift_R", ShiftMask); break;
365 case XK_Shift_Lock: check_modifier ("Shift_Lock", LockMask);
366 xd->lock_interpretation = XK_Shift_Lock; break;
367 case XK_Caps_Lock: check_modifier ("Caps_Lock", LockMask);
368 xd->lock_interpretation = XK_Caps_Lock; break;
370 /* It probably doesn't make any sense for a modifier bit to be
371 assigned to a key that is not one of the above, but OpenWindows
372 assigns modifier bits to a couple of random function keys for
373 no reason that I can discern, so printing a warning here would
378 #undef store_modifier
379 #undef check_modifier
383 /* If there was no Meta key, then try using the Alt key instead.
384 If there is both a Meta key and an Alt key, then the Alt key
385 is not disturbed and remains an Alt key. */
386 if (! meta_bit && alt_bit)
387 meta_bit = alt_bit, alt_bit = 0;
389 /* mode_bit overrides everything, since it's processed down inside of
390 XLookupString() instead of by us. If Meta and Mode_switch both
391 generate the same modifier bit (which is an error), then we don't
392 interpret that bit as Meta, because we can't make XLookupString()
393 not interpret it as Mode_switch; and interpreting it as both would
397 CONST char *warn = 0;
398 if (mode_bit == meta_bit) warn = "Meta", meta_bit = 0;
399 else if (mode_bit == hyper_bit) warn = "Hyper", hyper_bit = 0;
400 else if (mode_bit == super_bit) warn = "Super", super_bit = 0;
401 else if (mode_bit == alt_bit) warn = "Alt", alt_bit = 0;
405 (Qkey_mapping, Qwarning,
406 "XEmacs: %s is being used for both Mode_switch and %s.",
407 index_to_name (mode_bit), warn),
408 warned_about_overlapping_modifiers = 1;
413 xd->MetaMask = (meta_bit ? (1 << meta_bit) : 0);
414 xd->HyperMask = (hyper_bit ? (1 << hyper_bit) : 0);
415 xd->SuperMask = (super_bit ? (1 << super_bit) : 0);
416 xd->AltMask = (alt_bit ? (1 << alt_bit) : 0);
417 xd->ModeMask = (mode_bit ? (1 << mode_bit) : 0); /* unused */
420 if (warned_about_overlapping_modifiers)
421 warn_when_safe (Qkey_mapping, Qwarning, "\n"
422 " Two distinct modifier keys (such as Meta and Hyper) cannot generate\n"
423 " the same modifier bit, because Emacs won't be able to tell which\n"
424 " modifier was actually held down when some other key is pressed. It\n"
425 " won't be able to tell Meta-x and Hyper-x apart, for example. Change\n"
426 " one of these keys to use some other modifier bit. If you intend for\n"
427 " these keys to have the same behavior, then change them to have the\n"
428 " same keysym as well as the same modifier bit.");
430 if (warned_about_predefined_modifiers)
431 warn_when_safe (Qkey_mapping, Qwarning, "\n"
432 " The semantics of the modifier bits ModShift, ModLock, and ModControl\n"
433 " are predefined. It does not make sense to assign ModControl to any\n"
434 " keysym other than Control_L or Control_R, or to assign any modifier\n"
435 " bits to the \"control\" keysyms other than ModControl. You can't\n"
436 " turn a \"control\" key into a \"meta\" key (or vice versa) by simply\n"
437 " assigning the key a different modifier bit. You must also make that\n"
438 " key generate an appropriate keysym (Control_L, Meta_L, etc).");
440 /* No need to say anything more for warned_about_duplicate_modifiers. */
442 if (warned_about_overlapping_modifiers || warned_about_predefined_modifiers)
443 warn_when_safe (Qkey_mapping, Qwarning, "\n"
444 " The meanings of the modifier bits Mod1 through Mod5 are determined\n"
445 " by the keysyms used to control those bits. Mod1 does NOT always\n"
446 " mean Meta, although some non-ICCCM-compliant programs assume that.");
450 x_init_modifier_mapping (struct device *d)
452 struct x_device *xd = DEVICE_X_DATA (d);
453 xd->x_keysym_map_hash_table = Qnil;
454 xd->x_keysym_map = NULL;
455 xd->x_modifier_keymap = NULL;
456 x_reset_modifier_mapping (d);
460 x_key_is_modifier_p (KeyCode keycode, struct device *d)
462 struct x_device *xd = DEVICE_X_DATA (d);
466 if (keycode < xd->x_keysym_map_min_code ||
467 keycode > xd->x_keysym_map_max_code)
470 syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
471 xd->x_keysym_map_keysyms_per_code];
472 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
473 if (IsModifierKey (syms [i]) ||
474 syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */
479 /* key-handling code is always ugly. It just ends up working out
482 Here are some pointers:
484 -- DOWN_MASK indicates which modifiers should be treated as "down"
485 when the corresponding upstroke happens. It gets reset for
486 a particular modifier when that modifier goes up, and reset
487 for all modifiers when a non-modifier key is pressed. Example:
489 I press Control-A-Shift and then release Control-A-Shift.
490 I want the Shift key to be sticky but not the Control key.
492 -- LAST_DOWNKEY and RELEASE_TIME are used to keep track of
493 auto-repeat -- see below.
495 -- If a modifier key is sticky, I can unstick it by pressing
496 the modifier key again. */
499 x_handle_sticky_modifiers (XEvent *ev, struct device *d)
505 if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */
508 xd = DEVICE_X_DATA (d);
509 keycode = ev->xkey.keycode;
512 if (keycode < xd->x_keysym_map_min_code ||
513 keycode > xd->x_keysym_map_max_code)
516 if (! ((type == KeyPress || type == KeyRelease) &&
517 x_key_is_modifier_p (keycode, d)))
518 { /* Not a modifier key */
519 Bool key_event_p = (type == KeyPress || type == KeyRelease);
521 if (type == KeyPress && !xd->last_downkey)
522 xd->last_downkey = keycode;
523 else if (type == ButtonPress ||
524 (type == KeyPress && xd->last_downkey &&
525 (keycode != xd->last_downkey ||
526 ev->xkey.time != xd->release_time)))
528 xd->need_to_add_mask = 0;
529 xd->last_downkey = 0;
531 if (type == KeyPress)
532 xd->release_time = 0;
533 if (type == KeyPress || type == ButtonPress)
537 ev->xkey.state |= xd->need_to_add_mask;
539 ev->xbutton.state |= xd->need_to_add_mask;
541 if (type == KeyRelease && keycode == xd->last_downkey)
542 /* If I hold press-and-release the Control key and then press
543 and hold down the right arrow, I want it to auto-repeat
544 Control-Right. On the other hand, if I do the same but
545 manually press the Right arrow a bunch of times, I want
546 to see one Control-Right and then a bunch of Rights.
547 This means that we need to distinguish between an
548 auto-repeated key and a key pressed and released a bunch
551 Naturally, the designers of the X spec didn't see fit
552 to provide an obvious way to distinguish these cases.
553 So we assume that if the release and the next press
554 occur at the same time, the key was actually auto-
555 repeated. Under Open-Windows, at least, this works. */
556 xd->release_time = key_event_p ? ev->xkey.time : ev->xbutton.time;
558 else /* Modifier key pressed */
561 KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
562 xd->x_keysym_map_keysyms_per_code];
564 /* If a non-modifier key was pressed in the middle of a bunch
565 of modifiers, then it unsticks all the modifiers that were
566 previously pressed. We cannot unstick the modifiers until
567 now because we want to check for auto-repeat of the
570 if (xd->last_downkey)
572 xd->last_downkey = 0;
573 xd->need_to_add_mask = 0;
578 if (type == KeyPress) \
580 /* If modifier key is already sticky, \
581 then unstick it. Note that we do \
582 not test down_mask to deal with the \
583 unlikely but possible case that the \
584 modifier key auto-repeats. */ \
585 if (xd->need_to_add_mask & mask) \
587 xd->need_to_add_mask &= ~mask; \
588 xd->down_mask &= ~mask; \
591 xd->down_mask |= mask; \
595 if (xd->down_mask & mask) \
597 xd->down_mask &= ~mask; \
598 xd->need_to_add_mask |= mask; \
603 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
606 case XK_Control_L: case XK_Control_R: FROB (ControlMask); break;
607 case XK_Shift_L: case XK_Shift_R: FROB (ShiftMask); break;
608 case XK_Meta_L: case XK_Meta_R: FROB (xd->MetaMask); break;
609 case XK_Super_L: case XK_Super_R: FROB (xd->SuperMask); break;
610 case XK_Hyper_L: case XK_Hyper_R: FROB (xd->HyperMask); break;
611 case XK_Alt_L: case XK_Alt_R: FROB (xd->AltMask); break;
618 clear_sticky_modifiers (struct device *d)
620 struct x_device *xd = DEVICE_X_DATA (d);
622 xd->need_to_add_mask = 0;
623 xd->last_downkey = 0;
624 xd->release_time = 0;
629 keysym_obeys_caps_lock_p (KeySym sym, struct device *d)
631 struct x_device *xd = DEVICE_X_DATA (d);
632 /* Eeeeevil hack. Don't apply Caps_Lock to things that aren't alphabetic
633 characters, where "alphabetic" means something more than simply A-Z.
634 That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC.
635 But if shift-lock is down, then it does. */
636 if (xd->lock_interpretation == XK_Shift_Lock)
640 ((sym >= XK_A) && (sym <= XK_Z)) ||
641 ((sym >= XK_a) && (sym <= XK_z)) ||
642 ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) ||
643 ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) ||
644 ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) ||
645 ((sym >= XK_oslash) && (sym <= XK_thorn));
648 /* called from EmacsFrame.c (actually from Xt itself) when a
649 MappingNotify event is received. In its infinite wisdom, Xt
650 decided that Xt event handlers never get MappingNotify events.
651 O'Reilly Xt Programming Manual 9.1.2 says:
653 MappingNotify is automatically handled by Xt, so it isn't passed
654 to event handlers and you don't need to worry about it.
656 Of course, we DO worry about it, so we need a special translation. */
658 emacs_Xt_mapping_action (Widget w, XEvent* event)
660 struct device *d = get_device_from_display (event->xany.display);
662 if (DEVICE_X_BEING_DELETED (d))
665 /* nyet. Now this is handled by Xt. */
666 XRefreshKeyboardMapping (&event->xmapping);
668 /* xmodmap generates about a billion MappingKeyboard events, followed
669 by a single MappingModifier event, so it might be worthwhile to
670 take extra MappingKeyboard events out of the queue before requesting
671 the current keymap from the server. */
672 switch (event->xmapping.request)
674 case MappingKeyboard: x_reset_key_mapping (d); break;
675 case MappingModifier: x_reset_modifier_mapping (d); break;
676 case MappingPointer: /* Do something here? */ break;
682 /************************************************************************/
683 /* X to Emacs event conversion */
684 /************************************************************************/
687 x_keysym_to_emacs_keysym (KeySym keysym, int simple_p)
690 if (keysym >= XK_exclam && keysym <= XK_asciitilde)
691 /* We must assume that the X keysym numbers for the ASCII graphic
692 characters are the same as their ASCII codes. */
693 return make_char (keysym);
697 /* These would be handled correctly by the default case, but by
698 special-casing them here we don't garbage a string or call
700 case XK_BackSpace: return QKbackspace;
701 case XK_Tab: return QKtab;
702 case XK_Linefeed: return QKlinefeed;
703 case XK_Return: return QKreturn;
704 case XK_Escape: return QKescape;
705 case XK_space: return QKspace;
706 case XK_Delete: return QKdelete;
709 if (simple_p) return Qnil;
710 /* !!#### not Mule-ized */
711 name = XKeysymToString (keysym);
712 if (!name || !name[0])
713 /* This happens if there is a mismatch between the Xlib of
714 XEmacs and the Xlib of the X server...
716 Let's hard-code in some knowledge of common keysyms introduced
717 in recent X11 releases. Snarfed from X11/keysymdef.h
719 Probably we should add some stuff here for X11R6. */
722 case 0xFF95: return KEYSYM ("kp-home");
723 case 0xFF96: return KEYSYM ("kp-left");
724 case 0xFF97: return KEYSYM ("kp-up");
725 case 0xFF98: return KEYSYM ("kp-right");
726 case 0xFF99: return KEYSYM ("kp-down");
727 case 0xFF9A: return KEYSYM ("kp-prior");
728 case 0xFF9B: return KEYSYM ("kp-next");
729 case 0xFF9C: return KEYSYM ("kp-end");
730 case 0xFF9D: return KEYSYM ("kp-begin");
731 case 0xFF9E: return KEYSYM ("kp-insert");
732 case 0xFF9F: return KEYSYM ("kp-delete");
734 case 0x1005FF10: return KEYSYM ("SunF36"); /* labeled F11 */
735 case 0x1005FF11: return KEYSYM ("SunF37"); /* labeled F12 */
739 sprintf (buf, "unknown-keysym-0x%X", (int) keysym);
743 /* If it's got a one-character name, that's good enough. */
745 return make_char (name[0]);
747 /* If it's in the "Keyboard" character set, downcase it.
748 The case of those keysyms is too totally random for us to
749 force anyone to remember them.
750 The case of the other character sets is significant, however.
752 if ((((unsigned int) keysym) & (~0x1FF)) == ((unsigned int) 0xFE00))
756 for (s1 = name, s2 = buf; *s1; s1++, s2++) {
760 *s2 = tolower (* (unsigned char *) s1);
766 return KEYSYM (name);
771 x_to_emacs_keysym (XKeyPressedEvent *event, int simple_p)
772 /* simple_p means don't try too hard (ASCII only) */
779 char *bufptr = buffer;
780 int bufsiz = sizeof (buffer);
783 XIC xic = FRAME_X_XIC (x_any_window_to_frame
784 (get_device_from_display (event->display),
786 #endif /* XIM_XLIB */
787 #endif /* HAVE_XIM */
789 /* We use XLookupString if we're not using XIM, or are using
790 XIM_XLIB but input context creation failed. */
791 #if ! (defined (HAVE_XIM) && defined (XIM_MOTIF))
792 #if defined (HAVE_XIM) && defined (XIM_XLIB)
794 #endif /* XIM_XLIB */
796 /* Apparently it's necessary to specify a dummy here (rather
797 than passing in 0) to avoid crashes on German IRIX */
799 XLookupString (event, dummy, 200, &keysym, 0);
800 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
801 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
803 #endif /* ! XIM_MOTIF */
806 Lookup_String: /* Come-From XBufferOverflow */
808 len = XmImMbLookupString (XtWindowToWidget (event->display, event->window),
809 event, bufptr, bufsiz, &keysym, &status);
812 len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
813 #endif /* HAVE_XIM */
816 if (x_debug_events > 0)
818 stderr_out (" status=");
819 #define print_status_when(S) if (status == S) stderr_out (#S)
820 print_status_when (XLookupKeySym);
821 print_status_when (XLookupBoth);
822 print_status_when (XLookupChars);
823 print_status_when (XLookupNone);
824 print_status_when (XBufferOverflow);
826 if (status == XLookupKeySym || status == XLookupBoth)
827 stderr_out (" keysym=%s", XKeysymToString (keysym));
828 if (status == XLookupChars || status == XLookupBoth)
833 stderr_out (" chars=\"");
834 for (j=0; j<len; j++)
835 stderr_out ("%c", bufptr[j]);
838 else if (bufptr[0] <= 32 || bufptr[0] >= 127)
839 stderr_out (" char=0x%x", bufptr[0]);
841 stderr_out (" char=%c", bufptr[0]);
845 #endif /* DEBUG_XEMACS */
851 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
852 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
856 /* Generate multiple emacs events */
857 struct device *d = get_device_from_display (event->display);
859 Lisp_Object instream, fb_instream;
861 struct gcpro gcpro1, gcpro2;
864 make_fixed_buffer_input_stream ((unsigned char *) bufptr, len);
866 /* ### Use Fget_coding_system (Vcomposed_input_coding_system) */
868 make_decoding_input_stream (XLSTREAM (fb_instream),
869 Fget_coding_system (Qundecided));
871 istr = XLSTREAM (instream);
873 GCPRO2 (instream, fb_instream);
874 while ((ch = Lstream_get_emchar (istr)) != EOF)
876 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
877 struct Lisp_Event *ev = XEVENT (emacs_event);
878 ev->channel = DEVICE_CONSOLE (d);
879 ev->event_type = key_press_event;
880 ev->timestamp = event->time;
881 ev->event.key.modifiers = 0;
882 ev->event.key.keysym = make_char (ch);
883 enqueue_Xt_dispatch_event (emacs_event);
885 Lstream_close (istr);
887 Lstream_delete (istr);
888 Lstream_delete (XLSTREAM (fb_instream));
891 case XLookupNone: return Qnil;
892 case XBufferOverflow:
893 bufptr = (char *) alloca (len+1);
897 return Qnil; /* not reached */
898 #endif /* HAVE_XIM */
902 set_last_server_timestamp (struct device *d, XEvent *x_event)
905 switch (x_event->type)
908 case KeyRelease: t = x_event->xkey.time; break;
910 case ButtonRelease: t = x_event->xbutton.time; break;
912 case LeaveNotify: t = x_event->xcrossing.time; break;
913 case MotionNotify: t = x_event->xmotion.time; break;
914 case PropertyNotify: t = x_event->xproperty.time; break;
915 case SelectionClear: t = x_event->xselectionclear.time; break;
916 case SelectionRequest: t = x_event->xselectionrequest.time; break;
917 case SelectionNotify: t = x_event->xselection.time; break;
920 DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t;
924 x_event_to_emacs_event (XEvent *x_event, struct Lisp_Event *emacs_event)
926 Display *display = x_event->xany.display;
927 struct device *d = get_device_from_display (display);
928 struct x_device *xd = DEVICE_X_DATA (d);
930 if (DEVICE_X_BEING_DELETED (d))
931 /* #### Uh, is this 0 correct? */
934 set_last_server_timestamp (d, x_event);
936 switch (x_event->type)
939 x_handle_sticky_modifiers (x_event, d);
946 unsigned int modifiers = 0;
948 Bool key_event_p = (x_event->type == KeyPress);
949 unsigned int *state =
950 key_event_p ? &x_event->xkey.state : &x_event->xbutton.state;
952 /* If this is a synthetic KeyPress or Button event, and the user
953 has expressed a disinterest in this security hole, then drop
956 ? x_event->xkey.send_event
957 : x_event->xbutton.send_event)
958 #ifdef EXTERNAL_WIDGET
959 /* ben: events get sent to an ExternalShell using XSendEvent.
960 This is not a perfect solution. */
961 && !FRAME_X_EXTERNAL_WINDOW_P
962 (x_any_window_to_frame (d, x_event->xany.window))
964 && !x_allow_sendevents)
967 DEVICE_X_MOUSE_TIMESTAMP (d) =
968 DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
969 key_event_p ? x_event->xkey.time : x_event->xbutton.time;
971 x_handle_sticky_modifiers (x_event, d);
973 if (*state & ControlMask) modifiers |= MOD_CONTROL;
974 if (*state & xd->MetaMask) modifiers |= MOD_META;
975 if (*state & xd->SuperMask) modifiers |= MOD_SUPER;
976 if (*state & xd->HyperMask) modifiers |= MOD_HYPER;
977 if (*state & xd->AltMask) modifiers |= MOD_ALT;
979 /* Ignore the Caps_Lock key if:
980 - any other modifiers are down, so that Caps_Lock doesn't
981 turn C-x into C-X, which would suck.
982 - the event was a mouse event. */
983 if (modifiers || ! key_event_p)
984 *state &= (~LockMask);
986 shift_p = *state & ShiftMask;
987 lock_p = *state & LockMask;
989 if (shift_p || lock_p)
990 modifiers |= MOD_SHIFT;
995 XKeyEvent *ev = &x_event->xkey;
996 /* This used to compute the frame from the given X window and
997 store it here, but we really don't care about the frame. */
998 emacs_event->channel = DEVICE_CONSOLE (d);
999 keysym = x_to_emacs_keysym (&x_event->xkey, 0);
1001 /* If the emacs keysym is nil, then that means that the X
1002 keysym was either a Modifier or NoSymbol, which
1003 probably means that we're in the midst of reading a
1004 Multi_key sequence, or a "dead" key prefix, or XIM
1005 input. Ignore it. */
1009 /* More Caps_Lock garbage: Caps_Lock should *only* add the
1010 shift modifier to two-case keys (that is, A-Z and
1011 related characters). So at this point (after looking up
1012 the keysym) if the keysym isn't a dual-case alphabetic,
1013 and if the caps lock key was down but the shift key
1014 wasn't, then turn off the shift modifier. Gag barf */
1015 /* #### type lossage: assuming equivalence of emacs and
1017 /* !!#### maybe fix for Mule */
1018 if (lock_p && !shift_p &&
1019 ! (CHAR_OR_CHAR_INTP (keysym)
1020 && keysym_obeys_caps_lock_p
1021 ((KeySym) XCHAR_OR_CHAR_INT (keysym), d)))
1022 modifiers &= (~MOD_SHIFT);
1024 /* If this key contains two distinct keysyms, that is,
1025 "shift" generates a different keysym than the
1026 non-shifted key, then don't apply the shift modifier
1027 bit: it's implicit. Otherwise, if there would be no
1028 other way to tell the difference between the shifted
1029 and unshifted version of this key, apply the shift bit.
1030 Non-graphics, like Backspace and F1 get the shift bit
1031 in the modifiers slot. Neither the characters "a",
1032 "A", "2", nor "@" normally have the shift bit set.
1033 However, "F1" normally does. */
1034 if (modifiers & MOD_SHIFT)
1036 int Mode_switch_p = *state & xd->ModeMask;
1037 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0);
1038 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1);
1039 if (top && bot && top != bot)
1040 modifiers &= ~MOD_SHIFT;
1042 emacs_event->event_type = key_press_event;
1043 emacs_event->timestamp = ev->time;
1044 emacs_event->event.key.modifiers = modifiers;
1045 emacs_event->event.key.keysym = keysym;
1047 else /* Mouse press/release event */
1049 XButtonEvent *ev = &x_event->xbutton;
1050 struct frame *frame = x_window_to_frame (d, ev->window);
1053 return 0; /* not for us */
1054 XSETFRAME (emacs_event->channel, frame);
1056 emacs_event->event_type = (x_event->type == ButtonPress) ?
1057 button_press_event : button_release_event;
1059 emacs_event->event.button.modifiers = modifiers;
1060 emacs_event->timestamp = ev->time;
1061 emacs_event->event.button.button = ev->button;
1062 emacs_event->event.button.x = ev->x;
1063 emacs_event->event.button.y = ev->y;
1064 /* because we don't seem to get a FocusIn event for button clicks
1065 when a widget-glyph is selected we will assume that we want the
1066 focus if a button gets pressed. */
1067 if (x_event->type == ButtonPress)
1068 handle_focus_event_1 (frame, 1);
1075 XMotionEvent *ev = &x_event->xmotion;
1076 struct frame *frame = x_window_to_frame (d, ev->window);
1077 unsigned int modifiers = 0;
1078 XMotionEvent event2;
1081 return 0; /* not for us */
1083 /* We use MotionHintMask, so we will get only one motion event
1084 until the next time we call XQueryPointer or the user
1085 clicks the mouse. So call XQueryPointer now (meaning that
1086 the event will be in sync with the server just before
1087 Fnext_event() returns). If the mouse is still in motion,
1088 then the server will immediately generate exactly one more
1089 motion event, which will be on the queue waiting for us
1090 next time around. */
1092 if (XQueryPointer (event2.display, event2.window,
1093 &event2.root, &event2.subwindow,
1094 &event2.x_root, &event2.y_root,
1095 &event2.x, &event2.y,
1097 ev = &event2; /* only one structure copy */
1099 DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
1101 XSETFRAME (emacs_event->channel, frame);
1102 emacs_event->event_type = pointer_motion_event;
1103 emacs_event->timestamp = ev->time;
1104 emacs_event->event.motion.x = ev->x;
1105 emacs_event->event.motion.y = ev->y;
1106 if (ev->state & ShiftMask) modifiers |= MOD_SHIFT;
1107 if (ev->state & ControlMask) modifiers |= MOD_CONTROL;
1108 if (ev->state & xd->MetaMask) modifiers |= MOD_META;
1109 if (ev->state & xd->SuperMask) modifiers |= MOD_SUPER;
1110 if (ev->state & xd->HyperMask) modifiers |= MOD_HYPER;
1111 if (ev->state & xd->AltMask) modifiers |= MOD_ALT;
1112 /* Currently ignores Shift_Lock but probably shouldn't
1113 (but it definitely should ignore Caps_Lock). */
1114 emacs_event->event.motion.modifiers = modifiers;
1120 /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
1121 passed as the timestamp of the TAKE_FOCUS, which the ICCCM
1122 explicitly prohibits. */
1123 XClientMessageEvent *ev = &x_event->xclient;
1124 #ifdef HAVE_OFFIX_DND
1125 if (DndIsDropMessage(x_event))
1127 unsigned int state, modifiers = 0, button=0;
1128 struct frame *frame = x_any_window_to_frame (d, ev->window);
1130 unsigned long size, dtype;
1131 Lisp_Object l_type = Qnil, l_data = Qnil;
1132 Lisp_Object l_dndlist = Qnil, l_item = Qnil;
1133 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1135 GCPRO4 (l_type, l_data, l_dndlist, l_item);
1138 return 0; /* not for us */
1139 XSETFRAME (emacs_event->channel, frame);
1141 emacs_event->event_type = misc_user_event;
1142 emacs_event->timestamp = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1144 state=DndDragButtons(x_event);
1146 if (state & ShiftMask) modifiers |= MOD_SHIFT;
1147 if (state & ControlMask) modifiers |= MOD_CONTROL;
1148 if (state & xd->MetaMask) modifiers |= MOD_META;
1149 if (state & xd->SuperMask) modifiers |= MOD_SUPER;
1150 if (state & xd->HyperMask) modifiers |= MOD_HYPER;
1151 if (state & xd->AltMask) modifiers |= MOD_ALT;
1153 if (state & Button5Mask) button = Button5;
1154 if (state & Button4Mask) button = Button4;
1155 if (state & Button3Mask) button = Button3;
1156 if (state & Button2Mask) button = Button2;
1157 if (state & Button1Mask) button = Button1;
1159 emacs_event->event.misc.modifiers = modifiers;
1160 emacs_event->event.misc.button = button;
1162 DndDropCoordinates(FRAME_X_TEXT_WIDGET(frame), x_event,
1163 &(emacs_event->event.misc.x),
1164 &(emacs_event->event.misc.y) );
1166 DndGetData(x_event,&data,&size);
1168 dtype=DndDataType(x_event);
1171 case DndFiles: /* null terminated strings, end null */
1178 len = strlen ((char*)data);
1179 hurl = dnd_url_hexify_string ((char *)data, "file:");
1180 l_item = make_string ((Bufbyte *)hurl, strlen (hurl));
1181 l_dndlist = Fcons (l_item, l_dndlist);
1185 l_type = Qdragdrop_URL;
1189 l_type = Qdragdrop_MIME;
1190 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
1191 make_string ((Bufbyte *)"8bit", 4),
1192 make_ext_string ((Extbyte *)data,
1193 strlen((char *)data),
1197 /* we have to parse this in some way to extract
1198 content-type and params (in the tm way) and
1200 OR: if data is string, let tm do the job
1201 if data is list[2], give the first two
1204 l_type = Qdragdrop_MIME;
1205 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1206 strlen((char *)data),
1214 char *hurl = dnd_url_hexify_string ((char *) data, "file:");
1216 l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
1218 l_type = Qdragdrop_URL;
1224 /* as it is a real URL it should already be escaped
1225 and escaping again will break them (cause % is unsave) */
1226 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1227 strlen ((char *)data),
1229 l_type = Qdragdrop_URL;
1231 default: /* Unknown, RawData and any other type */
1232 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"application/octet-stream", 24) ),
1233 make_string ((Bufbyte *)"8bit", 4),
1234 make_ext_string ((Extbyte *)data,
1237 l_type = Qdragdrop_MIME;
1241 emacs_event->event.misc.function = Qdragdrop_drop_dispatch;
1242 emacs_event->event.misc.object = Fcons (l_type, l_dndlist);
1248 #endif /* HAVE_OFFIX_DND */
1249 if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
1250 && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
1251 && (Atom) (ev->data.l[1]) == 0)
1253 ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1258 default: /* it's a magic event */
1260 struct frame *frame;
1262 XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
1264 #define FROB(event_member, window_member) \
1265 x_event_copy->event_member = x_event->event_member; \
1266 w = x_event->event_member.window_member
1268 switch (x_event->type)
1270 case SelectionRequest: FROB(xselectionrequest, owner); break;
1271 case SelectionClear: FROB(xselectionclear, window); break;
1272 case SelectionNotify: FROB(xselection, requestor); break;
1273 case PropertyNotify: FROB(xproperty, window); break;
1274 case ClientMessage: FROB(xclient, window); break;
1275 case ConfigureNotify: FROB(xconfigure, window); break;
1277 case GraphicsExpose: FROB(xexpose, window); break;
1279 case UnmapNotify: FROB(xmap, window); break;
1281 case LeaveNotify: FROB(xcrossing, window); break;
1283 case FocusOut: FROB(xfocus, window); break;
1284 case VisibilityNotify: FROB(xvisibility, window); break;
1286 w = x_event->xany.window;
1287 *x_event_copy = *x_event;
1291 frame = x_any_window_to_frame (d, w);
1296 emacs_event->event_type = magic_event;
1297 XSETFRAME (emacs_event->channel, frame);
1307 /************************************************************************/
1308 /* magic-event handling */
1309 /************************************************************************/
1312 handle_focus_event_1 (struct frame *f, int in_p)
1314 #if XtSpecificationRelease > 5
1315 Widget focus_widget = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f));
1317 #if defined(HAVE_XIM) && defined(XIM_XLIB)
1319 XIM_focus_event (f, in_p);
1320 #endif /* HAVE_XIM */
1322 /* On focus change, clear all memory of sticky modifiers
1323 to avoid non-intuitive behavior. */
1324 clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f)));
1326 /* We don't want to handle the focus change now, because we might
1327 be in an accept-process-output, sleep-for, or sit-for. So
1330 Actually, we half handle it: we handle it as far as changing the
1331 box cursor for redisplay, but we don't call any hooks or do any
1332 select-frame stuff until after the sit-for.
1334 Unfortunately native widgets break the model because they grab
1335 the keyboard focus and nothing sets it back again. I cannot find
1336 any reasonable way to do this elsewhere so we assert here that
1337 the keybpard focus is on the emacs text widget. Menus and dialogs
1338 do this in their selection callback, but we don't want that since
1339 a button having focus is legitimate. An edit field having focus
1340 is mandatory. Weirdly you get a FocusOut event when you glick in
1341 a widget-glyph but you don't get a correspondng FocusIn when you
1342 click in the frame. Why is this? */
1344 #if XtSpecificationRelease > 5
1345 && FRAME_X_TEXT_WIDGET (f) != focus_widget
1349 lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f),
1350 FRAME_X_TEXT_WIDGET (f));
1352 /* do the generic event-stream stuff. */
1356 struct gcpro gcpro1;
1359 conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
1361 emacs_handle_focus_change_preliminary (conser);
1362 enqueue_magic_eval_event (emacs_handle_focus_change_final,
1368 /* This is called from the external-widget code */
1370 void emacs_Xt_handle_focus_event (XEvent *event);
1372 emacs_Xt_handle_focus_event (XEvent *event)
1374 struct device *d = get_device_from_display (event->xany.display);
1377 if (DEVICE_X_BEING_DELETED (d))
1381 * It's curious that we're using x_any_window_to_frame() instead
1382 * of x_window_to_frame(). I don't know what the impact of this is.
1384 f = x_any_window_to_frame (d, event->xfocus.window);
1386 /* focus events are sometimes generated just before
1387 a frame is destroyed. */
1389 handle_focus_event_1 (f, event->type == FocusIn);
1392 /* both MapNotify and VisibilityNotify can cause this
1393 JV is_visible has the same semantics as f->visible*/
1395 change_frame_visibility (struct frame *f, int is_visible)
1399 XSETFRAME (frame, f);
1401 if (!FRAME_VISIBLE_P (f) && is_visible)
1403 FRAME_VISIBLE_P (f) = is_visible;
1404 /* This improves the double flicker when uniconifying a frame
1405 some. A lot of it is not showing a buffer which has changed
1406 while the frame was iconified. To fix it further requires
1407 the good 'ol double redisplay structure. */
1408 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1409 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1411 else if (FRAME_VISIBLE_P (f) && !is_visible)
1413 FRAME_VISIBLE_P (f) = 0;
1414 va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
1416 else if (FRAME_VISIBLE_P (f) * is_visible < 0)
1418 FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f);
1419 if (FRAME_REPAINT_P(f))
1420 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1421 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1426 handle_map_event (struct frame *f, XEvent *event)
1430 XSETFRAME (frame, f);
1431 if (event->type == MapNotify)
1433 XWindowAttributes xwa;
1435 /* Bleagh!!!!!! Apparently some window managers (e.g. MWM)
1436 send synthetic MapNotify events when a window is first
1437 created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE.
1438 Or something like that. We initially tried a different
1439 solution below, but that ran into a different window-
1442 It seems that the only reliable way is to treat a
1443 MapNotify event as a "hint" that the window might or
1444 might not be visible, and check explicitly. */
1446 XGetWindowAttributes (event->xany.display, event->xmap.window,
1448 if (xwa.map_state != IsViewable)
1450 /* Calling Fframe_iconified_p is the only way we have to
1451 correctly update FRAME_ICONIFIED_P */
1452 Fframe_iconified_p (frame);
1456 FRAME_X_TOTALLY_VISIBLE_P (f) = 1;
1458 /* Bleagh again!!!! We initially tried the following hack
1459 around the MWM problem, but it turns out that TWM
1460 has a race condition when you un-iconify, where it maps
1461 the window and then tells the server that the window
1462 is un-iconified. Usually, XEmacs wakes up between
1463 those two occurrences, and thus thinks that un-iconified
1464 windows are still iconified.
1466 Ah, the joys of X. */
1468 /* By Emacs definition, a frame that is iconified is not
1469 visible. Marking a frame as visible will automatically cause
1470 frame-iconified-p to return nil, regardless of whether the
1471 frame is actually iconified. Therefore, we have to ignore
1472 MapNotify events on iconified frames. (It's not obvious
1473 to me why these are being sent, but it happens at startup
1474 with frames that are initially iconified; perhaps they are
1475 synthetic MapNotify events coming from the window manager.)
1476 Note that `frame-iconified-p' queries the server
1477 to determine whether the frame is currently iconified,
1478 rather than consulting some internal (and likely
1479 inaccurate) state flag. Therefore, ignoring the MapNotify
1481 if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (frame)))
1483 change_frame_visibility (f, 1);
1487 FRAME_X_TOTALLY_VISIBLE_P (f) = 0;
1488 change_frame_visibility (f, 0);
1489 /* Calling Fframe_iconified_p is the only way we have to
1490 correctly update FRAME_ICONIFIED_P */
1491 Fframe_iconified_p (frame);
1496 handle_client_message (struct frame *f, XEvent *event)
1498 struct device *d = XDEVICE (FRAME_DEVICE (f));
1501 XSETFRAME (frame, f);
1503 if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1504 (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d))
1506 /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages,
1507 such as WM_TAKE_FOCUS, are eval events. That's because delete-window
1508 was probably executed with a mouse click, while the others could
1509 have been sent as a result of mouse motion or some other implicit
1510 action. (Call this a "heuristic"...) The reason for caring about
1511 this is so that clicking on the close-box will make emacs prompt
1512 using a dialog box instead of the minibuffer if there are unsaved
1515 enqueue_misc_user_event (frame, Qeval,
1516 list3 (Qdelete_frame, frame, Qt));
1518 else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1519 (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
1521 handle_focus_event_1 (f, 1);
1523 /* If there is a dialog box up, focus on it.
1525 #### Actually, we're raising it too, which is wrong. We should
1526 #### just focus on it, but lwlib doesn't currently give us an
1527 #### easy way to do that. This should be fixed.
1529 unsigned long take_focus_timestamp = event->xclient.data.l[1];
1530 Widget widget = lw_raise_all_pop_up_widgets ();
1533 /* kludge: raise_all returns bottommost widget, but we really
1534 want the topmost. So just raise it for now. */
1535 XMapRaised (XtDisplay (widget), XtWindow (widget));
1536 /* Grab the focus with the timestamp of the TAKE_FOCUS. */
1537 XSetInputFocus (XtDisplay (widget), XtWindow (widget),
1538 RevertToParent, take_focus_timestamp);
1545 emacs_Xt_handle_magic_event (struct Lisp_Event *emacs_event)
1547 /* This function can GC */
1548 XEvent *event = &emacs_event->event.magic.underlying_x_event;
1549 struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
1551 if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
1554 switch (event->type)
1556 case SelectionRequest:
1557 x_handle_selection_request (&event->xselectionrequest);
1560 case SelectionClear:
1561 x_handle_selection_clear (&event->xselectionclear);
1564 case SelectionNotify:
1565 x_handle_selection_notify (&event->xselection);
1568 case PropertyNotify:
1569 x_handle_property_notify (&event->xproperty);
1573 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1574 event->xexpose.width, event->xexpose.height);
1577 case GraphicsExpose: /* This occurs when an XCopyArea's source area was
1578 obscured or not available. */
1579 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1580 event->xexpose.width, event->xexpose.height);
1585 handle_map_event (f, event);
1589 if (event->xcrossing.detail != NotifyInferior)
1593 XSETFRAME (frame, f);
1594 /* FRAME_X_MOUSE_P (f) = 1; */
1595 va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
1600 if (event->xcrossing.detail != NotifyInferior)
1604 XSETFRAME (frame, f);
1605 /* FRAME_X_MOUSE_P (f) = 0; */
1606 va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
1613 #ifdef EXTERNAL_WIDGET
1614 /* External widget lossage: Ben said:
1615 YUCK. The only way to make focus changes work properly is to
1616 completely ignore all FocusIn/FocusOut events and depend only
1617 on notifications from the ExternalClient widget. */
1618 if (FRAME_X_EXTERNAL_WINDOW_P (f))
1621 handle_focus_event_1 (f, event->type == FocusIn);
1625 handle_client_message (f, event);
1628 case VisibilityNotify: /* window visibility has changed */
1629 if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
1631 FRAME_X_TOTALLY_VISIBLE_P (f) =
1632 (event->xvisibility.state == VisibilityUnobscured);
1633 /* Note that the fvwm pager only sends VisibilityNotify when
1634 changing pages. Is this all we need to do ? JV */
1635 /* Nope. We must at least trigger a redisplay here.
1636 Since this case seems similar to MapNotify, I've
1637 factored out some code to change_frame_visibility().
1638 This triggers the necessary redisplay and runs
1639 (un)map-frame-hook. - dkindred@cs.cmu.edu */
1640 /* Changed it again to support the tristate visibility flag */
1641 change_frame_visibility (f, (event->xvisibility.state
1642 != VisibilityFullyObscured) ? 1 : -1);
1646 case ConfigureNotify:
1647 #if defined(HAVE_XIM) && defined(XIM_XLIB)
1649 XIM_SetGeometry (f);
1659 /************************************************************************/
1660 /* timeout events */
1661 /************************************************************************/
1663 static int timeout_id_tick;
1665 /* Xt interval id's might not fit into an int (they're pointers, as it
1666 happens), so we need to provide a conversion list. */
1671 XtIntervalId interval_id;
1672 struct Xt_timeout *next;
1673 } *pending_timeouts, *completed_timeouts;
1675 struct Xt_timeout_blocktype
1677 Blocktype_declare (struct Xt_timeout);
1678 } *the_Xt_timeout_blocktype;
1680 /* called by XtAppNextEvent() */
1682 Xt_timeout_callback (XtPointer closure, XtIntervalId *id)
1684 struct Xt_timeout *timeout = (struct Xt_timeout *) closure;
1685 struct Xt_timeout *t2 = pending_timeouts;
1686 /* Remove this one from the list of pending timeouts */
1688 pending_timeouts = pending_timeouts->next;
1691 while (t2->next && t2->next != timeout) t2 = t2->next;
1693 t2->next = t2->next->next;
1695 /* Add this one to the list of completed timeouts */
1696 timeout->next = completed_timeouts;
1697 completed_timeouts = timeout;
1701 emacs_Xt_add_timeout (EMACS_TIME thyme)
1703 struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype);
1704 EMACS_TIME current_time;
1707 timeout->id = timeout_id_tick++;
1708 timeout->next = pending_timeouts;
1709 pending_timeouts = timeout;
1710 EMACS_GET_TIME (current_time);
1711 EMACS_SUB_TIME (thyme, thyme, current_time);
1712 milliseconds = EMACS_SECS (thyme) * 1000 +
1713 EMACS_USECS (thyme) / 1000;
1714 if (milliseconds < 1)
1716 timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds,
1717 Xt_timeout_callback,
1718 (XtPointer) timeout);
1723 emacs_Xt_remove_timeout (int id)
1725 struct Xt_timeout *timeout, *t2;
1729 /* Find the timeout on the list of pending ones, if it's still there. */
1730 if (pending_timeouts)
1732 if (id == pending_timeouts->id)
1734 timeout = pending_timeouts;
1735 pending_timeouts = pending_timeouts->next;
1739 t2 = pending_timeouts;
1740 while (t2->next && t2->next->id != id) t2 = t2->next;
1741 if ( t2->next) /*found it */
1744 t2->next = t2->next->next;
1747 /* if it was pending, we have removed it from the list */
1749 XtRemoveTimeOut (timeout->interval_id);
1752 /* It could be that the Xt call back was already called but we didn't convert
1753 into an Emacs event yet */
1754 if (!timeout && completed_timeouts)
1756 /* Code duplication! */
1757 if (id == completed_timeouts->id)
1759 timeout = completed_timeouts;
1760 completed_timeouts = completed_timeouts->next;
1764 t2 = completed_timeouts;
1765 while (t2->next && t2->next->id != id) t2 = t2->next;
1766 if ( t2->next) /*found it */
1769 t2->next = t2->next->next;
1774 /* If we found the thing on the lists of timeouts,
1775 and removed it, deallocate
1778 Blocktype_free (the_Xt_timeout_blocktype, timeout);
1782 Xt_timeout_to_emacs_event (struct Lisp_Event *emacs_event)
1784 struct Xt_timeout *timeout = completed_timeouts;
1786 completed_timeouts = completed_timeouts->next;
1787 emacs_event->event_type = timeout_event;
1788 /* timeout events have nil as channel */
1789 emacs_event->timestamp = 0; /* #### wrong!! */
1790 emacs_event->event.timeout.interval_id = timeout->id;
1791 emacs_event->event.timeout.function = Qnil;
1792 emacs_event->event.timeout.object = Qnil;
1793 Blocktype_free (the_Xt_timeout_blocktype, timeout);
1797 /************************************************************************/
1798 /* process and tty events */
1799 /************************************************************************/
1801 struct what_is_ready_closure
1808 static Lisp_Object *filedesc_with_input;
1809 static struct what_is_ready_closure **filedesc_to_what_closure;
1812 init_what_input_once (void)
1816 filedesc_with_input = xnew_array (Lisp_Object, MAXDESC);
1817 filedesc_to_what_closure =
1818 xnew_array (struct what_is_ready_closure *, MAXDESC);
1820 for (i = 0; i < MAXDESC; i++)
1822 filedesc_to_what_closure[i] = 0;
1823 filedesc_with_input[i] = Qnil;
1826 process_events_occurred = 0;
1827 tty_events_occurred = 0;
1831 mark_what_as_being_ready (struct what_is_ready_closure *closure)
1833 if (NILP (filedesc_with_input[closure->fd]))
1835 SELECT_TYPE temp_mask;
1836 FD_ZERO (&temp_mask);
1837 FD_SET (closure->fd, &temp_mask);
1838 /* Check to make sure there's *really* input available.
1839 Sometimes things seem to get confused and this gets called
1840 for the tty fd when there's really only input available
1841 on some process's fd. (It will subsequently get called
1842 for that process's fd, so returning without setting any
1843 flags will take care of it.) To see the problem, uncomment
1844 the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
1845 down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
1846 and press return repeatedly. (Seen under AIX & Linux.)
1847 -dkindred@cs.cmu.edu */
1848 if (!poll_fds_for_input (temp_mask))
1851 stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
1856 filedesc_with_input[closure->fd] = closure->what;
1857 if (PROCESSP (closure->what))
1858 /* Don't increment this if the current process is already marked
1859 * as having input. */
1860 process_events_occurred++;
1862 tty_events_occurred++;
1867 Xt_what_callback (void *closure, int *source, XtInputId *id)
1869 /* If closure is 0, then we got a fake event from a signal handler.
1870 The only purpose of this is to make XtAppProcessEvent() stop
1873 mark_what_as_being_ready ((struct what_is_ready_closure *) closure);
1876 fake_event_occurred++;
1877 drain_signal_event_pipe ();
1882 select_filedesc (int fd, Lisp_Object what)
1884 struct what_is_ready_closure *closure;
1886 /* If somebody is trying to select something that's already selected
1887 for, then something went wrong. The generic routines ought to
1888 detect this and error before here. */
1889 assert (!filedesc_to_what_closure[fd]);
1891 closure = xnew (struct what_is_ready_closure);
1893 closure->what = what;
1895 XtAppAddInput (Xt_app_con, fd,
1896 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
1897 Xt_what_callback, closure);
1898 filedesc_to_what_closure[fd] = closure;
1902 unselect_filedesc (int fd)
1904 struct what_is_ready_closure *closure = filedesc_to_what_closure[fd];
1907 if (!NILP (filedesc_with_input[fd]))
1909 /* We are unselecting this process before we have drained the rest of
1910 the input from it, probably from status_notify() in the command loop.
1911 This can happen like so:
1913 - We are waiting in XtAppNextEvent()
1914 - Process generates output
1915 - Process is marked as being ready
1916 - Process dies, SIGCHLD gets generated before we return (!?)
1917 It could happen I guess.
1918 - sigchld_handler() marks process as dead
1919 - Somehow we end up getting a new KeyPress event on the queue
1920 at the same time (I'm really so sure how that happens but I'm
1921 not sure it can't either so let's assume it can...).
1922 - Key events have priority so we return that instead of the proc.
1923 - Before dispatching the lisp key event we call status_notify()
1924 - Which deselects the process that SIGCHLD marked as dead.
1926 Thus we never remove it from _with_input and turn it into a lisp
1927 event, so we need to do it here. But this does not mean that we're
1928 throwing away the last block of output - status_notify() has already
1929 taken care of running the proc filter or whatever.
1931 filedesc_with_input[fd] = Qnil;
1932 if (PROCESSP (closure->what))
1934 assert (process_events_occurred > 0);
1935 process_events_occurred--;
1939 assert (tty_events_occurred > 0);
1940 tty_events_occurred--;
1943 XtRemoveInput (closure->id);
1945 filedesc_to_what_closure[fd] = 0;
1949 emacs_Xt_select_process (struct Lisp_Process *p)
1951 Lisp_Object process;
1952 int infd = event_stream_unixoid_select_process (p);
1954 XSETPROCESS (process, p);
1955 select_filedesc (infd, process);
1959 emacs_Xt_unselect_process (struct Lisp_Process *p)
1961 int infd = event_stream_unixoid_unselect_process (p);
1963 unselect_filedesc (infd);
1967 emacs_Xt_create_stream_pair (void* inhandle, void* outhandle,
1968 Lisp_Object* instream, Lisp_Object* outstream, int flags)
1970 USID u = event_stream_unixoid_create_stream_pair
1971 (inhandle, outhandle, instream, outstream, flags);
1972 if (u != USID_ERROR)
1978 emacs_Xt_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream)
1980 event_stream_unixoid_delete_stream_pair (instream, outstream);
1981 return USID_DONTHASH;
1984 /* This is called from GC when a process object is about to be freed.
1985 If we've still got pointers to it in this file, we're gonna lose hard.
1988 debug_process_finalization (struct Lisp_Process *p)
1992 Lisp_Object instr, outstr;
1994 get_process_streams (p, &instr, &outstr);
1995 /* if it still has fds, then it hasn't been killed yet. */
1996 assert (NILP(instr));
1997 assert (NILP(outstr));
1998 /* Better not still be in the "with input" table; we know it's got no fds. */
1999 for (i = 0; i < MAXDESC; i++)
2001 Lisp_Object process = filedesc_fds_with_input [i];
2002 assert (!PROCESSP (process) || XPROCESS (process) != p);
2008 Xt_process_to_emacs_event (struct Lisp_Event *emacs_event)
2011 Lisp_Object process;
2013 assert (process_events_occurred > 0);
2014 for (i = 0; i < MAXDESC; i++)
2016 process = filedesc_with_input[i];
2017 if (PROCESSP (process))
2020 assert (i < MAXDESC);
2021 filedesc_with_input[i] = Qnil;
2022 process_events_occurred--;
2023 /* process events have nil as channel */
2024 emacs_event->event_type = process_event;
2025 emacs_event->timestamp = 0; /* #### */
2026 emacs_event->event.process.process = process;
2030 emacs_Xt_select_console (struct console *con)
2032 Lisp_Object console;
2038 if (CONSOLE_X_P (con))
2039 return; /* X consoles are automatically selected for when we
2040 initialize them in Xt */
2041 infd = event_stream_unixoid_select_console (con);
2042 XSETCONSOLE (console, con);
2043 select_filedesc (infd, console);
2045 /* On a stream device (ie: noninteractive), bad things can happen. */
2046 if (EQ (CONSOLE_TYPE (con), Qtty)) {
2047 mousefd = CONSOLE_TTY_MOUSE_FD (con);
2048 /* We check filedesc_to_what_closure[fd] here because if you run
2049 ** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
2050 ** if you run gnuattach to connect to another TTY, it will fire up
2051 ** GPM again, and try to reselect the mouse fd. GPM uses the same
2052 ** fd for every connection apparently, and select_filedesc will
2053 ** fail its assertion if we try to select it twice.
2055 if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
2056 select_filedesc (mousefd, console);
2063 emacs_Xt_unselect_console (struct console *con)
2065 Lisp_Object console;
2071 if (CONSOLE_X_P (con))
2072 return; /* X consoles are automatically selected for when we
2073 initialize them in Xt */
2074 infd = event_stream_unixoid_unselect_console (con);
2075 XSETCONSOLE (console, con);
2076 unselect_filedesc (infd);
2078 /* On a stream device (ie: noninteractive), bad things can happen. */
2079 if (EQ (CONSOLE_TYPE (con), Qtty)) {
2080 mousefd = CONSOLE_TTY_MOUSE_FD (con);
2082 unselect_filedesc (mousefd);
2088 /* read an event from a tty, if one is available. Returns non-zero
2089 if an event was available. Note that when this function is
2090 called, there should always be a tty marked as ready for input.
2091 However, the input condition might actually be EOF, so there
2092 may not really be any input available. (In this case,
2093 read_event_from_tty_or_stream_desc() will arrange for the TTY device
2097 Xt_tty_to_emacs_event (struct Lisp_Event *emacs_event)
2101 assert (tty_events_occurred > 0);
2102 for (i = 0; i < MAXDESC; i++)
2104 Lisp_Object console = filedesc_with_input[i];
2105 if (CONSOLEP (console))
2107 assert (tty_events_occurred > 0);
2108 tty_events_occurred--;
2109 filedesc_with_input[i] = Qnil;
2110 if (read_event_from_tty_or_stream_desc
2111 (emacs_event, XCONSOLE (console), i))
2120 /************************************************************************/
2121 /* debugging functions to decipher an event */
2122 /************************************************************************/
2125 #include "xintrinsicp.h" /* only describe_event() needs this */
2126 #include <X11/Xproto.h> /* only describe_event() needs this */
2129 describe_event_window (Window window, Display *display)
2133 stderr_out (" window: 0x%lx", (unsigned long) window);
2134 w = XtWindowToWidget (display, window);
2136 stderr_out (" %s", w->core.widget_class->core_class.class_name);
2137 f = x_any_window_to_frame (get_device_from_display (display), window);
2140 char *buf = alloca_array (char, XSTRING_LENGTH (f->name) + 4);
2141 sprintf (buf, " \"%s\"", XSTRING_DATA (f->name));
2142 write_string_to_stdio_stream (stderr, 0, (Bufbyte *) buf, 0,
2143 strlen (buf), FORMAT_TERMINAL);
2149 XEvent_mode_to_string (int mode)
2153 case NotifyNormal: return "Normal";
2154 case NotifyGrab: return "Grab";
2155 case NotifyUngrab: return "Ungrab";
2156 case NotifyWhileGrabbed: return "WhileGrabbed";
2157 default: return "???";
2162 XEvent_detail_to_string (int detail)
2166 case NotifyAncestor: return "Ancestor";
2167 case NotifyInferior: return "Inferior";
2168 case NotifyNonlinear: return "Nonlinear";
2169 case NotifyNonlinearVirtual: return "NonlinearVirtual";
2170 case NotifyPointer: return "Pointer";
2171 case NotifyPointerRoot: return "PointerRoot";
2172 case NotifyDetailNone: return "DetailNone";
2173 default: return "???";
2178 XEvent_visibility_to_string (int state)
2182 case VisibilityFullyObscured: return "FullyObscured";
2183 case VisibilityPartiallyObscured: return "PartiallyObscured";
2184 case VisibilityUnobscured: return "Unobscured";
2185 default: return "???";
2190 describe_event (XEvent *event)
2193 struct device *d = get_device_from_display (event->xany.display);
2195 sprintf (buf, "%s%s", x_event_name (event->type),
2196 event->xany.send_event ? " (send)" : "");
2197 stderr_out ("%-30s", buf);
2198 switch (event->type)
2203 XFocusChangeEvent *ev = &event->xfocus;
2204 describe_event_window (ev->window, ev->display);
2205 stderr_out (" mode: %s\n", XEvent_mode_to_string (ev->mode));
2206 stderr_out (" detail: %s\n", XEvent_detail_to_string(ev->detail));
2212 XKeyEvent *ev = &event->xkey;
2213 unsigned int state = ev->state;
2215 describe_event_window (ev->window, ev->display);
2216 stderr_out (" subwindow: %ld\n", ev->subwindow);
2217 stderr_out (" state: ");
2218 /* Complete list of modifier key masks */
2219 if (state & ShiftMask) stderr_out ("Shift ");
2220 if (state & LockMask) stderr_out ("Lock ");
2221 if (state & ControlMask) stderr_out ("Control ");
2222 if (state & Mod1Mask) stderr_out ("Mod1 ");
2223 if (state & Mod2Mask) stderr_out ("Mod2 ");
2224 if (state & Mod3Mask) stderr_out ("Mod3 ");
2225 if (state & Mod4Mask) stderr_out ("Mod4 ");
2226 if (state & Mod5Mask) stderr_out ("Mod5 ");
2229 stderr_out ("vanilla\n");
2232 if (x_key_is_modifier_p (ev->keycode, d))
2233 stderr_out (" Modifier key");
2234 stderr_out (" keycode: 0x%x\n", ev->keycode);
2239 if (x_debug_events > 1)
2241 XExposeEvent *ev = &event->xexpose;
2242 describe_event_window (ev->window, ev->display);
2243 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2244 ev->x, ev->y, ev->width, ev->height);
2245 stderr_out (" count: %d\n", ev->count);
2251 case GraphicsExpose:
2252 if (x_debug_events > 1)
2254 XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
2255 describe_event_window (ev->drawable, ev->display);
2256 stderr_out (" major: %s\n",
2257 (ev ->major_code == X_CopyArea ? "CopyArea" :
2258 (ev->major_code == X_CopyPlane ? "CopyPlane" : "?")));
2259 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2260 ev->x, ev->y, ev->width, ev->height);
2261 stderr_out (" count: %d\n", ev->count);
2269 if (x_debug_events > 1)
2271 XCrossingEvent *ev = &event->xcrossing;
2272 describe_event_window (ev->window, ev->display);
2274 stderr_out(" subwindow: 0x%x\n", ev->subwindow);
2275 stderr_out(" pos: %d %d\n", ev->x, ev->y);
2276 stderr_out(" root pos: %d %d\n", ev->x_root, ev->y_root);
2278 stderr_out(" mode: %s\n", XEvent_mode_to_string(ev->mode));
2279 stderr_out(" detail: %s\n", XEvent_detail_to_string(ev->detail));
2280 stderr_out(" focus: %d\n", ev->focus);
2282 stderr_out(" state: 0x%x\n", ev->state);
2289 case ConfigureNotify:
2290 if (x_debug_events > 1)
2292 XConfigureEvent *ev = &event->xconfigure;
2293 describe_event_window (ev->window, ev->display);
2294 stderr_out(" above: 0x%lx\n", ev->above);
2295 stderr_out(" size: %d %d %d %d\n", ev->x, ev->y,
2296 ev->width, ev->height);
2297 stderr_out(" redirect: %d\n", ev->override_redirect);
2303 case VisibilityNotify:
2304 if (x_debug_events > 1)
2306 XVisibilityEvent *ev = &event->xvisibility;
2307 describe_event_window (ev->window, ev->display);
2308 stderr_out(" state: %s\n", XEvent_visibility_to_string(ev->state));
2316 XClientMessageEvent *ev = &event->xclient;
2317 char *name = XGetAtomName (ev->display, ev->message_type);
2318 stderr_out ("%s", name);
2319 if (!strcmp (name, "WM_PROTOCOLS")) {
2320 char *protname = XGetAtomName (ev->display, ev->data.l[0]);
2321 stderr_out ("(%s)", protname);
2337 #endif /* include describe_event definition */
2340 /************************************************************************/
2341 /* get the next event from Xt */
2342 /************************************************************************/
2344 static Lisp_Object dispatch_event_queue, dispatch_event_queue_tail;
2347 enqueue_Xt_dispatch_event (Lisp_Object event)
2349 enqueue_event (event, &dispatch_event_queue, &dispatch_event_queue_tail);
2353 dequeue_Xt_dispatch_event (void)
2355 return dequeue_event (&dispatch_event_queue, &dispatch_event_queue_tail);
2358 /* This business exists because menu events "happen" when
2359 menubar_selection_callback() is called from somewhere deep
2360 within XtAppProcessEvent in emacs_Xt_next_event(). The
2361 callback needs to terminate the modal loop in that function
2362 or else it will continue waiting until another event is
2365 Same business applies to scrollbar events. */
2368 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
2371 Lisp_Object event = Fmake_event (Qnil, Qnil);
2373 XEVENT (event)->event_type = misc_user_event;
2374 XEVENT (event)->channel = channel;
2375 XEVENT (event)->event.eval.function = function;
2376 XEVENT (event)->event.eval.object = object;
2378 enqueue_Xt_dispatch_event (event);
2382 emacs_Xt_next_event (struct Lisp_Event *emacs_event)
2384 we_didnt_get_an_event:
2386 while (NILP (dispatch_event_queue) &&
2387 !completed_timeouts &&
2388 !fake_event_occurred &&
2389 !process_events_occurred &&
2390 !tty_events_occurred)
2393 /* Stupid logic in XtAppProcessEvent() dictates that, if process
2394 events and X events are both available, the process event gets
2395 taken first. This will cause an infinite loop if we're being
2396 called from Fdiscard_input().
2398 if (XtAppPending (Xt_app_con) & XtIMXEvent)
2399 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2402 Lisp_Object devcons, concons;
2404 /* We're about to block. Xt has a bug in it (big surprise,
2405 there) in that it blocks using select() and doesn't
2406 flush the Xlib output buffers (XNextEvent() does this
2407 automatically before blocking). So it's necessary
2408 for us to do this ourselves. If we don't do it, then
2409 display output may not be seen until the next time
2410 an X event is received. (This happens esp. with
2411 subprocess output that gets sent to a visible buffer.)
2413 #### The above comment may not have any validity. */
2415 DEVICE_LOOP_NO_BREAK (devcons, concons)
2418 d = XDEVICE (XCAR (devcons));
2420 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2421 /* emacs may be exiting */
2422 XFlush (DEVICE_X_DISPLAY (d));
2424 XtAppProcessEvent (Xt_app_con, XtIMAll);
2428 if (!NILP (dispatch_event_queue))
2430 Lisp_Object event, event2;
2431 XSETEVENT (event2, emacs_event);
2432 event = dequeue_Xt_dispatch_event ();
2433 Fcopy_event (event, event2);
2434 Fdeallocate_event (event);
2436 else if (tty_events_occurred)
2438 if (!Xt_tty_to_emacs_event (emacs_event))
2439 goto we_didnt_get_an_event;
2441 else if (completed_timeouts)
2442 Xt_timeout_to_emacs_event (emacs_event);
2443 else if (fake_event_occurred)
2445 /* A dummy event, so that a cycle of the command loop will occur. */
2446 fake_event_occurred = 0;
2447 /* eval events have nil as channel */
2448 emacs_event->event_type = eval_event;
2449 emacs_event->event.eval.function = Qidentity;
2450 emacs_event->event.eval.object = Qnil;
2452 else /* if (process_events_occurred) */
2453 Xt_process_to_emacs_event (emacs_event);
2455 /* No need to call XFilterEvent; Xt does it for us */
2459 emacs_Xt_event_handler (Widget wid /* unused */,
2460 XtPointer closure /* unused */,
2462 Boolean *continue_to_dispatch /* unused */)
2464 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
2467 if (x_debug_events > 0)
2469 describe_event (event);
2471 #endif /* DEBUG_XEMACS */
2472 if (x_event_to_emacs_event (event, XEVENT (emacs_event)))
2473 enqueue_Xt_dispatch_event (emacs_event);
2475 Fdeallocate_event (emacs_event);
2479 /************************************************************************/
2480 /* input pending / C-g checking */
2481 /************************************************************************/
2484 quit_char_predicate (Display *display, XEvent *event, XPointer data)
2486 struct device *d = get_device_from_display (display);
2487 struct x_device *xd = DEVICE_X_DATA (d);
2489 Bool *critical = (Bool *) data;
2494 if ((event->type != KeyPress) ||
2495 (! x_any_window_to_frame (d, event->xany.window)) ||
2497 & (xd->MetaMask | xd->HyperMask | xd->SuperMask | xd->AltMask)))
2500 /* This duplicates some code that exists elsewhere, but it's relatively
2501 fast and doesn't cons. */
2502 keysym = x_to_emacs_keysym (&event->xkey, 1);
2503 if (NILP (keysym)) return 0;
2504 if (CHAR_OR_CHAR_INTP (keysym))
2505 c = XCHAR_OR_CHAR_INT (keysym);
2506 /* Highly doubtful that these are the quit character, but... */
2507 else if (EQ (keysym, QKbackspace)) c = '\b';
2508 else if (EQ (keysym, QKtab)) c = '\t';
2509 else if (EQ (keysym, QKlinefeed)) c = '\n';
2510 else if (EQ (keysym, QKreturn)) c = '\r';
2511 else if (EQ (keysym, QKescape)) c = 27;
2512 else if (EQ (keysym, QKspace)) c = ' ';
2513 else if (EQ (keysym, QKdelete)) c = 127;
2516 if (event->xkey.state & xd->MetaMask) c |= 0x80;
2517 if ((event->xkey.state & ControlMask) && !(c >= 'A' && c <= 'Z'))
2518 c &= 0x1F; /* unshifted control characters */
2519 quit_char = CONSOLE_QUIT_CHAR (XCONSOLE (DEVICE_CONSOLE (d)));
2522 /* If we've got Control-Shift-G instead of Control-G, that means
2523 we have a critical_quit. Caps_Lock is its own modifier, so it
2524 won't cause ^G to act differently than before. */
2525 if (event->xkey.state & ControlMask) c &= 0x1F;
2528 if (critical) *critical = True;
2534 /* This scans the X input queue for a KeyPress event that matches the
2535 quit character, and sets Vquit_flag. This is called from the
2536 QUIT macro to determine whether we should quit.
2538 In a SIGIO world, this won't be called unless a SIGIO has happened
2539 since the last time we checked.
2541 In a non-SIGIO world, this is called from emacs_Xt_event_pending_p
2542 (which is called from input_pending_p).
2545 x_check_for_quit_char (Display *display)
2549 Bool critical_quit = False;
2550 XEventsQueued (display, QueuedAfterReading);
2551 queued = XCheckIfEvent (display, &event,
2552 quit_char_predicate,
2553 (char *) &critical_quit);
2556 Vquit_flag = (critical_quit ? Qcritical : Qt);
2557 /* don't put the event back onto the queue. Those functions that
2558 wanted to read a ^G directly have arranged to do this. */
2563 check_for_tty_quit_char (struct device *d)
2565 SELECT_TYPE temp_mask;
2566 int infd = DEVICE_INFD (d);
2567 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
2568 Emchar quit_char = CONSOLE_QUIT_CHAR (con);
2570 FD_ZERO (&temp_mask);
2571 FD_SET (infd, &temp_mask);
2578 if (!poll_fds_for_input (temp_mask))
2581 event = Fmake_event (Qnil, Qnil);
2582 if (!read_event_from_tty_or_stream_desc (XEVENT (event), con, infd))
2583 /* EOF, or something ... */
2585 /* #### bogus. quit-char should be allowed to be any sort
2587 the_char = event_to_character (XEVENT (event), 1, 0, 0);
2588 if (the_char >= 0 && the_char == quit_char)
2591 /* do not queue the C-g. See above. */
2595 /* queue the read event to be read for real later. */
2596 enqueue_Xt_dispatch_event (event);
2601 emacs_Xt_quit_p (void)
2603 Lisp_Object devcons, concons;
2604 CONSOLE_LOOP (concons)
2606 struct console *con = XCONSOLE (XCAR (concons));
2607 if (!con->input_enabled)
2610 CONSOLE_DEVICE_LOOP (devcons, con)
2613 d = XDEVICE (XCAR (devcons));
2615 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2616 /* emacs may be exiting */
2617 x_check_for_quit_char (DEVICE_X_DISPLAY (d));
2618 else if (DEVICE_TTY_P (d))
2619 check_for_tty_quit_char (d);
2625 drain_X_queue (void)
2627 while (XtAppPending (Xt_app_con) & XtIMXEvent)
2628 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2632 emacs_Xt_event_pending_p (int user_p)
2637 /* If `user_p' is false, then this function returns whether there are any
2638 X, timeout, or fd events pending (that is, whether emacs_Xt_next_event()
2639 would return immediately without blocking).
2641 if `user_p' is true, then this function returns whether there are any
2642 *user generated* events available (that is, whether there are keyboard
2643 or mouse-click events ready to be read). This also implies that
2644 emacs_Xt_next_event() would not block.
2646 In a non-SIGIO world, this also checks whether the user has typed ^G,
2647 since this is a convenient place to do so. We don't need to do this
2648 in a SIGIO world, since input causes an interrupt.
2652 /* I don't think there's any point to this and it will nullify
2653 the speed gains achieved by the sigio_happened checking below.
2654 Its only advantage is that it may possibly make C-g response
2655 a bit faster. The C-g will be noticed within 0.25 second, anyway,
2656 even without this. */
2658 /* First check for C-g if necessary */
2663 /* This function used to simply check whether there were any X
2664 events (or if user_p was 1, it iterated over all the pending
2665 X events using XCheckIfEvent(), looking for keystrokes and
2666 button events). That worked in the old cheesoid event loop,
2667 which didn't go through XtAppDispatchEvent(), but it doesn't
2668 work any more -- X events may not result in anything. For
2669 example, a button press in a blank part of the menubar appears
2670 as an X event but will not result in any Emacs events (a
2671 button press that activates the menubar results in an Emacs
2672 event through the stop_next_event mechanism).
2674 The only accurate way of determining whether these X events
2675 translate into Emacs events is to go ahead and dispatch them
2676 until there's something on the dispatch queue. */
2678 /* See if there are any user events already on the queue. */
2679 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2680 if (!user_p || command_event_p (event))
2683 /* See if there's any TTY input available.
2685 if (poll_fds_for_input (tty_only_mask))
2690 /* If not user_p and there are any timer or file-desc events
2691 pending, we know there will be an event so we're through. */
2692 XtInputMask pending_value;
2694 /* Note that formerly we just checked the value of XtAppPending()
2695 to determine if there was file-desc input. This doesn't
2696 work any more with the signal_event_pipe; XtAppPending()
2697 will says "yes" in this case but there isn't really any
2698 input. Another way of fixing this problem is for the
2699 signal_event_pipe to generate actual input in the form
2700 of an identity eval event or something. (#### maybe this
2701 actually happens?) */
2703 if (poll_fds_for_input (process_only_mask))
2706 pending_value = XtAppPending (Xt_app_con);
2708 if (pending_value & XtIMTimer)
2712 /* XtAppPending() can be super-slow, esp. over a network connection.
2713 Quantify results have indicated that in some cases the
2714 call to detect_input_pending() completely dominates the
2715 running time of redisplay(). Fortunately, in a SIGIO world
2716 we can more quickly determine whether there are any X events:
2717 if an event has happened since the last time we checked, then
2718 a SIGIO will have happened. On a machine with broken SIGIO,
2719 we'll still be in an OK state -- the sigio_happened flag
2720 will get set at least once a second, so we'll be no more than
2721 one second behind reality. (In general it's OK if we
2722 erroneously report no input pending when input is actually
2723 pending() -- preemption is just a bit less efficient, that's
2724 all. It's bad bad bad if you err the other way -- you've
2725 promised that `next-event' won't block but it actually will,
2726 and some action might get delayed until the next time you
2730 /* quit_check_signal_tick_count is volatile so try to avoid race conditions
2731 by using a temporary variable */
2732 tick_count_val = quit_check_signal_tick_count;
2733 if (last_quit_check_signal_tick_count != tick_count_val)
2735 last_quit_check_signal_tick_count = tick_count_val;
2737 /* We need to drain the entire queue now -- if we only
2738 drain part of it, we may later on end up with events
2739 actually pending but detect_input_pending() returning
2740 false because there wasn't another SIGIO. */
2743 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2744 if (!user_p || command_event_p (event))
2752 /************************************************************************/
2753 /* replacement for standard string-to-pixel converter */
2754 /************************************************************************/
2756 /* This was constructed by ripping off the standard string-to-pixel
2757 converter from Converters.c in the Xt source code and modifying
2762 /* This is exported by the Xt library (at least by mine). If this
2763 isn't the case somewhere, rename this appropriately and remove
2764 the '#if 0'. Note, however, that I got "unknown structure"
2765 errors when I tried this. */
2766 XtConvertArgRec Const colorConvertArgs[] = {
2767 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
2769 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
2775 #define done(type, value) \
2776 if (toVal->addr != NULL) { \
2777 if (toVal->size < sizeof(type)) { \
2778 toVal->size = sizeof(type); \
2781 *(type*)(toVal->addr) = (value); \
2783 static type static_val; \
2784 static_val = (value); \
2785 toVal->addr = (XPointer)&static_val; \
2787 toVal->size = sizeof(type); \
2788 return True /* Caller supplies `;' */
2790 /* JH: We use this because I think there's a possibility this
2791 is called before the device is properly set up, in which case
2792 I don't want to abort. */
2793 extern struct device *get_device_from_display_1 (Display *dpy);
2796 Boolean EmacsXtCvtStringToPixel (
2800 XrmValuePtr fromVal,
2802 XtPointer *closure_ret)
2804 String str = (String)fromVal->addr;
2813 Cardinal num_params = 1;
2814 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
2816 if (*num_args != 2) {
2817 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
2819 "String to pixel conversion needs screen and colormap arguments",
2820 (String *)NULL, (Cardinal *)NULL);
2824 screen = *((Screen **) args[0].addr);
2825 colormap = *((Colormap *) args[1].addr);
2827 /* The original uses the private function CompareISOLatin1().
2828 Use XmuCompareISOLatin1() if you want, but I don't think it
2829 makes any difference here. */
2830 if (strcmp(str, XtDefaultBackground) == 0) {
2831 *closure_ret = False;
2832 /* This refers to the display's "*reverseVideo" resource.
2833 These display resources aren't documented anywhere that
2834 I can find, so I'm going to ignore this. */
2835 /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */
2836 done(Pixel, WhitePixelOfScreen(screen));
2838 if (strcmp(str, XtDefaultForeground) == 0) {
2839 *closure_ret = False;
2840 /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */
2841 done(Pixel, BlackPixelOfScreen(screen));
2844 /* Originally called XAllocNamedColor() here. */
2845 if ((d = get_device_from_display_1(dpy))) {
2846 visual = DEVICE_X_VISUAL(d);
2847 if (colormap != DEVICE_X_COLORMAP(d)) {
2848 XtAppWarningMsg(the_app_con, "wierdColormap", "cvtStringToPixel",
2850 "The colormap passed to cvtStringToPixel doesn't match the one registerd to the device.\n",
2852 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2854 status = XParseColor (dpy, colormap, (char*)str, &screenColor);
2856 status = allocate_nearest_color (dpy, colormap, visual, &screenColor);
2860 /* We haven't set up this device totally yet, so just punt */
2861 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2865 /* Server returns a specific error code but Xlib discards it. Ugh */
2866 if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
2867 &exactColor, &screenColor)) {
2868 XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
2870 "Cannot allocate colormap entry for \"%s\"",
2871 params, &num_params);
2874 XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
2876 "Color name \"%s\" is not defined", params, &num_params);
2879 *closure_ret = False;
2882 *closure_ret = (char*)True;
2883 done(Pixel, screenColor.pixel);
2888 static void EmacsFreePixel (
2895 if (*num_args != 2) {
2896 XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError",
2897 "Freeing a pixel requires screen and colormap arguments",
2898 (String *)NULL, (Cardinal *)NULL);
2903 Screen *screen = *((Screen **) args[0].addr);
2904 Colormap colormap = *((Colormap *) args[1].addr);
2905 XFreeColors(DisplayOfScreen(screen), colormap,
2906 (unsigned long*)toVal->addr, 1, (unsigned long)0);
2911 /************************************************************************/
2912 /* initialization */
2913 /************************************************************************/
2916 syms_of_event_Xt (void)
2918 defsymbol (&Qkey_mapping, "key-mapping");
2919 defsymbol (&Qsans_modifiers, "sans-modifiers");
2923 vars_of_event_Xt (void)
2925 dispatch_event_queue = Qnil;
2926 staticpro (&dispatch_event_queue);
2927 dispatch_event_queue_tail = Qnil;
2929 /* this function only makes safe calls */
2930 init_what_input_once ();
2932 Xt_event_stream = xnew (struct event_stream);
2933 Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p;
2934 Xt_event_stream->next_event_cb = emacs_Xt_next_event;
2935 Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
2936 Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout;
2937 Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout;
2938 Xt_event_stream->select_console_cb = emacs_Xt_select_console;
2939 Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console;
2940 Xt_event_stream->select_process_cb = emacs_Xt_select_process;
2941 Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process;
2942 Xt_event_stream->quit_p_cb = emacs_Xt_quit_p;
2943 Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
2944 Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
2946 DEFVAR_BOOL ("modifier-keys-are-sticky", &modifier_keys_are_sticky /*
2947 *Non-nil makes modifier keys sticky.
2948 This means that you can release the modifier key before pressing down
2949 the key that you wish to be modified. Although this is non-standard
2950 behavior, it is recommended because it reduces the strain on your hand,
2951 thus reducing the incidence of the dreaded Emacs-pinky syndrome.
2953 modifier_keys_are_sticky = 0;
2955 DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /*
2956 *Non-nil means to allow synthetic events. Nil means they are ignored.
2957 Beware: allowing emacs to process SendEvents opens a big security hole.
2959 x_allow_sendevents = 0;
2962 DEFVAR_INT ("x-debug-events", &x_debug_events /*
2963 If non-zero, display debug information about X events that XEmacs sees.
2964 Information is displayed on stderr. Currently defined values are:
2966 1 == non-verbose output
2972 the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
2974 last_quit_check_signal_tick_count = 0;
2977 /* This mess is a hack that patches the shell widget to treat visual inheritance
2978 the same as colormap and depth inheritance */
2980 static XtInitProc orig_shell_init_proc;
2982 static void ShellVisualPatch(Widget wanted, Widget new,
2983 ArgList args, Cardinal *num_args)
2986 ShellWidget w = (ShellWidget) new;
2988 /* first, call the original setup */
2989 (*orig_shell_init_proc)(wanted, new, args, num_args);
2991 /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */
2992 if (w->shell.visual == CopyFromParent) {
2994 while (p && !XtIsShell(p)) p = XtParent(p);
2995 if (p) w->shell.visual = ((ShellWidget)p)->shell.visual;
3000 init_event_Xt_late (void) /* called when already initialized */
3002 timeout_id_tick = 1;
3003 pending_timeouts = 0;
3004 completed_timeouts = 0;
3006 event_stream = Xt_event_stream;
3008 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
3009 Initialize_Locale();
3010 #endif /* HAVE_XIM || USE_XFONTSET */
3012 XtToolkitInitialize ();
3013 Xt_app_con = XtCreateApplicationContext ();
3014 XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
3017 x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
3018 XSetErrorHandler (x_error_handler);
3019 XSetIOErrorHandler (x_IO_error_handler);
3022 XtAppAddInput (Xt_app_con, signal_event_pipe[0],
3023 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
3024 Xt_what_callback, 0);
3027 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel,
3028 EmacsXtCvtStringToPixel,
3029 (XtConvertArgList) colorConvertArgs,
3030 2, XtCacheByDisplay, EmacsFreePixel);
3033 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
3034 EmacsXtCvtStringToXIMStyles,
3036 XtCacheByDisplay, EmacsFreeXIMStyles);
3037 #endif /* XIM_XLIB */
3039 /* insert the visual inheritance patch/hack described above */
3040 orig_shell_init_proc = shellClassRec.core_class.initialize;
3041 shellClassRec.core_class.initialize = ShellVisualPatch;