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)
68 #include "events-mod.h"
70 void enqueue_focus_event (Widget wants_it, Lisp_Object frame, int in_p);
71 static void handle_focus_event_1 (struct frame *f, int in_p);
72 static void handle_focus_event_2 (Window w, struct frame *f, int in_p);
74 static struct event_stream *Xt_event_stream;
76 /* With the new event model, all events go through XtDispatchEvent()
77 and are picked up by an event handler that is added to each frame
78 widget. (This is how it's supposed to be.) In the old method,
79 Emacs sucks out events directly from XtNextEvent() and only
80 dispatches the events that it doesn't need to deal with. This
81 old way has lots of corresponding junk that is no longer
82 necessary: lwlib extensions, synthetic XAnyEvents, unnecessary
85 /* The one and only one application context that Emacs uses. */
86 XtAppContext Xt_app_con;
88 /* Do we accept events sent by other clients? */
89 int x_allow_sendevents;
92 Fixnum debug_x_events;
95 static int process_events_occurred;
96 static int tty_events_occurred;
97 static Widget widget_with_focus;
99 /* Mask of bits indicating the descriptors that we wait for input on */
100 extern SELECT_TYPE input_wait_mask, process_only_mask, tty_only_mask;
102 static const String x_fallback_resources[] =
104 /* This file is automatically generated from the app-defaults file
105 in ../etc/Emacs.ad. These resources are consulted only if no
106 app-defaults file is found at all.
108 #include <Emacs.ad.h>
112 static Lisp_Object x_keysym_to_emacs_keysym (KeySym keysym, int simple_p);
113 void emacs_Xt_mapping_action (Widget w, XEvent *event);
114 void debug_process_finalization (Lisp_Process *p);
115 void emacs_Xt_event_handler (Widget wid, XtPointer closure, XEvent *event,
116 Boolean *continue_to_dispatch);
118 static int last_quit_check_signal_tick_count;
120 Lisp_Object Qkey_mapping;
121 Lisp_Object Qsans_modifiers;
124 /************************************************************************/
125 /* keymap handling */
126 /************************************************************************/
128 /* X bogusly doesn't define the interpretations of any bits besides
129 ModControl, ModShift, and ModLock; so the Interclient Communication
130 Conventions Manual says that we have to bend over backwards to figure
131 out what the other modifier bits mean. According to ICCCM:
133 - Any keycode which is assigned ModControl is a "control" key.
135 - Any modifier bit which is assigned to a keycode which generates Meta_L
136 or Meta_R is the modifier bit meaning "meta". Likewise for Super, Hyper,
139 - Any keypress event which contains ModControl in its state should be
140 interpreted as a "control" character.
142 - Any keypress event which contains a modifier bit in its state which is
143 generated by a keycode whose corresponding keysym is Meta_L or Meta_R
144 should be interpreted as a "meta" character. Likewise for Super, Hyper,
147 - It is illegal for a keysym to be associated with more than one modifier
150 This means that the only thing that emacs can reasonably interpret as a
151 "meta" key is a key whose keysym is Meta_L or Meta_R, and which generates
152 one of the modifier bits Mod1-Mod5.
154 Unfortunately, many keyboards don't have Meta keys in their default
155 configuration. So, if there are no Meta keys, but there are "Alt" keys,
156 emacs will interpret Alt as Meta. If there are both Meta and Alt keys,
157 then the Meta keys mean "Meta", and the Alt keys mean "Alt" (it used to
158 mean "Symbol," but that just confused the hell out of way too many people).
160 This works with the default configurations of the 19 keyboard-types I've
163 Emacs detects keyboard configurations which violate the above rules, and
164 prints an error message on the standard-error-output. (Perhaps it should
165 use a pop-up-window instead.)
168 /* For every key on the keyboard that has a known character correspondence,
169 we define the ascii-character property of the keysym, and make the
170 default binding for the key be self-insert-command.
172 The following magic is basically intimate knowledge of X11/keysymdef.h.
173 The keysym mappings defined by X11 are based on the iso8859 standards,
174 except for Cyrillic and Greek.
176 In a non-Mule world, a user can still have a multi-lingual editor, by doing
177 (set-face-font "...-iso8859-2" (current-buffer))
178 for all their Latin-2 buffers, etc. */
181 x_keysym_to_character (KeySym keysym)
184 Lisp_Object charset = Qzero;
185 #define USE_CHARSET(var,cs) \
186 ((var) = CHARSET_BY_LEADING_BYTE (LEADING_BYTE_##cs))
188 #define USE_CHARSET(var,lb)
192 if ((keysym & 0xff) < 0xa0)
197 case 0: /* ASCII + Latin1 */
198 USE_CHARSET (charset, LATIN_ISO8859_1);
199 code = keysym & 0x7f;
202 USE_CHARSET (charset, LATIN_ISO8859_2);
203 code = keysym & 0x7f;
206 USE_CHARSET (charset, LATIN_ISO8859_3);
207 code = keysym & 0x7f;
210 USE_CHARSET (charset, LATIN_ISO8859_4);
211 code = keysym & 0x7f;
213 case 4: /* Katakana */
214 USE_CHARSET (charset, KATAKANA_JISX0201);
215 if ((keysym & 0xff) > 0xa0)
216 code = keysym & 0x7f;
219 USE_CHARSET (charset, ARABIC_ISO8859_6);
220 code = keysym & 0x7f;
222 case 6: /* Cyrillic */
224 static unsigned char const cyrillic[] = /* 0x20 - 0x7f */
225 {0x00, 0x72, 0x73, 0x71, 0x74, 0x75, 0x76, 0x77,
226 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x00, 0x7e, 0x7f,
227 0x70, 0x22, 0x23, 0x21, 0x24, 0x25, 0x26, 0x27,
228 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x00, 0x2e, 0x2f,
229 0x6e, 0x50, 0x51, 0x66, 0x54, 0x55, 0x64, 0x53,
230 0x65, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e,
231 0x5f, 0x6f, 0x60, 0x61, 0x62, 0x63, 0x56, 0x52,
232 0x6c, 0x6b, 0x57, 0x68, 0x6d, 0x69, 0x67, 0x6a,
233 0x4e, 0x30, 0x31, 0x46, 0x34, 0x35, 0x44, 0x33,
234 0x45, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
235 0x3f, 0x4f, 0x40, 0x41, 0x42, 0x43, 0x36, 0x32,
236 0x4c, 0x4b, 0x37, 0x48, 0x4d, 0x49, 0x47, 0x4a};
237 USE_CHARSET (charset, CYRILLIC_ISO8859_5);
238 code = cyrillic[(keysym & 0x7f) - 0x20];
243 static unsigned char const greek[] = /* 0x20 - 0x7f */
244 {0x00, 0x36, 0x38, 0x39, 0x3a, 0x5a, 0x00, 0x3c,
245 0x3e, 0x5b, 0x00, 0x3f, 0x00, 0x00, 0x35, 0x2f,
246 0x00, 0x5c, 0x5d, 0x5e, 0x5f, 0x7a, 0x40, 0x7c,
247 0x7d, 0x7b, 0x60, 0x7e, 0x00, 0x00, 0x00, 0x00,
248 0x00, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
249 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
250 0x50, 0x51, 0x53, 0x00, 0x54, 0x55, 0x56, 0x57,
251 0x58, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
253 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
254 0x70, 0x71, 0x73, 0x72, 0x74, 0x75, 0x76, 0x77,
255 0x78, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
256 USE_CHARSET (charset, GREEK_ISO8859_7);
257 code = greek[(keysym & 0x7f) - 0x20];
260 case 8: /* Technical */
262 case 9: /* Special */
264 case 10: /* Publishing */
268 case 12: /* Hebrew */
269 USE_CHARSET (charset, HEBREW_ISO8859_8);
270 code = keysym & 0x7f;
273 /* #### This needs to deal with character composition. */
274 USE_CHARSET (charset, THAI_TIS620);
275 code = keysym & 0x7f;
277 case 14: /* Korean Hangul */
279 case 19: /* Latin 9 - ISO8859-15 - unsupported charset. */
281 case 32: /* Currency */
291 return make_char (MAKE_CHAR (charset, code, 0));
293 return make_char (code + 0x80);
297 /* #### The way that keysym correspondence to characters should work:
298 - a Lisp_Event should contain a keysym AND a character slot.
299 - keybindings are tried with the keysym. If no binding can be found,
300 and there is a corresponding character, call self-insert-command.
302 #### Nuke x-iso8859-1.el.
303 #### Nuke the Qascii_character property.
304 #### Nuke Vcharacter_set_property.
307 maybe_define_x_key_as_self_inserting_character (KeySym keysym, Lisp_Object symbol)
309 Lisp_Object character = x_keysym_to_character (keysym);
311 if (CHARP (character))
313 extern Lisp_Object Vcurrent_global_map;
314 extern Lisp_Object Qascii_character;
315 if (NILP (Flookup_key (Vcurrent_global_map, symbol, Qnil)))
317 Fput (symbol, Qascii_character, character);
318 Fdefine_key (Vcurrent_global_map, symbol, Qself_insert_command);
324 x_has_keysym (KeySym keysym, Lisp_Object hash_table, int with_modifiers)
326 KeySym upper_lower[2];
329 if (keysym < 0x80) /* Optimize for ASCII keysyms */
333 xmodmap -e 'keysym NN = scaron'
334 and then press (Shift scaron), X11 will return the different
335 keysym `Scaron', but `xmodmap -pke' might not even mention `Scaron'.
336 So we "register" both `scaron' and `Scaron'. */
337 #ifdef HAVE_XCONVERTCASE
338 XConvertCase (keysym, &upper_lower[0], &upper_lower[1]);
340 upper_lower[0] = upper_lower[1] = keysym;
343 for (j = 0; j < (upper_lower[0] == upper_lower[1] ? 1 : 2); j++)
346 keysym = upper_lower[j];
348 name = XKeysymToString (keysym);
351 /* X guarantees NAME to be in the Host Portable Character Encoding */
352 Lisp_Object sym = x_keysym_to_emacs_keysym (keysym, 0);
353 Lisp_Object new_value = with_modifiers ? Qt : Qsans_modifiers;
354 Lisp_Object old_value = Fgethash (sym, hash_table, Qnil);
356 if (! EQ (old_value, new_value)
357 && ! (EQ (old_value, Qsans_modifiers) &&
360 maybe_define_x_key_as_self_inserting_character (keysym, sym);
361 Fputhash (build_ext_string (name, Qbinary), new_value, hash_table);
362 Fputhash (sym, new_value, hash_table);
369 x_reset_key_mapping (struct device *d)
371 Display *display = DEVICE_X_DISPLAY (d);
372 struct x_device *xd = DEVICE_X_DATA (d);
373 KeySym *keysym, *keysym_end;
374 Lisp_Object hash_table;
375 int key_code_count, keysyms_per_code;
377 if (xd->x_keysym_map)
378 XFree ((char *) xd->x_keysym_map);
379 XDisplayKeycodes (display,
380 &xd->x_keysym_map_min_code,
381 &xd->x_keysym_map_max_code);
382 key_code_count = xd->x_keysym_map_max_code - xd->x_keysym_map_min_code + 1;
384 XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count,
385 &xd->x_keysym_map_keysyms_per_code);
387 hash_table = xd->x_keysym_map_hash_table;
388 if (HASH_TABLEP (hash_table))
389 Fclrhash (hash_table);
391 xd->x_keysym_map_hash_table = hash_table =
392 make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
394 for (keysym = xd->x_keysym_map,
395 keysyms_per_code = xd->x_keysym_map_keysyms_per_code,
396 keysym_end = keysym + (key_code_count * keysyms_per_code);
398 keysym += keysyms_per_code)
402 if (keysym[0] == NoSymbol)
405 x_has_keysym (keysym[0], hash_table, 0);
407 for (j = 1; j < keysyms_per_code; j++)
409 if (keysym[j] != keysym[0] &&
410 keysym[j] != NoSymbol)
411 x_has_keysym (keysym[j], hash_table, 1);
417 index_to_name (int indice)
421 case ShiftMapIndex: return "ModShift";
422 case LockMapIndex: return "ModLock";
423 case ControlMapIndex: return "ModControl";
424 case Mod1MapIndex: return "Mod1";
425 case Mod2MapIndex: return "Mod2";
426 case Mod3MapIndex: return "Mod3";
427 case Mod4MapIndex: return "Mod4";
428 case Mod5MapIndex: return "Mod5";
429 default: return "???";
433 /* Boy, I really wish C had local functions... */
434 struct c_doesnt_have_closures /* #### not yet used */
436 int warned_about_overlapping_modifiers;
437 int warned_about_predefined_modifiers;
438 int warned_about_duplicate_modifiers;
447 x_reset_modifier_mapping (struct device *d)
449 Display *display = DEVICE_X_DISPLAY (d);
450 struct x_device *xd = DEVICE_X_DATA (d);
451 int modifier_index, modifier_key, column, mkpm;
452 int warned_about_overlapping_modifiers = 0;
453 int warned_about_predefined_modifiers = 0;
454 int warned_about_duplicate_modifiers = 0;
461 xd->lock_interpretation = 0;
463 if (xd->x_modifier_keymap)
465 XFreeModifiermap (xd->x_modifier_keymap);
466 /* Set it to NULL in case we receive two MappingModifier events in a
467 row, and the second is processed during some CHECK_QUITs within
468 x_reset_key_mapping. If that happens, XFreeModifierMap will be
469 called twice on the same map, and we crash. */
470 xd->x_modifier_keymap = NULL;
473 x_reset_key_mapping (d);
475 xd->x_modifier_keymap = XGetModifierMapping (display);
477 /* Boy, I really wish C had local functions...
480 /* The call to warn_when_safe must be on the same line as the string or
481 make-msgfile won't pick it up properly (the newline doesn't confuse
482 it, but the backslash does). */
484 #define modwarn(name,old,other) \
485 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is generated by %s.", \
486 name, code, index_to_name (old), other), \
487 warned_about_overlapping_modifiers = 1
489 #define modbarf(name,other) \
490 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
491 name, code, other), \
492 warned_about_predefined_modifiers = 1
494 #define check_modifier(name,mask) \
495 if ((1<<modifier_index) != mask) \
496 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates %s, which is nonsensical.", \
497 name, code, index_to_name (modifier_index)), \
498 warned_about_predefined_modifiers = 1
500 #define store_modifier(name,old) \
501 if (old && old != modifier_index) \
502 warn_when_safe (Qkey_mapping, Qwarning, "XEmacs: %s (0x%x) generates both %s and %s, which is nonsensical.",\
503 name, code, index_to_name (old), \
504 index_to_name (modifier_index)), \
505 warned_about_duplicate_modifiers = 1; \
506 if (modifier_index == ShiftMapIndex) modbarf (name,"ModShift"); \
507 else if (modifier_index == LockMapIndex) modbarf (name,"ModLock"); \
508 else if (modifier_index == ControlMapIndex) modbarf (name,"ModControl"); \
509 else if (sym == XK_Mode_switch) \
510 mode_bit = modifier_index; /* Mode_switch is special, see below... */ \
511 else if (modifier_index == meta_bit && old != meta_bit) \
512 modwarn (name, meta_bit, "Meta"); \
513 else if (modifier_index == super_bit && old != super_bit) \
514 modwarn (name, super_bit, "Super"); \
515 else if (modifier_index == hyper_bit && old != hyper_bit) \
516 modwarn (name, hyper_bit, "Hyper"); \
517 else if (modifier_index == alt_bit && old != alt_bit) \
518 modwarn (name, alt_bit, "Alt"); \
520 old = modifier_index;
522 mkpm = xd->x_modifier_keymap->max_keypermod;
523 for (modifier_index = 0; modifier_index < 8; modifier_index++)
524 for (modifier_key = 0; modifier_key < mkpm; modifier_key++) {
526 for (column = 0; column < 4; column += 2) {
527 KeyCode code = xd->x_modifier_keymap->modifiermap[modifier_index * mkpm
529 KeySym sym = (code ? XKeycodeToKeysym (display, code, column) : 0);
530 if (sym == last_sym) continue;
533 case XK_Mode_switch:store_modifier ("Mode_switch", mode_bit); break;
534 case XK_Meta_L: store_modifier ("Meta_L", meta_bit); break;
535 case XK_Meta_R: store_modifier ("Meta_R", meta_bit); break;
536 case XK_Super_L: store_modifier ("Super_L", super_bit); break;
537 case XK_Super_R: store_modifier ("Super_R", super_bit); break;
538 case XK_Hyper_L: store_modifier ("Hyper_L", hyper_bit); break;
539 case XK_Hyper_R: store_modifier ("Hyper_R", hyper_bit); break;
540 case XK_Alt_L: store_modifier ("Alt_L", alt_bit); break;
541 case XK_Alt_R: store_modifier ("Alt_R", alt_bit); break;
542 case XK_Control_L: check_modifier ("Control_L", ControlMask); break;
543 case XK_Control_R: check_modifier ("Control_R", ControlMask); break;
544 case XK_Shift_L: check_modifier ("Shift_L", ShiftMask); break;
545 case XK_Shift_R: check_modifier ("Shift_R", ShiftMask); break;
546 case XK_Shift_Lock: check_modifier ("Shift_Lock", LockMask);
547 xd->lock_interpretation = XK_Shift_Lock; break;
548 case XK_Caps_Lock: check_modifier ("Caps_Lock", LockMask);
549 xd->lock_interpretation = XK_Caps_Lock; break;
551 /* It probably doesn't make any sense for a modifier bit to be
552 assigned to a key that is not one of the above, but OpenWindows
553 assigns modifier bits to a couple of random function keys for
554 no reason that I can discern, so printing a warning here would
559 #undef store_modifier
560 #undef check_modifier
564 /* If there was no Meta key, then try using the Alt key instead.
565 If there is both a Meta key and an Alt key, then the Alt key
566 is not disturbed and remains an Alt key. */
567 if (! meta_bit && alt_bit)
568 meta_bit = alt_bit, alt_bit = 0;
570 /* mode_bit overrides everything, since it's processed down inside of
571 XLookupString() instead of by us. If Meta and Mode_switch both
572 generate the same modifier bit (which is an error), then we don't
573 interpret that bit as Meta, because we can't make XLookupString()
574 not interpret it as Mode_switch; and interpreting it as both would
578 const char *warn = 0;
579 if (mode_bit == meta_bit) warn = "Meta", meta_bit = 0;
580 else if (mode_bit == hyper_bit) warn = "Hyper", hyper_bit = 0;
581 else if (mode_bit == super_bit) warn = "Super", super_bit = 0;
582 else if (mode_bit == alt_bit) warn = "Alt", alt_bit = 0;
586 (Qkey_mapping, Qwarning,
587 "XEmacs: %s is being used for both Mode_switch and %s.",
588 index_to_name (mode_bit), warn),
589 warned_about_overlapping_modifiers = 1;
594 xd->MetaMask = (meta_bit ? (1 << meta_bit) : 0);
595 xd->HyperMask = (hyper_bit ? (1 << hyper_bit) : 0);
596 xd->SuperMask = (super_bit ? (1 << super_bit) : 0);
597 xd->AltMask = (alt_bit ? (1 << alt_bit) : 0);
598 xd->ModeMask = (mode_bit ? (1 << mode_bit) : 0); /* unused */
601 if (warned_about_overlapping_modifiers)
602 warn_when_safe (Qkey_mapping, Qwarning, "\n"
603 " Two distinct modifier keys (such as Meta and Hyper) cannot generate\n"
604 " the same modifier bit, because Emacs won't be able to tell which\n"
605 " modifier was actually held down when some other key is pressed. It\n"
606 " won't be able to tell Meta-x and Hyper-x apart, for example. Change\n"
607 " one of these keys to use some other modifier bit. If you intend for\n"
608 " these keys to have the same behavior, then change them to have the\n"
609 " same keysym as well as the same modifier bit.");
611 if (warned_about_predefined_modifiers)
612 warn_when_safe (Qkey_mapping, Qwarning, "\n"
613 " The semantics of the modifier bits ModShift, ModLock, and ModControl\n"
614 " are predefined. It does not make sense to assign ModControl to any\n"
615 " keysym other than Control_L or Control_R, or to assign any modifier\n"
616 " bits to the \"control\" keysyms other than ModControl. You can't\n"
617 " turn a \"control\" key into a \"meta\" key (or vice versa) by simply\n"
618 " assigning the key a different modifier bit. You must also make that\n"
619 " key generate an appropriate keysym (Control_L, Meta_L, etc).");
621 /* No need to say anything more for warned_about_duplicate_modifiers. */
623 if (warned_about_overlapping_modifiers || warned_about_predefined_modifiers)
624 warn_when_safe (Qkey_mapping, Qwarning, "\n"
625 " The meanings of the modifier bits Mod1 through Mod5 are determined\n"
626 " by the keysyms used to control those bits. Mod1 does NOT always\n"
627 " mean Meta, although some non-ICCCM-compliant programs assume that.");
631 x_init_modifier_mapping (struct device *d)
633 struct x_device *xd = DEVICE_X_DATA (d);
634 xd->x_keysym_map_hash_table = Qnil;
635 xd->x_keysym_map = NULL;
636 xd->x_modifier_keymap = NULL;
637 x_reset_modifier_mapping (d);
641 x_key_is_modifier_p (KeyCode keycode, struct device *d)
643 struct x_device *xd = DEVICE_X_DATA (d);
647 if (keycode < xd->x_keysym_map_min_code ||
648 keycode > xd->x_keysym_map_max_code)
651 syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
652 xd->x_keysym_map_keysyms_per_code];
653 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
654 if (IsModifierKey (syms [i]) ||
655 syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */
660 /* key-handling code is always ugly. It just ends up working out
663 Here are some pointers:
665 -- DOWN_MASK indicates which modifiers should be treated as "down"
666 when the corresponding upstroke happens. It gets reset for
667 a particular modifier when that modifier goes up, and reset
668 for all modifiers when a non-modifier key is pressed. Example:
670 I press Control-A-Shift and then release Control-A-Shift.
671 I want the Shift key to be sticky but not the Control key.
673 -- LAST_DOWNKEY and RELEASE_TIME are used to keep track of
674 auto-repeat -- see below.
676 -- If a modifier key is sticky, I can unstick it by pressing
677 the modifier key again. */
680 x_handle_sticky_modifiers (XEvent *ev, struct device *d)
686 if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */
689 xd = DEVICE_X_DATA (d);
690 keycode = ev->xkey.keycode;
693 if (keycode < xd->x_keysym_map_min_code ||
694 keycode > xd->x_keysym_map_max_code)
697 if (! ((type == KeyPress || type == KeyRelease) &&
698 x_key_is_modifier_p (keycode, d)))
699 { /* Not a modifier key */
700 Bool key_event_p = (type == KeyPress || type == KeyRelease);
702 if (type == ButtonPress
704 && ((xd->last_downkey
705 && ((keycode != xd->last_downkey
706 || ev->xkey.time != xd->release_time)))
707 || (INTP (Vmodifier_keys_sticky_time)
709 > (xd->modifier_release_time
710 + XINT (Vmodifier_keys_sticky_time))))))
712 xd->need_to_add_mask = 0;
713 xd->last_downkey = 0;
715 else if (type == KeyPress && !xd->last_downkey)
716 xd->last_downkey = keycode;
718 if (type == KeyPress)
719 xd->release_time = 0;
720 if (type == KeyPress || type == ButtonPress)
723 xd->modifier_release_time = 0;
727 ev->xkey.state |= xd->need_to_add_mask;
729 ev->xbutton.state |= xd->need_to_add_mask;
731 if (type == KeyRelease && keycode == xd->last_downkey)
732 /* If I hold press-and-release the Control key and then press
733 and hold down the right arrow, I want it to auto-repeat
734 Control-Right. On the other hand, if I do the same but
735 manually press the Right arrow a bunch of times, I want
736 to see one Control-Right and then a bunch of Rights.
737 This means that we need to distinguish between an
738 auto-repeated key and a key pressed and released a bunch
741 Naturally, the designers of the X spec didn't see fit
742 to provide an obvious way to distinguish these cases.
743 So we assume that if the release and the next press
744 occur at the same time, the key was actually auto-
745 repeated. Under Open-Windows, at least, this works. */
746 xd->modifier_release_time = xd->release_time
747 = key_event_p ? ev->xkey.time : ev->xbutton.time;
749 else /* Modifier key pressed */
752 KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
753 xd->x_keysym_map_keysyms_per_code];
755 /* If a non-modifier key was pressed in the middle of a bunch
756 of modifiers, then it unsticks all the modifiers that were
757 previously pressed. We cannot unstick the modifiers until
758 now because we want to check for auto-repeat of the
761 if (xd->last_downkey)
763 xd->last_downkey = 0;
764 xd->need_to_add_mask = 0;
767 if (xd->modifier_release_time
768 && INTP (Vmodifier_keys_sticky_time)
770 > xd->modifier_release_time + XINT (Vmodifier_keys_sticky_time)))
772 xd->need_to_add_mask = 0;
778 if (type == KeyPress) \
780 /* If modifier key is already sticky, \
781 then unstick it. Note that we do \
782 not test down_mask to deal with the \
783 unlikely but possible case that the \
784 modifier key auto-repeats. */ \
785 if (xd->need_to_add_mask & mask) \
787 xd->need_to_add_mask &= ~mask; \
788 xd->down_mask &= ~mask; \
791 xd->down_mask |= mask; \
795 if (xd->down_mask & mask) \
797 xd->down_mask &= ~mask; \
798 xd->need_to_add_mask |= mask; \
801 xd->modifier_release_time = ev->xkey.time; \
804 for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
807 case XK_Control_L: case XK_Control_R: FROB (ControlMask); break;
808 case XK_Shift_L: case XK_Shift_R: FROB (ShiftMask); break;
809 case XK_Meta_L: case XK_Meta_R: FROB (xd->MetaMask); break;
810 case XK_Super_L: case XK_Super_R: FROB (xd->SuperMask); break;
811 case XK_Hyper_L: case XK_Hyper_R: FROB (xd->HyperMask); break;
812 case XK_Alt_L: case XK_Alt_R: FROB (xd->AltMask); break;
819 clear_sticky_modifiers (struct device *d)
821 struct x_device *xd = DEVICE_X_DATA (d);
823 xd->need_to_add_mask = 0;
824 xd->last_downkey = 0;
825 xd->release_time = 0;
830 keysym_obeys_caps_lock_p (KeySym sym, struct device *d)
832 struct x_device *xd = DEVICE_X_DATA (d);
833 /* Eeeeevil hack. Don't apply Caps_Lock to things that aren't alphabetic
834 characters, where "alphabetic" means something more than simply A-Z.
835 That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC.
836 But if shift-lock is down, then it does. */
837 if (xd->lock_interpretation == XK_Shift_Lock)
841 ((sym >= XK_A) && (sym <= XK_Z)) ||
842 ((sym >= XK_a) && (sym <= XK_z)) ||
843 ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis)) ||
844 ((sym >= XK_agrave) && (sym <= XK_odiaeresis)) ||
845 ((sym >= XK_Ooblique) && (sym <= XK_Thorn)) ||
846 ((sym >= XK_oslash) && (sym <= XK_thorn));
849 /* called from EmacsFrame.c (actually from Xt itself) when a
850 MappingNotify event is received. In its infinite wisdom, Xt
851 decided that Xt event handlers never get MappingNotify events.
852 O'Reilly Xt Programming Manual 9.1.2 says:
854 MappingNotify is automatically handled by Xt, so it isn't passed
855 to event handlers and you don't need to worry about it.
857 Of course, we DO worry about it, so we need a special translation. */
859 emacs_Xt_mapping_action (Widget w, XEvent* event)
861 struct device *d = get_device_from_display (event->xany.display);
863 if (DEVICE_X_BEING_DELETED (d))
866 /* nyet. Now this is handled by Xt. */
867 XRefreshKeyboardMapping (&event->xmapping);
869 /* xmodmap generates about a billion MappingKeyboard events, followed
870 by a single MappingModifier event, so it might be worthwhile to
871 take extra MappingKeyboard events out of the queue before requesting
872 the current keymap from the server. */
873 switch (event->xmapping.request)
875 case MappingKeyboard: x_reset_key_mapping (d); break;
876 case MappingModifier: x_reset_modifier_mapping (d); break;
877 case MappingPointer: /* Do something here? */ break;
883 /************************************************************************/
884 /* X to Emacs event conversion */
885 /************************************************************************/
888 x_keysym_to_emacs_keysym (KeySym keysym, int simple_p)
891 if (keysym >= XK_exclam && keysym <= XK_asciitilde)
892 /* We must assume that the X keysym numbers for the ASCII graphic
893 characters are the same as their ASCII codes. */
894 return make_char (keysym);
898 /* These would be handled correctly by the default case, but by
899 special-casing them here we don't garbage a string or call
901 case XK_BackSpace: return QKbackspace;
902 case XK_Tab: return QKtab;
903 case XK_Linefeed: return QKlinefeed;
904 case XK_Return: return QKreturn;
905 case XK_Escape: return QKescape;
906 case XK_space: return QKspace;
907 case XK_Delete: return QKdelete;
910 if (simple_p) return Qnil;
911 /* !!#### not Mule-ized */
912 name = XKeysymToString (keysym);
913 if (!name || !name[0])
914 /* This happens if there is a mismatch between the Xlib of
915 XEmacs and the Xlib of the X server...
917 Let's hard-code in some knowledge of common keysyms introduced
918 in recent X11 releases. Snarfed from X11/keysymdef.h
920 Probably we should add some stuff here for X11R6. */
923 case 0xFF95: return KEYSYM ("kp-home");
924 case 0xFF96: return KEYSYM ("kp-left");
925 case 0xFF97: return KEYSYM ("kp-up");
926 case 0xFF98: return KEYSYM ("kp-right");
927 case 0xFF99: return KEYSYM ("kp-down");
928 case 0xFF9A: return KEYSYM ("kp-prior");
929 case 0xFF9B: return KEYSYM ("kp-next");
930 case 0xFF9C: return KEYSYM ("kp-end");
931 case 0xFF9D: return KEYSYM ("kp-begin");
932 case 0xFF9E: return KEYSYM ("kp-insert");
933 case 0xFF9F: return KEYSYM ("kp-delete");
935 case 0x1005FF10: return KEYSYM ("SunF36"); /* labeled F11 */
936 case 0x1005FF11: return KEYSYM ("SunF37"); /* labeled F12 */
940 sprintf (buf, "unknown-keysym-0x%X", (int) keysym);
944 /* If it's got a one-character name, that's good enough. */
946 return make_char (name[0]);
948 /* If it's in the "Keyboard" character set, downcase it.
949 The case of those keysyms is too totally random for us to
950 force anyone to remember them.
951 The case of the other character sets is significant, however.
953 if ((((unsigned int) keysym) & (~0x1FF)) == ((unsigned int) 0xFE00))
957 for (s1 = name, s2 = buf; *s1; s1++, s2++) {
961 *s2 = tolower (* (unsigned char *) s1);
967 return KEYSYM (name);
972 x_to_emacs_keysym (XKeyPressedEvent *event, int simple_p)
973 /* simple_p means don't try too hard (ASCII only) */
979 /* Some implementations of XmbLookupString don't return
980 XBufferOverflow correctly, so increase the size of the xim input
981 buffer from 64 to the more reasonable size 513, as Emacs has done.
982 From Kenichi Handa. */
984 char *bufptr = buffer;
985 int bufsiz = sizeof (buffer);
988 XIC xic = FRAME_X_XIC (x_any_window_to_frame
989 (get_device_from_display (event->display),
991 #endif /* XIM_XLIB */
992 #endif /* HAVE_XIM */
994 /* We use XLookupString if we're not using XIM, or are using
995 XIM_XLIB but input context creation failed. */
996 #if ! (defined (HAVE_XIM) && defined (XIM_MOTIF))
997 #if defined (HAVE_XIM) && defined (XIM_XLIB)
999 #endif /* XIM_XLIB */
1001 /* Apparently it's necessary to specify a dummy here (rather
1002 than passing in 0) to avoid crashes on German IRIX */
1004 XLookupString (event, dummy, 200, &keysym, 0);
1005 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
1006 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
1008 #endif /* ! XIM_MOTIF */
1011 Lookup_String: /* Come-From XBufferOverflow */
1013 len = XmImMbLookupString (XtWindowToWidget (event->display, event->window),
1014 event, bufptr, bufsiz, &keysym, &status);
1015 #else /* XIM_XLIB */
1017 len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
1018 #endif /* HAVE_XIM */
1021 if (debug_x_events > 0)
1023 stderr_out (" status=");
1024 #define print_status_when(S) if (status == S) stderr_out (#S)
1025 print_status_when (XLookupKeySym);
1026 print_status_when (XLookupBoth);
1027 print_status_when (XLookupChars);
1028 print_status_when (XLookupNone);
1029 print_status_when (XBufferOverflow);
1031 if (status == XLookupKeySym || status == XLookupBoth)
1032 stderr_out (" keysym=%s", XKeysymToString (keysym));
1033 if (status == XLookupChars || status == XLookupBoth)
1038 stderr_out (" chars=\"");
1039 for (j=0; j<len; j++)
1040 stderr_out ("%c", bufptr[j]);
1043 else if (bufptr[0] <= 32 || bufptr[0] >= 127)
1044 stderr_out (" char=0x%x", bufptr[0]);
1046 stderr_out (" char=%c", bufptr[0]);
1050 #endif /* DEBUG_XEMACS */
1056 return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
1057 ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
1061 /* Generate multiple emacs events */
1062 struct device *d = get_device_from_display (event->display);
1064 Lisp_Object instream, fb_instream;
1066 struct gcpro gcpro1, gcpro2;
1068 fb_instream = make_fixed_buffer_input_stream (bufptr, len);
1070 /* #### Use Fget_coding_system (Vcomposed_input_coding_system) */
1072 make_decoding_input_stream (XLSTREAM (fb_instream),
1073 Fget_coding_system (Qundecided));
1075 istr = XLSTREAM (instream);
1077 GCPRO2 (instream, fb_instream);
1078 while ((ch = Lstream_get_emchar (istr)) != EOF)
1080 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
1081 Lisp_Event *ev = XEVENT (emacs_event);
1082 ev->channel = DEVICE_CONSOLE (d);
1083 ev->event_type = key_press_event;
1084 ev->timestamp = event->time;
1085 ev->event.key.modifiers = 0;
1086 ev->event.key.keysym = make_char (ch);
1087 enqueue_Xt_dispatch_event (emacs_event);
1089 Lstream_close (istr);
1091 Lstream_delete (istr);
1092 Lstream_delete (XLSTREAM (fb_instream));
1095 case XLookupNone: return Qnil;
1096 case XBufferOverflow:
1097 bufptr = (char *) alloca (len+1);
1101 return Qnil; /* not reached */
1102 #endif /* HAVE_XIM */
1106 set_last_server_timestamp (struct device *d, XEvent *x_event)
1109 switch (x_event->type)
1112 case KeyRelease: t = x_event->xkey.time; break;
1114 case ButtonRelease: t = x_event->xbutton.time; break;
1116 case LeaveNotify: t = x_event->xcrossing.time; break;
1117 case MotionNotify: t = x_event->xmotion.time; break;
1118 case PropertyNotify: t = x_event->xproperty.time; break;
1119 case SelectionClear: t = x_event->xselectionclear.time; break;
1120 case SelectionRequest: t = x_event->xselectionrequest.time; break;
1121 case SelectionNotify: t = x_event->xselection.time; break;
1124 DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t;
1128 x_event_to_emacs_event (XEvent *x_event, Lisp_Event *emacs_event)
1130 Display *display = x_event->xany.display;
1131 struct device *d = get_device_from_display (display);
1132 struct x_device *xd = DEVICE_X_DATA (d);
1134 if (DEVICE_X_BEING_DELETED (d))
1135 /* #### Uh, is this 0 correct? */
1138 set_last_server_timestamp (d, x_event);
1140 switch (x_event->type)
1143 x_handle_sticky_modifiers (x_event, d);
1151 int shift_p, lock_p;
1152 Bool key_event_p = (x_event->type == KeyPress);
1153 unsigned int *state =
1154 key_event_p ? &x_event->xkey.state : &x_event->xbutton.state;
1156 /* If this is a synthetic KeyPress or Button event, and the user
1157 has expressed a disinterest in this security hole, then drop
1160 ? x_event->xkey.send_event
1161 : x_event->xbutton.send_event)
1162 #ifdef EXTERNAL_WIDGET
1163 /* ben: events get sent to an ExternalShell using XSendEvent.
1164 This is not a perfect solution. */
1165 && !FRAME_X_EXTERNAL_WINDOW_P
1166 (x_any_window_to_frame (d, x_event->xany.window))
1168 && !x_allow_sendevents)
1171 DEVICE_X_MOUSE_TIMESTAMP (d) =
1172 DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
1173 key_event_p ? x_event->xkey.time : x_event->xbutton.time;
1175 x_handle_sticky_modifiers (x_event, d);
1177 if (*state & ControlMask) modifiers |= XEMACS_MOD_CONTROL;
1178 if (*state & xd->MetaMask) modifiers |= XEMACS_MOD_META;
1179 if (*state & xd->SuperMask) modifiers |= XEMACS_MOD_SUPER;
1180 if (*state & xd->HyperMask) modifiers |= XEMACS_MOD_HYPER;
1181 if (*state & xd->AltMask) modifiers |= XEMACS_MOD_ALT;
1183 int numero_de_botao = -1;
1186 numero_de_botao = x_event->xbutton.button;
1188 /* the button gets noted either in the button or the modifiers
1189 field, but not both. */
1190 if (numero_de_botao != 1 && (*state & Button1Mask))
1191 modifiers |= XEMACS_MOD_BUTTON1;
1192 if (numero_de_botao != 2 && (*state & Button2Mask))
1193 modifiers |= XEMACS_MOD_BUTTON2;
1194 if (numero_de_botao != 3 && (*state & Button3Mask))
1195 modifiers |= XEMACS_MOD_BUTTON3;
1196 if (numero_de_botao != 4 && (*state & Button4Mask))
1197 modifiers |= XEMACS_MOD_BUTTON4;
1198 if (numero_de_botao != 5 && (*state & Button5Mask))
1199 modifiers |= XEMACS_MOD_BUTTON5;
1202 /* Ignore the Caps_Lock key if:
1203 - any other modifiers are down, so that Caps_Lock doesn't
1204 turn C-x into C-X, which would suck.
1205 - the event was a mouse event. */
1206 if (modifiers || ! key_event_p)
1207 *state &= (~LockMask);
1209 shift_p = *state & ShiftMask;
1210 lock_p = *state & LockMask;
1212 if (shift_p || lock_p)
1213 modifiers |= XEMACS_MOD_SHIFT;
1218 XKeyEvent *ev = &x_event->xkey;
1219 /* This used to compute the frame from the given X window and
1220 store it here, but we really don't care about the frame. */
1221 emacs_event->channel = DEVICE_CONSOLE (d);
1222 keysym = x_to_emacs_keysym (&x_event->xkey, 0);
1224 /* If the emacs keysym is nil, then that means that the X
1225 keysym was either a Modifier or NoSymbol, which
1226 probably means that we're in the midst of reading a
1227 Multi_key sequence, or a "dead" key prefix, or XIM
1228 input. Ignore it. */
1232 /* More Caps_Lock garbage: Caps_Lock should *only* add the
1233 shift modifier to two-case keys (that is, A-Z and
1234 related characters). So at this point (after looking up
1235 the keysym) if the keysym isn't a dual-case alphabetic,
1236 and if the caps lock key was down but the shift key
1237 wasn't, then turn off the shift modifier. Gag barf */
1238 /* #### type lossage: assuming equivalence of emacs and
1240 /* !!#### maybe fix for Mule */
1241 if (lock_p && !shift_p &&
1242 ! (CHAR_OR_CHAR_INTP (keysym)
1243 && keysym_obeys_caps_lock_p
1244 ((KeySym) XCHAR_OR_CHAR_INT (keysym), d)))
1245 modifiers &= (~XEMACS_MOD_SHIFT);
1247 /* If this key contains two distinct keysyms, that is,
1248 "shift" generates a different keysym than the
1249 non-shifted key, then don't apply the shift modifier
1250 bit: it's implicit. Otherwise, if there would be no
1251 other way to tell the difference between the shifted
1252 and unshifted version of this key, apply the shift bit.
1253 Non-graphics, like Backspace and F1 get the shift bit
1254 in the modifiers slot. Neither the characters "a",
1255 "A", "2", nor "@" normally have the shift bit set.
1256 However, "F1" normally does. */
1257 if (modifiers & XEMACS_MOD_SHIFT)
1259 int Mode_switch_p = *state & xd->ModeMask;
1260 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0);
1261 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1);
1262 if (top && bot && top != bot)
1263 modifiers &= ~XEMACS_MOD_SHIFT;
1265 emacs_event->event_type = key_press_event;
1266 emacs_event->timestamp = ev->time;
1267 emacs_event->event.key.modifiers = modifiers;
1268 emacs_event->event.key.keysym = keysym;
1270 else /* Mouse press/release event */
1272 XButtonEvent *ev = &x_event->xbutton;
1273 struct frame *frame = x_window_to_frame (d, ev->window);
1276 return 0; /* not for us */
1277 XSETFRAME (emacs_event->channel, frame);
1279 emacs_event->event_type = (x_event->type == ButtonPress) ?
1280 button_press_event : button_release_event;
1282 emacs_event->event.button.modifiers = modifiers;
1283 emacs_event->timestamp = ev->time;
1284 emacs_event->event.button.button = ev->button;
1285 emacs_event->event.button.x = ev->x;
1286 emacs_event->event.button.y = ev->y;
1287 /* because we don't seem to get a FocusIn event for button clicks
1288 when a widget-glyph is selected we will assume that we want the
1289 focus if a button gets pressed. */
1290 if (x_event->type == ButtonPress)
1291 handle_focus_event_1 (frame, 1);
1298 XMotionEvent *ev = &x_event->xmotion;
1299 struct frame *frame = x_window_to_frame (d, ev->window);
1301 XMotionEvent event2;
1304 return 0; /* not for us */
1306 /* We use MotionHintMask, so we will get only one motion event
1307 until the next time we call XQueryPointer or the user
1308 clicks the mouse. So call XQueryPointer now (meaning that
1309 the event will be in sync with the server just before
1310 Fnext_event() returns). If the mouse is still in motion,
1311 then the server will immediately generate exactly one more
1312 motion event, which will be on the queue waiting for us
1313 next time around. */
1315 if (XQueryPointer (event2.display, event2.window,
1316 &event2.root, &event2.subwindow,
1317 &event2.x_root, &event2.y_root,
1318 &event2.x, &event2.y,
1320 ev = &event2; /* only one structure copy */
1322 DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
1324 XSETFRAME (emacs_event->channel, frame);
1325 emacs_event->event_type = pointer_motion_event;
1326 emacs_event->timestamp = ev->time;
1327 emacs_event->event.motion.x = ev->x;
1328 emacs_event->event.motion.y = ev->y;
1329 if (ev->state & ShiftMask) modifiers |= XEMACS_MOD_SHIFT;
1330 if (ev->state & ControlMask) modifiers |= XEMACS_MOD_CONTROL;
1331 if (ev->state & xd->MetaMask) modifiers |= XEMACS_MOD_META;
1332 if (ev->state & xd->SuperMask) modifiers |= XEMACS_MOD_SUPER;
1333 if (ev->state & xd->HyperMask) modifiers |= XEMACS_MOD_HYPER;
1334 if (ev->state & xd->AltMask) modifiers |= XEMACS_MOD_ALT;
1335 if (ev->state & Button1Mask) modifiers |= XEMACS_MOD_BUTTON1;
1336 if (ev->state & Button2Mask) modifiers |= XEMACS_MOD_BUTTON2;
1337 if (ev->state & Button3Mask) modifiers |= XEMACS_MOD_BUTTON3;
1338 if (ev->state & Button4Mask) modifiers |= XEMACS_MOD_BUTTON4;
1339 if (ev->state & Button5Mask) modifiers |= XEMACS_MOD_BUTTON5;
1340 /* Currently ignores Shift_Lock but probably shouldn't
1341 (but it definitely should ignore Caps_Lock). */
1342 emacs_event->event.motion.modifiers = modifiers;
1348 /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
1349 passed as the timestamp of the TAKE_FOCUS, which the ICCCM
1350 explicitly prohibits. */
1351 XClientMessageEvent *ev = &x_event->xclient;
1352 #ifdef HAVE_OFFIX_DND
1353 if (DndIsDropMessage(x_event))
1357 unsigned int button=0;
1358 struct frame *frame = x_any_window_to_frame (d, ev->window);
1360 unsigned long size, dtype;
1361 Lisp_Object l_type = Qnil, l_data = Qnil;
1362 Lisp_Object l_dndlist = Qnil, l_item = Qnil;
1363 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1366 return 0; /* not for us */
1368 GCPRO4 (l_type, l_data, l_dndlist, l_item);
1369 XSETFRAME (emacs_event->channel, frame);
1371 emacs_event->event_type = misc_user_event;
1372 emacs_event->timestamp = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1374 state=DndDragButtons(x_event);
1376 if (state & ShiftMask) modifiers |= XEMACS_MOD_SHIFT;
1377 if (state & ControlMask) modifiers |= XEMACS_MOD_CONTROL;
1378 if (state & xd->MetaMask) modifiers |= XEMACS_MOD_META;
1379 if (state & xd->SuperMask) modifiers |= XEMACS_MOD_SUPER;
1380 if (state & xd->HyperMask) modifiers |= XEMACS_MOD_HYPER;
1381 if (state & xd->AltMask) modifiers |= XEMACS_MOD_ALT;
1382 if (state & Button1Mask) modifiers |= XEMACS_MOD_BUTTON1;
1383 if (state & Button2Mask) modifiers |= XEMACS_MOD_BUTTON2;
1384 if (state & Button3Mask) modifiers |= XEMACS_MOD_BUTTON3;
1385 if (state & Button4Mask) modifiers |= XEMACS_MOD_BUTTON4;
1386 if (state & Button5Mask) modifiers |= XEMACS_MOD_BUTTON5;
1388 if (state & Button5Mask) button = Button5;
1389 if (state & Button4Mask) button = Button4;
1390 if (state & Button3Mask) button = Button3;
1391 if (state & Button2Mask) button = Button2;
1392 if (state & Button1Mask) button = Button1;
1394 emacs_event->event.misc.modifiers = modifiers;
1395 emacs_event->event.misc.button = button;
1397 DndDropCoordinates(FRAME_X_TEXT_WIDGET(frame), x_event,
1398 &(emacs_event->event.misc.x),
1399 &(emacs_event->event.misc.y) );
1401 DndGetData(x_event,&data,&size);
1403 dtype=DndDataType(x_event);
1406 case DndFiles: /* null terminated strings, end null */
1413 len = strlen ((char*)data);
1414 hurl = dnd_url_hexify_string ((char *)data, "file:");
1415 l_item = make_string ((Bufbyte *)hurl, strlen (hurl));
1416 l_dndlist = Fcons (l_item, l_dndlist);
1420 l_type = Qdragdrop_URL;
1424 l_type = Qdragdrop_MIME;
1425 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
1426 make_string ((Bufbyte *)"8bit", 4),
1427 make_ext_string ((Extbyte *)data,
1428 strlen((char *)data),
1432 /* we have to parse this in some way to extract
1433 content-type and params (in the tm way) and
1435 OR: if data is string, let tm do the job
1436 if data is list[2], give the first two
1439 l_type = Qdragdrop_MIME;
1440 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1441 strlen((char *)data),
1449 char *hurl = dnd_url_hexify_string ((char *) data, "file:");
1451 l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
1453 l_type = Qdragdrop_URL;
1459 /* as it is a real URL it should already be escaped
1460 and escaping again will break them (cause % is unsave) */
1461 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1462 strlen ((char *)data),
1464 l_type = Qdragdrop_URL;
1466 default: /* Unknown, RawData and any other type */
1467 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"application/octet-stream", 24) ),
1468 make_string ((Bufbyte *)"8bit", 4),
1469 make_ext_string ((Extbyte *)data,
1472 l_type = Qdragdrop_MIME;
1476 emacs_event->event.misc.function = Qdragdrop_drop_dispatch;
1477 emacs_event->event.misc.object = Fcons (l_type, l_dndlist);
1483 #endif /* HAVE_OFFIX_DND */
1484 if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
1485 && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
1486 && (Atom) (ev->data.l[1]) == 0)
1488 ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1493 default: /* it's a magic event */
1495 struct frame *frame;
1497 XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
1499 #define FROB(event_member, window_member) \
1500 x_event_copy->event_member = x_event->event_member; \
1501 w = x_event->event_member.window_member
1503 switch (x_event->type)
1505 case SelectionRequest: FROB(xselectionrequest, owner); break;
1506 case SelectionClear: FROB(xselectionclear, window); break;
1507 case SelectionNotify: FROB(xselection, requestor); break;
1508 case PropertyNotify: FROB(xproperty, window); break;
1509 case ClientMessage: FROB(xclient, window); break;
1510 case ConfigureNotify: FROB(xconfigure, window); break;
1512 case GraphicsExpose: FROB(xexpose, window); break;
1514 case UnmapNotify: FROB(xmap, window); break;
1516 case LeaveNotify: FROB(xcrossing, window); break;
1518 case FocusOut: FROB(xfocus, window); break;
1519 case VisibilityNotify: FROB(xvisibility, window); break;
1520 case CreateNotify: FROB(xcreatewindow, window); break;
1522 w = x_event->xany.window;
1523 *x_event_copy = *x_event;
1527 frame = x_any_window_to_frame (d, w);
1532 emacs_event->event_type = magic_event;
1533 XSETFRAME (emacs_event->channel, frame);
1543 /************************************************************************/
1544 /* magic-event handling */
1545 /************************************************************************/
1548 handle_focus_event_1 (struct frame *f, int in_p)
1550 handle_focus_event_2 (XtWindow (FRAME_X_TEXT_WIDGET (f)), f, in_p);
1554 handle_focus_event_2 (Window win, struct frame *f, int in_p)
1556 /* Although this treats focus differently for all widgets (including
1557 the frame) it seems to work ok. */
1558 Widget needs_it = XtWindowToWidget (FRAME_X_DISPLAY (f), win);
1560 #if XtSpecificationRelease > 5
1561 widget_with_focus = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f));
1564 XIM_focus_event (f, in_p);
1565 #endif /* HAVE_XIM */
1567 /* On focus change, clear all memory of sticky modifiers
1568 to avoid non-intuitive behavior. */
1569 clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f)));
1571 /* We don't want to handle the focus change now, because we might
1572 be in an accept-process-output, sleep-for, or sit-for. So
1575 Actually, we half handle it: we handle it as far as changing the
1576 box cursor for redisplay, but we don't call any hooks or do any
1577 select-frame stuff until after the sit-for.
1579 Unfortunately native widgets break the model because they grab
1580 the keyboard focus and nothing sets it back again. I cannot find
1581 any reasonable way to do this elsewhere so we assert here that
1582 the keyboard focus is on the emacs text widget. Menus and dialogs
1583 do this in their selection callback, but we don't want that since
1584 a button having focus is legitimate. An edit field having focus
1585 is mandatory. Weirdly you get a FocusOut event when you click in
1586 a widget-glyph but you don't get a corresponding FocusIn when you
1587 click in the frame. Why is this? */
1589 #if XtSpecificationRelease > 5
1590 && needs_it != widget_with_focus
1594 lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f), needs_it);
1597 /* If we are focusing on a native widget then record and exit. */
1598 if (needs_it != FRAME_X_TEXT_WIDGET (f)) {
1599 widget_with_focus = needs_it;
1603 /* We have the focus now. See comment in
1604 emacs_Xt_handle_widget_losing_focus (). */
1606 widget_with_focus = NULL;
1608 /* do the generic event-stream stuff. */
1612 struct gcpro gcpro1;
1615 conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
1617 emacs_handle_focus_change_preliminary (conser);
1618 enqueue_magic_eval_event (emacs_handle_focus_change_final,
1624 /* Create a synthetic X focus event. */
1626 enqueue_focus_event (Widget wants_it, Lisp_Object frame, int in_p)
1628 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
1629 Lisp_Event *ev = XEVENT (emacs_event);
1630 XEvent *x_event = &ev->event.magic.underlying_x_event;
1632 x_event->type = in_p ? FocusIn : FocusOut;
1633 x_event->xfocus.window = XtWindow (wants_it);
1635 ev->channel = frame;
1636 ev->event_type = magic_event;
1638 enqueue_Xt_dispatch_event (emacs_event);
1641 /* The idea here is that when a widget glyph gets unmapped we don't
1642 want the focus to stay with it if it has focus - because it may
1643 well just get deleted next and then we have lost the focus until the
1644 user does something. So handle_focus_event_1 records the widget
1645 with keyboard focus when FocusOut is processed, and then, when a
1646 widget gets unmapped, it calls this function to restore focus if
1648 void emacs_Xt_handle_widget_losing_focus (struct frame* f, Widget losing_widget);
1650 emacs_Xt_handle_widget_losing_focus (struct frame* f, Widget losing_widget)
1652 if (losing_widget == widget_with_focus)
1654 handle_focus_event_1 (f, 1);
1658 /* This is called from the external-widget code */
1660 void emacs_Xt_handle_focus_event (XEvent *event);
1662 emacs_Xt_handle_focus_event (XEvent *event)
1664 struct device *d = get_device_from_display (event->xany.display);
1667 if (DEVICE_X_BEING_DELETED (d))
1671 * It's curious that we're using x_any_window_to_frame() instead
1672 * of x_window_to_frame(). I don't know what the impact of this is.
1674 f = x_any_window_to_frame (d, event->xfocus.window);
1676 /* focus events are sometimes generated just before
1677 a frame is destroyed. */
1679 handle_focus_event_1 (f, event->type == FocusIn);
1682 /* both MapNotify and VisibilityNotify can cause this
1683 JV is_visible has the same semantics as f->visible*/
1685 change_frame_visibility (struct frame *f, int is_visible)
1689 XSETFRAME (frame, f);
1691 if (!FRAME_VISIBLE_P (f) && is_visible)
1693 FRAME_VISIBLE_P (f) = is_visible;
1694 /* This improves the double flicker when uniconifying a frame
1695 some. A lot of it is not showing a buffer which has changed
1696 while the frame was iconified. To fix it further requires
1697 the good 'ol double redisplay structure. */
1698 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1699 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1701 else if (FRAME_VISIBLE_P (f) && !is_visible)
1703 FRAME_VISIBLE_P (f) = 0;
1704 va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
1706 else if (FRAME_VISIBLE_P (f) * is_visible < 0)
1708 FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f);
1709 if (FRAME_REPAINT_P(f))
1710 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1711 va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1716 handle_map_event (struct frame *f, XEvent *event)
1720 XSETFRAME (frame, f);
1721 if (event->type == MapNotify)
1723 XWindowAttributes xwa;
1725 /* Bleagh!!!!!! Apparently some window managers (e.g. MWM)
1726 send synthetic MapNotify events when a window is first
1727 created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE.
1728 Or something like that. We initially tried a different
1729 solution below, but that ran into a different window-
1732 It seems that the only reliable way is to treat a
1733 MapNotify event as a "hint" that the window might or
1734 might not be visible, and check explicitly. */
1736 XGetWindowAttributes (event->xany.display, event->xmap.window,
1738 if (xwa.map_state != IsViewable)
1740 /* Calling Fframe_iconified_p is the only way we have to
1741 correctly update FRAME_ICONIFIED_P */
1742 Fframe_iconified_p (frame);
1746 FRAME_X_TOTALLY_VISIBLE_P (f) = 1;
1748 /* Bleagh again!!!! We initially tried the following hack
1749 around the MWM problem, but it turns out that TWM
1750 has a race condition when you un-iconify, where it maps
1751 the window and then tells the server that the window
1752 is un-iconified. Usually, XEmacs wakes up between
1753 those two occurrences, and thus thinks that un-iconified
1754 windows are still iconified.
1756 Ah, the joys of X. */
1758 /* By Emacs definition, a frame that is iconified is not
1759 visible. Marking a frame as visible will automatically cause
1760 frame-iconified-p to return nil, regardless of whether the
1761 frame is actually iconified. Therefore, we have to ignore
1762 MapNotify events on iconified frames. (It's not obvious
1763 to me why these are being sent, but it happens at startup
1764 with frames that are initially iconified; perhaps they are
1765 synthetic MapNotify events coming from the window manager.)
1766 Note that `frame-iconified-p' queries the server
1767 to determine whether the frame is currently iconified,
1768 rather than consulting some internal (and likely
1769 inaccurate) state flag. Therefore, ignoring the MapNotify
1771 if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (frame)))
1773 change_frame_visibility (f, 1);
1777 FRAME_X_TOTALLY_VISIBLE_P (f) = 0;
1778 change_frame_visibility (f, 0);
1779 /* Calling Fframe_iconified_p is the only way we have to
1780 correctly update FRAME_ICONIFIED_P */
1781 Fframe_iconified_p (frame);
1786 handle_client_message (struct frame *f, XEvent *event)
1788 struct device *d = XDEVICE (FRAME_DEVICE (f));
1791 XSETFRAME (frame, f);
1793 if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1794 (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d))
1796 /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages,
1797 such as WM_TAKE_FOCUS, are eval events. That's because delete-window
1798 was probably executed with a mouse click, while the others could
1799 have been sent as a result of mouse motion or some other implicit
1800 action. (Call this a "heuristic"...) The reason for caring about
1801 this is so that clicking on the close-box will make emacs prompt
1802 using a dialog box instead of the minibuffer if there are unsaved
1805 enqueue_misc_user_event (frame, Qeval,
1806 list3 (Qdelete_frame, frame, Qt));
1808 else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1809 (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
1811 handle_focus_event_1 (f, 1);
1813 /* If there is a dialog box up, focus on it.
1815 #### Actually, we're raising it too, which is wrong. We should
1816 #### just focus on it, but lwlib doesn't currently give us an
1817 #### easy way to do that. This should be fixed.
1819 unsigned long take_focus_timestamp = event->xclient.data.l[1];
1820 Widget widget = lw_raise_all_pop_up_widgets ();
1823 /* kludge: raise_all returns bottommost widget, but we really
1824 want the topmost. So just raise it for now. */
1825 XMapRaised (XtDisplay (widget), XtWindow (widget));
1826 /* Grab the focus with the timestamp of the TAKE_FOCUS. */
1827 XSetInputFocus (XtDisplay (widget), XtWindow (widget),
1828 RevertToParent, take_focus_timestamp);
1834 /* #### I'm struggling to understand how the X event loop really works.
1835 Here is the problem:
1837 When widgets get mapped / changed etc the actual display updates
1838 are done asynchronously via X events being processed - this
1839 normally happens when XtAppProcessEvent() gets called. However, if
1840 we are executing lisp code or even doing redisplay we won't
1841 necessarily process X events for a very long time. This has the
1842 effect of widgets only getting updated when XEmacs only goes into
1843 idle, or some other event causes processing of the X event queue.
1845 XtAppProcessEvent can get called from the following places:
1847 emacs_Xt_next_event () - this is normal event processing, almost
1848 any non-X event will take precedence and this means that we
1849 cannot rely on it to do the right thing at the right time for
1852 drain_X_queue () - this happens when SIGIO gets tripped,
1853 processing the event queue allows C-g to be checked for. It gets
1854 called from emacs_Xt_event_pending_p ().
1856 In order to solve this I have tried introducing a list primitive -
1857 dispatch-non-command-events - which forces processing of X events
1858 related to display. Unfortunately this has a number of problems,
1859 one is that it is possible for event_stream_event_pending_p to
1860 block for ever if there isn't actually an event. I guess this can
1861 happen if we drop the synthetic event for reason. It also relies on
1862 SIGIO processing which makes things rather fragile.
1864 People have seen behaviour whereby XEmacs blocks until you move the
1865 mouse. This seems to indicate that dispatch-non-command-events is
1866 blocking. It may be that in a SIGIO world forcing SIGIO processing
1867 does the wrong thing.
1870 emacs_Xt_force_event_pending (struct frame* f)
1874 Display* dpy = DEVICE_X_DISPLAY (XDEVICE (FRAME_DEVICE (f)));
1875 event.xclient.type = ClientMessage;
1876 event.xclient.display = dpy;
1877 event.xclient.message_type = XInternAtom (dpy, "BumpQueue", False);
1878 event.xclient.format = 32;
1879 event.xclient.window = 0;
1881 /* Send the drop message */
1882 XSendEvent(dpy, XtWindow (FRAME_X_SHELL_WIDGET (f)),
1883 True, NoEventMask, &event);
1884 /* We rely on SIGIO and friends to realise we have generated an
1889 emacs_Xt_handle_magic_event (Lisp_Event *emacs_event)
1891 /* This function can GC */
1892 XEvent *event = &emacs_event->event.magic.underlying_x_event;
1893 struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
1895 if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
1898 switch (event->type)
1900 case SelectionRequest:
1901 x_handle_selection_request (&event->xselectionrequest);
1904 case SelectionClear:
1905 x_handle_selection_clear (&event->xselectionclear);
1908 case SelectionNotify:
1909 x_handle_selection_notify (&event->xselection);
1912 case PropertyNotify:
1913 x_handle_property_notify (&event->xproperty);
1917 if (!check_for_ignored_expose (f, event->xexpose.x, event->xexpose.y,
1918 event->xexpose.width, event->xexpose.height)
1920 !find_matching_subwindow (f, event->xexpose.x, event->xexpose.y,
1921 event->xexpose.width, event->xexpose.height))
1922 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1923 event->xexpose.width, event->xexpose.height);
1926 case GraphicsExpose: /* This occurs when an XCopyArea's source area was
1927 obscured or not available. */
1928 x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1929 event->xexpose.width, event->xexpose.height);
1934 handle_map_event (f, event);
1938 if (event->xcrossing.detail != NotifyInferior)
1942 XSETFRAME (frame, f);
1943 /* FRAME_X_MOUSE_P (f) = 1; */
1944 va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
1949 if (event->xcrossing.detail != NotifyInferior)
1953 XSETFRAME (frame, f);
1954 /* FRAME_X_MOUSE_P (f) = 0; */
1955 va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
1962 #ifdef EXTERNAL_WIDGET
1963 /* External widget lossage: Ben said:
1964 YUCK. The only way to make focus changes work properly is to
1965 completely ignore all FocusIn/FocusOut events and depend only
1966 on notifications from the ExternalClient widget. */
1967 if (FRAME_X_EXTERNAL_WINDOW_P (f))
1970 handle_focus_event_2 (event->xfocus.window, f, event->type == FocusIn);
1974 handle_client_message (f, event);
1977 case VisibilityNotify: /* window visibility has changed */
1978 if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
1980 FRAME_X_TOTALLY_VISIBLE_P (f) =
1981 (event->xvisibility.state == VisibilityUnobscured);
1982 /* Note that the fvwm pager only sends VisibilityNotify when
1983 changing pages. Is this all we need to do ? JV */
1984 /* Nope. We must at least trigger a redisplay here.
1985 Since this case seems similar to MapNotify, I've
1986 factored out some code to change_frame_visibility().
1987 This triggers the necessary redisplay and runs
1988 (un)map-frame-hook. - dkindred@cs.cmu.edu */
1989 /* Changed it again to support the tristate visibility flag */
1990 change_frame_visibility (f, (event->xvisibility.state
1991 != VisibilityFullyObscured) ? 1 : -1);
1995 case ConfigureNotify:
1997 XIM_SetGeometry (f);
2010 /************************************************************************/
2011 /* timeout events */
2012 /************************************************************************/
2014 static int timeout_id_tick;
2016 /* Xt interval id's might not fit into an int (they're pointers, as it
2017 happens), so we need to provide a conversion list. */
2019 /* pending_timeouts is a set (unordered), implemented as a stack.
2020 completed_timeouts* is a queue. */
2021 static struct Xt_timeout
2024 XtIntervalId interval_id;
2025 struct Xt_timeout *next;
2026 } *pending_timeouts, *completed_timeouts_head, *completed_timeouts_tail;
2028 static struct Xt_timeout_blocktype
2030 Blocktype_declare (struct Xt_timeout);
2031 } *the_Xt_timeout_blocktype;
2033 /* called by XtAppNextEvent() */
2035 Xt_timeout_callback (XtPointer closure, XtIntervalId *id)
2037 struct Xt_timeout *timeout = (struct Xt_timeout *) closure;
2038 struct Xt_timeout *t2 = pending_timeouts;
2039 /* Remove this one from the set of pending timeouts */
2041 pending_timeouts = pending_timeouts->next;
2044 while (t2->next && t2->next != timeout) t2 = t2->next;
2046 t2->next = t2->next->next;
2048 /* Add this one to the queue of completed timeouts */
2049 timeout->next = NULL;
2050 if (completed_timeouts_head)
2051 completed_timeouts_tail->next = timeout;
2053 completed_timeouts_head = timeout;
2054 completed_timeouts_tail = timeout;
2058 emacs_Xt_add_timeout (EMACS_TIME thyme)
2060 struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype);
2061 EMACS_TIME current_time;
2064 timeout->id = timeout_id_tick++;
2065 timeout->next = pending_timeouts;
2066 pending_timeouts = timeout;
2067 EMACS_GET_TIME (current_time);
2068 EMACS_SUB_TIME (thyme, thyme, current_time);
2069 milliseconds = EMACS_SECS (thyme) * 1000 +
2070 EMACS_USECS (thyme) / 1000;
2071 if (milliseconds < 1)
2073 timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds,
2074 Xt_timeout_callback,
2075 (XtPointer) timeout);
2080 emacs_Xt_remove_timeout (int id)
2082 struct Xt_timeout *timeout, *t2;
2086 /* Find the timeout on the list of pending ones, if it's still there. */
2087 if (pending_timeouts)
2089 if (id == pending_timeouts->id)
2091 timeout = pending_timeouts;
2092 pending_timeouts = pending_timeouts->next;
2096 t2 = pending_timeouts;
2097 while (t2->next && t2->next->id != id) t2 = t2->next;
2098 if ( t2->next) /*found it */
2101 t2->next = t2->next->next;
2104 /* if it was pending, we have removed it from the list */
2106 XtRemoveTimeOut (timeout->interval_id);
2109 /* It could be that Xt_timeout_callback was already called but we didn't
2110 convert into an Emacs event yet */
2111 if (!timeout && completed_timeouts_head)
2113 /* Thank God for code duplication! */
2114 if (id == completed_timeouts_head->id)
2116 timeout = completed_timeouts_head;
2117 completed_timeouts_head = completed_timeouts_head->next;
2118 /* this may not be necessary? */
2119 if (!completed_timeouts_head) completed_timeouts_tail = NULL;
2123 t2 = completed_timeouts_head;
2124 while (t2->next && t2->next->id != id) t2 = t2->next;
2125 if (t2->next) /* found it */
2128 t2->next = t2->next->next;
2129 if (!t2->next) completed_timeouts_tail = t2;
2134 /* If we found the thing on the lists of timeouts,
2135 and removed it, deallocate
2138 Blocktype_free (the_Xt_timeout_blocktype, timeout);
2142 Xt_timeout_to_emacs_event (Lisp_Event *emacs_event)
2144 struct Xt_timeout *timeout = completed_timeouts_head;
2146 completed_timeouts_head = completed_timeouts_head->next;
2147 /* probably unnecessary */
2148 if (!completed_timeouts_head) completed_timeouts_tail = NULL;
2149 emacs_event->event_type = timeout_event;
2150 /* timeout events have nil as channel */
2151 emacs_event->timestamp = 0; /* #### wrong!! */
2152 emacs_event->event.timeout.interval_id = timeout->id;
2153 emacs_event->event.timeout.function = Qnil;
2154 emacs_event->event.timeout.object = Qnil;
2155 Blocktype_free (the_Xt_timeout_blocktype, timeout);
2159 /************************************************************************/
2160 /* process and tty events */
2161 /************************************************************************/
2163 struct what_is_ready_closure
2170 static Lisp_Object *filedesc_with_input;
2171 static struct what_is_ready_closure **filedesc_to_what_closure;
2174 init_what_input_once (void)
2178 filedesc_with_input = xnew_array (Lisp_Object, MAXDESC);
2179 filedesc_to_what_closure =
2180 xnew_array (struct what_is_ready_closure *, MAXDESC);
2182 for (i = 0; i < MAXDESC; i++)
2184 filedesc_to_what_closure[i] = 0;
2185 filedesc_with_input[i] = Qnil;
2188 process_events_occurred = 0;
2189 tty_events_occurred = 0;
2193 mark_what_as_being_ready (struct what_is_ready_closure *closure)
2195 if (NILP (filedesc_with_input[closure->fd]))
2197 SELECT_TYPE temp_mask;
2198 FD_ZERO (&temp_mask);
2199 FD_SET (closure->fd, &temp_mask);
2200 /* Check to make sure there's *really* input available.
2201 Sometimes things seem to get confused and this gets called
2202 for the tty fd when there's really only input available
2203 on some process's fd. (It will subsequently get called
2204 for that process's fd, so returning without setting any
2205 flags will take care of it.) To see the problem, uncomment
2206 the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
2207 down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
2208 and press return repeatedly. (Seen under AIX & Linux.)
2209 -dkindred@cs.cmu.edu */
2210 if (!poll_fds_for_input (temp_mask))
2213 stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
2218 filedesc_with_input[closure->fd] = closure->what;
2219 if (PROCESSP (closure->what))
2220 /* Don't increment this if the current process is already marked
2221 * as having input. */
2222 process_events_occurred++;
2224 tty_events_occurred++;
2229 Xt_what_callback (void *closure, int *source, XtInputId *id)
2231 /* If closure is 0, then we got a fake event from a signal handler.
2232 The only purpose of this is to make XtAppProcessEvent() stop
2235 mark_what_as_being_ready ((struct what_is_ready_closure *) closure);
2238 fake_event_occurred++;
2239 drain_signal_event_pipe ();
2244 select_filedesc (int fd, Lisp_Object what)
2246 struct what_is_ready_closure *closure;
2248 /* If somebody is trying to select something that's already selected
2249 for, then something went wrong. The generic routines ought to
2250 detect this and error before here. */
2251 assert (!filedesc_to_what_closure[fd]);
2253 closure = xnew (struct what_is_ready_closure);
2255 closure->what = what;
2257 XtAppAddInput (Xt_app_con, fd,
2258 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
2259 Xt_what_callback, closure);
2260 filedesc_to_what_closure[fd] = closure;
2264 unselect_filedesc (int fd)
2266 struct what_is_ready_closure *closure = filedesc_to_what_closure[fd];
2269 if (!NILP (filedesc_with_input[fd]))
2271 /* We are unselecting this process before we have drained the rest of
2272 the input from it, probably from status_notify() in the command loop.
2273 This can happen like so:
2275 - We are waiting in XtAppNextEvent()
2276 - Process generates output
2277 - Process is marked as being ready
2278 - Process dies, SIGCHLD gets generated before we return (!?)
2279 It could happen I guess.
2280 - sigchld_handler() marks process as dead
2281 - Somehow we end up getting a new KeyPress event on the queue
2282 at the same time (I'm really so sure how that happens but I'm
2283 not sure it can't either so let's assume it can...).
2284 - Key events have priority so we return that instead of the proc.
2285 - Before dispatching the lisp key event we call status_notify()
2286 - Which deselects the process that SIGCHLD marked as dead.
2288 Thus we never remove it from _with_input and turn it into a lisp
2289 event, so we need to do it here. But this does not mean that we're
2290 throwing away the last block of output - status_notify() has already
2291 taken care of running the proc filter or whatever.
2293 filedesc_with_input[fd] = Qnil;
2294 if (PROCESSP (closure->what))
2296 assert (process_events_occurred > 0);
2297 process_events_occurred--;
2301 assert (tty_events_occurred > 0);
2302 tty_events_occurred--;
2305 XtRemoveInput (closure->id);
2307 filedesc_to_what_closure[fd] = 0;
2311 emacs_Xt_select_process (Lisp_Process *p)
2313 Lisp_Object process;
2314 int infd = event_stream_unixoid_select_process (p);
2316 XSETPROCESS (process, p);
2317 select_filedesc (infd, process);
2321 emacs_Xt_unselect_process (Lisp_Process *p)
2323 int infd = event_stream_unixoid_unselect_process (p);
2325 unselect_filedesc (infd);
2329 emacs_Xt_create_stream_pair (void* inhandle, void* outhandle,
2330 Lisp_Object* instream, Lisp_Object* outstream, int flags)
2332 USID u = event_stream_unixoid_create_stream_pair
2333 (inhandle, outhandle, instream, outstream, flags);
2334 if (u != USID_ERROR)
2340 emacs_Xt_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream)
2342 event_stream_unixoid_delete_stream_pair (instream, outstream);
2343 return USID_DONTHASH;
2346 /* This is called from GC when a process object is about to be freed.
2347 If we've still got pointers to it in this file, we're gonna lose hard.
2350 debug_process_finalization (Lisp_Process *p)
2354 Lisp_Object instr, outstr;
2356 get_process_streams (p, &instr, &outstr);
2357 /* if it still has fds, then it hasn't been killed yet. */
2358 assert (NILP(instr));
2359 assert (NILP(outstr));
2360 /* Better not still be in the "with input" table; we know it's got no fds. */
2361 for (i = 0; i < MAXDESC; i++)
2363 Lisp_Object process = filedesc_fds_with_input [i];
2364 assert (!PROCESSP (process) || XPROCESS (process) != p);
2370 Xt_process_to_emacs_event (Lisp_Event *emacs_event)
2374 assert (process_events_occurred > 0);
2376 for (i = 0; i < MAXDESC; i++)
2378 Lisp_Object process = filedesc_with_input[i];
2379 if (PROCESSP (process))
2381 filedesc_with_input[i] = Qnil;
2382 process_events_occurred--;
2383 /* process events have nil as channel */
2384 emacs_event->event_type = process_event;
2385 emacs_event->timestamp = 0; /* #### */
2386 emacs_event->event.process.process = process;
2394 emacs_Xt_select_console (struct console *con)
2396 Lisp_Object console;
2399 if (CONSOLE_X_P (con))
2400 return; /* X consoles are automatically selected for when we
2401 initialize them in Xt */
2402 infd = event_stream_unixoid_select_console (con);
2403 XSETCONSOLE (console, con);
2404 select_filedesc (infd, console);
2408 emacs_Xt_unselect_console (struct console *con)
2410 Lisp_Object console;
2413 if (CONSOLE_X_P (con))
2414 return; /* X consoles are automatically selected for when we
2415 initialize them in Xt */
2416 infd = event_stream_unixoid_unselect_console (con);
2417 XSETCONSOLE (console, con);
2418 unselect_filedesc (infd);
2421 /* read an event from a tty, if one is available. Returns non-zero
2422 if an event was available. Note that when this function is
2423 called, there should always be a tty marked as ready for input.
2424 However, the input condition might actually be EOF, so there
2425 may not really be any input available. (In this case,
2426 read_event_from_tty_or_stream_desc() will arrange for the TTY device
2430 Xt_tty_to_emacs_event (Lisp_Event *emacs_event)
2434 assert (tty_events_occurred > 0);
2435 for (i = 0; i < MAXDESC; i++)
2437 Lisp_Object console = filedesc_with_input[i];
2438 if (CONSOLEP (console))
2440 assert (tty_events_occurred > 0);
2441 tty_events_occurred--;
2442 filedesc_with_input[i] = Qnil;
2443 if (read_event_from_tty_or_stream_desc
2444 (emacs_event, XCONSOLE (console), i))
2453 /************************************************************************/
2454 /* debugging functions to decipher an event */
2455 /************************************************************************/
2458 #include "xintrinsicp.h" /* only describe_event() needs this */
2459 #include <X11/Xproto.h> /* only describe_event() needs this */
2462 describe_event_window (Window window, Display *display)
2466 stderr_out (" window: 0x%lx", (unsigned long) window);
2467 w = XtWindowToWidget (display, window);
2469 stderr_out (" %s", w->core.widget_class->core_class.class_name);
2470 f = x_any_window_to_frame (get_device_from_display (display), window);
2473 char *buf = alloca_array (char, XSTRING_LENGTH (f->name) + 4);
2474 sprintf (buf, " \"%s\"", XSTRING_DATA (f->name));
2475 write_string_to_stdio_stream (stderr, 0, (Bufbyte *) buf, 0,
2476 strlen (buf), Qterminal, 1);
2482 XEvent_mode_to_string (int mode)
2486 case NotifyNormal: return "Normal";
2487 case NotifyGrab: return "Grab";
2488 case NotifyUngrab: return "Ungrab";
2489 case NotifyWhileGrabbed: return "WhileGrabbed";
2490 default: return "???";
2495 XEvent_detail_to_string (int detail)
2499 case NotifyAncestor: return "Ancestor";
2500 case NotifyInferior: return "Inferior";
2501 case NotifyNonlinear: return "Nonlinear";
2502 case NotifyNonlinearVirtual: return "NonlinearVirtual";
2503 case NotifyPointer: return "Pointer";
2504 case NotifyPointerRoot: return "PointerRoot";
2505 case NotifyDetailNone: return "DetailNone";
2506 default: return "???";
2511 XEvent_visibility_to_string (int state)
2515 case VisibilityFullyObscured: return "FullyObscured";
2516 case VisibilityPartiallyObscured: return "PartiallyObscured";
2517 case VisibilityUnobscured: return "Unobscured";
2518 default: return "???";
2523 describe_event (XEvent *event)
2526 struct device *d = get_device_from_display (event->xany.display);
2528 sprintf (buf, "%s%s", x_event_name (event->type),
2529 event->xany.send_event ? " (send)" : "");
2530 stderr_out ("%-30s", buf);
2531 switch (event->type)
2536 XFocusChangeEvent *ev = &event->xfocus;
2537 describe_event_window (ev->window, ev->display);
2538 stderr_out (" mode: %s\n", XEvent_mode_to_string (ev->mode));
2539 stderr_out (" detail: %s\n", XEvent_detail_to_string(ev->detail));
2545 XKeyEvent *ev = &event->xkey;
2546 unsigned int state = ev->state;
2548 describe_event_window (ev->window, ev->display);
2549 stderr_out (" subwindow: %ld\n", ev->subwindow);
2550 stderr_out (" state: ");
2551 /* Complete list of modifier key masks */
2552 if (state & ShiftMask) stderr_out ("Shift ");
2553 if (state & LockMask) stderr_out ("Lock ");
2554 if (state & ControlMask) stderr_out ("Control ");
2555 if (state & Mod1Mask) stderr_out ("Mod1 ");
2556 if (state & Mod2Mask) stderr_out ("Mod2 ");
2557 if (state & Mod3Mask) stderr_out ("Mod3 ");
2558 if (state & Mod4Mask) stderr_out ("Mod4 ");
2559 if (state & Mod5Mask) stderr_out ("Mod5 ");
2562 stderr_out ("vanilla\n");
2565 if (x_key_is_modifier_p (ev->keycode, d))
2566 stderr_out (" Modifier key");
2567 stderr_out (" keycode: 0x%x\n", ev->keycode);
2572 if (debug_x_events > 1)
2574 XExposeEvent *ev = &event->xexpose;
2575 describe_event_window (ev->window, ev->display);
2576 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2577 ev->x, ev->y, ev->width, ev->height);
2578 stderr_out (" count: %d\n", ev->count);
2584 case GraphicsExpose:
2585 if (debug_x_events > 1)
2587 XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
2588 describe_event_window (ev->drawable, ev->display);
2589 stderr_out (" major: %s\n",
2590 (ev ->major_code == X_CopyArea ? "CopyArea" :
2591 (ev->major_code == X_CopyPlane ? "CopyPlane" : "?")));
2592 stderr_out (" region: x=%d y=%d width=%d height=%d\n",
2593 ev->x, ev->y, ev->width, ev->height);
2594 stderr_out (" count: %d\n", ev->count);
2602 if (debug_x_events > 1)
2604 XCrossingEvent *ev = &event->xcrossing;
2605 describe_event_window (ev->window, ev->display);
2607 stderr_out(" subwindow: 0x%x\n", ev->subwindow);
2608 stderr_out(" pos: %d %d\n", ev->x, ev->y);
2609 stderr_out(" root pos: %d %d\n", ev->x_root, ev->y_root);
2611 stderr_out(" mode: %s\n", XEvent_mode_to_string(ev->mode));
2612 stderr_out(" detail: %s\n", XEvent_detail_to_string(ev->detail));
2613 stderr_out(" focus: %d\n", ev->focus);
2615 stderr_out(" state: 0x%x\n", ev->state);
2622 case ConfigureNotify:
2623 if (debug_x_events > 1)
2625 XConfigureEvent *ev = &event->xconfigure;
2626 describe_event_window (ev->window, ev->display);
2627 stderr_out(" above: 0x%lx\n", ev->above);
2628 stderr_out(" size: %d %d %d %d\n", ev->x, ev->y,
2629 ev->width, ev->height);
2630 stderr_out(" redirect: %d\n", ev->override_redirect);
2636 case VisibilityNotify:
2637 if (debug_x_events > 1)
2639 XVisibilityEvent *ev = &event->xvisibility;
2640 describe_event_window (ev->window, ev->display);
2641 stderr_out(" state: %s\n", XEvent_visibility_to_string(ev->state));
2649 XClientMessageEvent *ev = &event->xclient;
2650 char *name = XGetAtomName (ev->display, ev->message_type);
2651 stderr_out ("%s", name);
2652 if (!strcmp (name, "WM_PROTOCOLS")) {
2653 char *protname = XGetAtomName (ev->display, ev->data.l[0]);
2654 stderr_out ("(%s)", protname);
2670 #endif /* include describe_event definition */
2673 /************************************************************************/
2674 /* get the next event from Xt */
2675 /************************************************************************/
2677 static Lisp_Object dispatch_event_queue, dispatch_event_queue_tail;
2680 enqueue_Xt_dispatch_event (Lisp_Object event)
2682 enqueue_event (event, &dispatch_event_queue, &dispatch_event_queue_tail);
2686 dequeue_Xt_dispatch_event (void)
2688 return dequeue_event (&dispatch_event_queue, &dispatch_event_queue_tail);
2691 /* This business exists because menu events "happen" when
2692 menubar_selection_callback() is called from somewhere deep
2693 within XtAppProcessEvent in emacs_Xt_next_event(). The
2694 callback needs to terminate the modal loop in that function
2695 or else it will continue waiting until another event is
2698 Same business applies to scrollbar events. */
2701 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
2704 Lisp_Object event = Fmake_event (Qnil, Qnil);
2706 XEVENT (event)->event_type = misc_user_event;
2707 XEVENT (event)->channel = channel;
2708 XEVENT (event)->event.eval.function = function;
2709 XEVENT (event)->event.eval.object = object;
2711 enqueue_Xt_dispatch_event (event);
2715 emacs_Xt_next_event (Lisp_Event *emacs_event)
2717 we_didnt_get_an_event:
2719 while (NILP (dispatch_event_queue) &&
2720 !completed_timeouts_head &&
2721 !fake_event_occurred &&
2722 !process_events_occurred &&
2723 !tty_events_occurred)
2726 /* Stupid logic in XtAppProcessEvent() dictates that, if process
2727 events and X events are both available, the process event gets
2728 taken first. This will cause an infinite loop if we're being
2729 called from Fdiscard_input().
2731 if (XtAppPending (Xt_app_con) & XtIMXEvent)
2732 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2735 Lisp_Object devcons, concons;
2737 /* We're about to block. Xt has a bug in it (big surprise,
2738 there) in that it blocks using select() and doesn't
2739 flush the Xlib output buffers (XNextEvent() does this
2740 automatically before blocking). So it's necessary
2741 for us to do this ourselves. If we don't do it, then
2742 display output may not be seen until the next time
2743 an X event is received. (This happens esp. with
2744 subprocess output that gets sent to a visible buffer.)
2746 #### The above comment may not have any validity. */
2748 DEVICE_LOOP_NO_BREAK (devcons, concons)
2751 d = XDEVICE (XCAR (devcons));
2753 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2754 /* emacs may be exiting */
2755 XFlush (DEVICE_X_DISPLAY (d));
2757 XtAppProcessEvent (Xt_app_con, XtIMAll);
2761 if (!NILP (dispatch_event_queue))
2763 Lisp_Object event, event2;
2764 XSETEVENT (event2, emacs_event);
2765 event = dequeue_Xt_dispatch_event ();
2766 Fcopy_event (event, event2);
2767 Fdeallocate_event (event);
2769 else if (tty_events_occurred)
2771 if (!Xt_tty_to_emacs_event (emacs_event))
2772 goto we_didnt_get_an_event;
2774 else if (completed_timeouts_head)
2775 Xt_timeout_to_emacs_event (emacs_event);
2776 else if (fake_event_occurred)
2778 /* A dummy event, so that a cycle of the command loop will occur. */
2779 fake_event_occurred = 0;
2780 /* eval events have nil as channel */
2781 emacs_event->event_type = eval_event;
2782 emacs_event->event.eval.function = Qidentity;
2783 emacs_event->event.eval.object = Qnil;
2785 else /* if (process_events_occurred) */
2786 Xt_process_to_emacs_event (emacs_event);
2788 /* No need to call XFilterEvent; Xt does it for us */
2792 emacs_Xt_event_handler (Widget wid /* unused */,
2793 XtPointer closure /* unused */,
2795 Boolean *continue_to_dispatch /* unused */)
2797 Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
2800 if (debug_x_events > 0)
2802 describe_event (event);
2804 #endif /* DEBUG_XEMACS */
2805 if (x_event_to_emacs_event (event, XEVENT (emacs_event)))
2806 enqueue_Xt_dispatch_event (emacs_event);
2808 Fdeallocate_event (emacs_event);
2812 /************************************************************************/
2813 /* input pending / C-g checking */
2814 /************************************************************************/
2817 quit_char_predicate (Display *display, XEvent *event, XPointer data)
2819 struct device *d = get_device_from_display (display);
2820 struct x_device *xd = DEVICE_X_DATA (d);
2822 Bool *critical = (Bool *) data;
2827 if ((event->type != KeyPress) ||
2828 (! x_any_window_to_frame (d, event->xany.window)) ||
2830 & (xd->MetaMask | xd->HyperMask | xd->SuperMask | xd->AltMask)))
2833 /* This duplicates some code that exists elsewhere, but it's relatively
2834 fast and doesn't cons. */
2835 keysym = x_to_emacs_keysym (&event->xkey, 1);
2836 if (NILP (keysym)) return 0;
2837 if (CHAR_OR_CHAR_INTP (keysym))
2838 c = XCHAR_OR_CHAR_INT (keysym);
2839 /* Highly doubtful that these are the quit character, but... */
2840 else if (EQ (keysym, QKbackspace)) c = '\b';
2841 else if (EQ (keysym, QKtab)) c = '\t';
2842 else if (EQ (keysym, QKlinefeed)) c = '\n';
2843 else if (EQ (keysym, QKreturn)) c = '\r';
2844 else if (EQ (keysym, QKescape)) c = 27;
2845 else if (EQ (keysym, QKspace)) c = ' ';
2846 else if (EQ (keysym, QKdelete)) c = 127;
2849 if (event->xkey.state & xd->MetaMask) c |= 0x80;
2850 if ((event->xkey.state & ControlMask) && !(c >= 'A' && c <= 'Z'))
2851 c &= 0x1F; /* unshifted control characters */
2852 quit_char = CONSOLE_QUIT_CHAR (XCONSOLE (DEVICE_CONSOLE (d)));
2855 /* If we've got Control-Shift-G instead of Control-G, that means
2856 we have a critical_quit. Caps_Lock is its own modifier, so it
2857 won't cause ^G to act differently than before. */
2858 if (event->xkey.state & ControlMask) c &= 0x1F;
2861 if (critical) *critical = True;
2867 /* This scans the X input queue for a KeyPress event that matches the
2868 quit character, and sets Vquit_flag. This is called from the
2869 QUIT macro to determine whether we should quit.
2871 In a SIGIO world, this won't be called unless a SIGIO has happened
2872 since the last time we checked.
2874 In a non-SIGIO world, this is called from emacs_Xt_event_pending_p
2875 (which is called from input_pending_p).
2878 x_check_for_quit_char (Display *display)
2882 Bool critical_quit = False;
2883 XEventsQueued (display, QueuedAfterReading);
2884 queued = XCheckIfEvent (display, &event,
2885 quit_char_predicate,
2886 (char *) &critical_quit);
2889 Vquit_flag = (critical_quit ? Qcritical : Qt);
2890 /* don't put the event back onto the queue. Those functions that
2891 wanted to read a ^G directly have arranged to do this. */
2896 check_for_tty_quit_char (struct device *d)
2898 SELECT_TYPE temp_mask;
2899 int infd = DEVICE_INFD (d);
2900 struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
2901 Emchar quit_char = CONSOLE_QUIT_CHAR (con);
2903 FD_ZERO (&temp_mask);
2904 FD_SET (infd, &temp_mask);
2911 if (!poll_fds_for_input (temp_mask))
2914 event = Fmake_event (Qnil, Qnil);
2915 if (!read_event_from_tty_or_stream_desc (XEVENT (event), con, infd))
2916 /* EOF, or something ... */
2918 /* #### bogus. quit-char should be allowed to be any sort
2920 the_char = event_to_character (XEVENT (event), 1, 0, 0);
2921 if (the_char >= 0 && the_char == quit_char)
2924 /* do not queue the C-g. See above. */
2928 /* queue the read event to be read for real later. */
2929 enqueue_Xt_dispatch_event (event);
2934 emacs_Xt_quit_p (void)
2936 Lisp_Object devcons, concons;
2937 CONSOLE_LOOP (concons)
2939 struct console *con = XCONSOLE (XCAR (concons));
2940 if (!con->input_enabled)
2943 CONSOLE_DEVICE_LOOP (devcons, con)
2946 d = XDEVICE (XCAR (devcons));
2948 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2949 /* emacs may be exiting */
2950 x_check_for_quit_char (DEVICE_X_DISPLAY (d));
2951 else if (DEVICE_TTY_P (d))
2952 check_for_tty_quit_char (d);
2958 drain_X_queue (void)
2960 Lisp_Object devcons, concons;
2961 CONSOLE_LOOP (concons)
2963 struct console *con = XCONSOLE (XCAR (concons));
2964 if (!con->input_enabled)
2967 /* sjt sez: Have you tried the loop over devices with XtAppPending(),
2968 not XEventsQueued()?
2969 Ben Sigelman sez: No.
2970 sjt sez: I'm guessing that the reason that your patch "works" is this:
2974 + d = XDEVICE (XCAR (devcons));
2975 + if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d)) {
2977 Ie, if the device goes down, XEmacs detects that and deletes it.
2978 Then the if() fails (DEVICE_X_DISPLAY(d) is NULL), and we don't go
2979 into the Xlib-of-no-return. If you know different, I'd like to hear
2982 These ideas haven't been tested; the code below works for Ben.
2984 CONSOLE_DEVICE_LOOP (devcons, con)
2988 d = XDEVICE (XCAR (devcons));
2989 if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d)) {
2990 display = DEVICE_X_DISPLAY (d);
2991 while (XEventsQueued (display, QueuedAfterReading))
2992 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2996 /* This is the old code, before Ben Sigelman's patch. */
2998 while (XtAppPending (Xt_app_con) & XtIMXEvent)
2999 XtAppProcessEvent (Xt_app_con, XtIMXEvent);
3004 emacs_Xt_event_pending_p (int user_p)
3009 /* If `user_p' is false, then this function returns whether there are any
3010 X, timeout, or fd events pending (that is, whether emacs_Xt_next_event()
3011 would return immediately without blocking).
3013 if `user_p' is true, then this function returns whether there are any
3014 *user generated* events available (that is, whether there are keyboard
3015 or mouse-click events ready to be read). This also implies that
3016 emacs_Xt_next_event() would not block.
3018 In a non-SIGIO world, this also checks whether the user has typed ^G,
3019 since this is a convenient place to do so. We don't need to do this
3020 in a SIGIO world, since input causes an interrupt.
3024 /* I don't think there's any point to this and it will nullify
3025 the speed gains achieved by the sigio_happened checking below.
3026 Its only advantage is that it may possibly make C-g response
3027 a bit faster. The C-g will be noticed within 0.25 second, anyway,
3028 even without this. */
3030 /* First check for C-g if necessary */
3035 /* This function used to simply check whether there were any X
3036 events (or if user_p was 1, it iterated over all the pending
3037 X events using XCheckIfEvent(), looking for keystrokes and
3038 button events). That worked in the old cheesoid event loop,
3039 which didn't go through XtAppDispatchEvent(), but it doesn't
3040 work any more -- X events may not result in anything. For
3041 example, a button press in a blank part of the menubar appears
3042 as an X event but will not result in any Emacs events (a
3043 button press that activates the menubar results in an Emacs
3044 event through the stop_next_event mechanism).
3046 The only accurate way of determining whether these X events
3047 translate into Emacs events is to go ahead and dispatch them
3048 until there's something on the dispatch queue. */
3050 /* See if there are any user events already on the queue. */
3051 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
3052 if (!user_p || command_event_p (event))
3055 /* See if there's any TTY input available.
3057 if (poll_fds_for_input (tty_only_mask))
3062 /* If not user_p and there are any timer or file-desc events
3063 pending, we know there will be an event so we're through. */
3064 XtInputMask pending_value;
3066 /* Note that formerly we just checked the value of XtAppPending()
3067 to determine if there was file-desc input. This doesn't
3068 work any more with the signal_event_pipe; XtAppPending()
3069 will says "yes" in this case but there isn't really any
3070 input. Another way of fixing this problem is for the
3071 signal_event_pipe to generate actual input in the form
3072 of an identity eval event or something. (#### maybe this
3073 actually happens?) */
3075 if (poll_fds_for_input (process_only_mask))
3078 pending_value = XtAppPending (Xt_app_con);
3080 if (pending_value & XtIMTimer)
3084 /* XtAppPending() can be super-slow, esp. over a network connection.
3085 Quantify results have indicated that in some cases the
3086 call to detect_input_pending() completely dominates the
3087 running time of redisplay(). Fortunately, in a SIGIO world
3088 we can more quickly determine whether there are any X events:
3089 if an event has happened since the last time we checked, then
3090 a SIGIO will have happened. On a machine with broken SIGIO,
3091 we'll still be in an OK state -- the sigio_happened flag
3092 will get set at least once a second, so we'll be no more than
3093 one second behind reality. (In general it's OK if we
3094 erroneously report no input pending when input is actually
3095 pending() -- preemption is just a bit less efficient, that's
3096 all. It's bad bad bad if you err the other way -- you've
3097 promised that `next-event' won't block but it actually will,
3098 and some action might get delayed until the next time you
3102 /* quit_check_signal_tick_count is volatile so try to avoid race conditions
3103 by using a temporary variable */
3104 tick_count_val = quit_check_signal_tick_count;
3105 if (last_quit_check_signal_tick_count != tick_count_val
3106 #if !defined (SIGIO) || defined (CYGWIN)
3107 || (XtIMXEvent & XtAppPending (Xt_app_con))
3111 last_quit_check_signal_tick_count = tick_count_val;
3113 /* We need to drain the entire queue now -- if we only
3114 drain part of it, we may later on end up with events
3115 actually pending but detect_input_pending() returning
3116 false because there wasn't another SIGIO. */
3119 EVENT_CHAIN_LOOP (event, dispatch_event_queue)
3120 if (!user_p || command_event_p (event))
3128 emacs_Xt_current_event_timestamp (struct console *c)
3131 Lisp_Object devs = CONSOLE_DEVICE_LIST (c);
3137 struct device *d = XDEVICE (XCAR (devs));
3138 return DEVICE_X_LAST_SERVER_TIMESTAMP (d);
3143 /************************************************************************/
3144 /* replacement for standard string-to-pixel converter */
3145 /************************************************************************/
3147 /* This was constructed by ripping off the standard string-to-pixel
3148 converter from Converters.c in the Xt source code and modifying
3153 /* This is exported by the Xt library (at least by mine). If this
3154 isn't the case somewhere, rename this appropriately and remove
3155 the '#if 0'. Note, however, that I got "unknown structure"
3156 errors when I tried this. */
3157 XtConvertArgRec Const colorConvertArgs[] = {
3158 { XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
3159 sizeof (Screen *) },
3160 { XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
3166 #define done(type, value) \
3167 if (toVal->addr != NULL) { \
3168 if (toVal->size < sizeof(type)) { \
3169 toVal->size = sizeof(type); \
3172 *(type*)(toVal->addr) = (value); \
3174 static type static_val; \
3175 static_val = (value); \
3176 toVal->addr = (XPointer)&static_val; \
3178 toVal->size = sizeof(type); \
3179 return True /* Caller supplies `;' */
3181 /* JH: We use this because I think there's a possibility this
3182 is called before the device is properly set up, in which case
3183 I don't want to ABORT. */
3184 extern struct device *get_device_from_display_1 (Display *dpy);
3187 Boolean EmacsXtCvtStringToPixel (
3191 XrmValuePtr fromVal,
3193 XtPointer *closure_ret)
3195 String str = (String)fromVal->addr;
3204 Cardinal num_params = 1;
3205 XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
3207 if (*num_args != 2) {
3208 XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
3210 "String to pixel conversion needs screen and colormap arguments",
3211 (String *)NULL, (Cardinal *)NULL);
3215 screen = *((Screen **) args[0].addr);
3216 colormap = *((Colormap *) args[1].addr);
3218 /* The original uses the private function CompareISOLatin1().
3219 Use XmuCompareISOLatin1() if you want, but I don't think it
3220 makes any difference here. */
3221 if (strcmp(str, XtDefaultBackground) == 0) {
3222 *closure_ret = False;
3223 /* This refers to the display's "*reverseVideo" resource.
3224 These display resources aren't documented anywhere that
3225 I can find, so I'm going to ignore this. */
3226 /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */
3227 done(Pixel, WhitePixelOfScreen(screen));
3229 if (strcmp(str, XtDefaultForeground) == 0) {
3230 *closure_ret = False;
3231 /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */
3232 done(Pixel, BlackPixelOfScreen(screen));
3235 /* Originally called XAllocNamedColor() here. */
3236 if ((d = get_device_from_display_1(dpy))) {
3237 visual = DEVICE_X_VISUAL(d);
3238 if (colormap != DEVICE_X_COLORMAP(d)) {
3239 XtAppWarningMsg(the_app_con, "weirdColormap", "cvtStringToPixel",
3241 "The colormap passed to cvtStringToPixel doesn't match the one registered to the device.\n",
3243 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
3245 status = XParseColor (dpy, colormap, (char*)str, &screenColor);
3247 status = allocate_nearest_color (dpy, colormap, visual, &screenColor);
3251 /* We haven't set up this device totally yet, so just punt */
3252 status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
3256 /* Server returns a specific error code but Xlib discards it. Ugh */
3257 if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
3258 &exactColor, &screenColor)) {
3259 XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
3261 "Cannot allocate colormap entry for \"%s\"",
3262 params, &num_params);
3265 XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
3267 "Color name \"%s\" is not defined", params, &num_params);
3270 *closure_ret = False;
3273 *closure_ret = (char*)True;
3274 done(Pixel, screenColor.pixel);
3279 static void EmacsFreePixel (
3286 if (*num_args != 2) {
3287 XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError",
3288 "Freeing a pixel requires screen and colormap arguments",
3289 (String *)NULL, (Cardinal *)NULL);
3294 Screen *screen = *((Screen **) args[0].addr);
3295 Colormap colormap = *((Colormap *) args[1].addr);
3296 XFreeColors(DisplayOfScreen(screen), colormap,
3297 (unsigned long*)toVal->addr, 1, (unsigned long)0);
3302 /************************************************************************/
3303 /* handle focus changes for native widgets */
3304 /************************************************************************/
3306 emacs_Xt_event_widget_focus_in (Widget w,
3309 Cardinal *num_params)
3312 x_any_widget_or_parent_to_frame (get_device_from_display (event->xany.display), w);
3314 XtSetKeyboardFocus (FRAME_X_SHELL_WIDGET (f), w);
3318 emacs_Xt_event_widget_focus_out (Widget w,
3321 Cardinal *num_params)
3325 static XtActionsRec widgetActionsList[] =
3327 {"widget-focus-in", emacs_Xt_event_widget_focus_in },
3328 {"widget-focus-out", emacs_Xt_event_widget_focus_out },
3332 emacs_Xt_event_add_widget_actions (XtAppContext ctx)
3334 XtAppAddActions (ctx, widgetActionsList, 2);
3338 /************************************************************************/
3339 /* initialization */
3340 /************************************************************************/
3343 syms_of_event_Xt (void)
3345 defsymbol (&Qkey_mapping, "key-mapping");
3346 defsymbol (&Qsans_modifiers, "sans-modifiers");
3347 defsymbol (&Qself_insert_command, "self-insert-command");
3351 reinit_vars_of_event_Xt (void)
3353 Xt_event_stream = xnew (struct event_stream);
3354 Xt_event_stream->event_pending_p = emacs_Xt_event_pending_p;
3355 Xt_event_stream->force_event_pending = emacs_Xt_force_event_pending;
3356 Xt_event_stream->next_event_cb = emacs_Xt_next_event;
3357 Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
3358 Xt_event_stream->add_timeout_cb = emacs_Xt_add_timeout;
3359 Xt_event_stream->remove_timeout_cb = emacs_Xt_remove_timeout;
3360 Xt_event_stream->select_console_cb = emacs_Xt_select_console;
3361 Xt_event_stream->unselect_console_cb = emacs_Xt_unselect_console;
3362 Xt_event_stream->select_process_cb = emacs_Xt_select_process;
3363 Xt_event_stream->unselect_process_cb = emacs_Xt_unselect_process;
3364 Xt_event_stream->quit_p_cb = emacs_Xt_quit_p;
3365 Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
3366 Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
3367 Xt_event_stream->current_event_timestamp_cb =
3368 emacs_Xt_current_event_timestamp;
3370 the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
3372 last_quit_check_signal_tick_count = 0;
3374 /* this function only makes safe calls */
3375 init_what_input_once ();
3379 vars_of_event_Xt (void)
3381 reinit_vars_of_event_Xt ();
3383 dispatch_event_queue = Qnil;
3384 staticpro (&dispatch_event_queue);
3385 dispatch_event_queue_tail = Qnil;
3386 dump_add_root_object (&dispatch_event_queue_tail);
3388 DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /*
3389 *Non-nil means to allow synthetic events. Nil means they are ignored.
3390 Beware: allowing emacs to process SendEvents opens a big security hole.
3392 x_allow_sendevents = 0;
3395 DEFVAR_INT ("debug-x-events", &debug_x_events /*
3396 If non-zero, display debug information about X events that XEmacs sees.
3397 Information is displayed on stderr. Currently defined values are:
3399 1 == non-verbose output
3406 /* This mess is a hack that patches the shell widget to treat visual inheritance
3407 the same as colormap and depth inheritance */
3409 static XtInitProc orig_shell_init_proc;
3411 static void ShellVisualPatch(Widget wanted, Widget new,
3412 ArgList args, Cardinal *num_args)
3415 ShellWidget w = (ShellWidget) new;
3417 /* first, call the original setup */
3418 (*orig_shell_init_proc)(wanted, new, args, num_args);
3420 /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */
3421 if (w->shell.visual == CopyFromParent) {
3423 while (p && !XtIsShell(p)) p = XtParent(p);
3424 if (p) w->shell.visual = ((ShellWidget)p)->shell.visual;
3429 init_event_Xt_late (void) /* called when already initialized */
3431 timeout_id_tick = 1;
3432 pending_timeouts = NULL;
3433 completed_timeouts_head = NULL; /* queue is empty */
3434 completed_timeouts_tail = NULL; /* just to be picky */
3436 event_stream = Xt_event_stream;
3438 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
3439 Initialize_Locale();
3440 #endif /* HAVE_XIM || USE_XFONTSET */
3442 XtToolkitInitialize ();
3443 Xt_app_con = XtCreateApplicationContext ();
3444 XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
3447 x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
3448 XSetErrorHandler (x_error_handler);
3449 XSetIOErrorHandler (x_IO_error_handler);
3451 #ifndef WIN32_NATIVE
3452 XtAppAddInput (Xt_app_con, signal_event_pipe[0],
3453 (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
3454 Xt_what_callback, 0);
3457 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel,
3458 EmacsXtCvtStringToPixel,
3459 (XtConvertArgList) colorConvertArgs,
3460 2, XtCacheByDisplay, EmacsFreePixel);
3463 XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
3464 EmacsXtCvtStringToXIMStyles,
3466 XtCacheByDisplay, EmacsFreeXIMStyles);
3467 #endif /* XIM_XLIB */
3468 /* Add extra actions to native widgets to handle focus and friends. */
3469 emacs_Xt_event_add_widget_actions (Xt_app_con);
3471 /* insert the visual inheritance patch/hack described above */
3472 orig_shell_init_proc = shellClassRec.core_class.initialize;
3473 shellClassRec.core_class.initialize = ShellVisualPatch;