XEmacs 21.2.20 "Yoko".
[chise/xemacs-chise.git-] / src / event-Xt.c
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.
5
6 This file is part of XEmacs.
7
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
11 later version.
12
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
16 for more details.
17
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.  */
22
23 /* Synched up with: Not in FSF. */
24
25 #include <config.h>
26 #include "lisp.h"
27
28 #include "console-x.h"
29 #include "../lwlib/lwlib.h"
30 #include "EmacsFrame.h"
31
32 #include "blocktype.h"
33 #include "buffer.h"
34 #include "console.h"
35 #include "console-tty.h"
36 #include "events.h"
37 #include "frame.h"
38 #include "objects-x.h"
39 #include "process.h"
40 #include "redisplay.h"
41 #include "elhash.h"
42
43 #include "systime.h"
44 #include "sysproc.h" /* for MAXDESC */
45
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>
51
52 #ifdef HAVE_XIM
53 #ifdef XIM_MOTIF
54 #include <Xm/Xm.h>
55 #endif
56 #include "lstream.h"
57 #include "file-coding.h"
58 #endif
59
60 #ifdef HAVE_DRAGNDROP
61 #include "dragdrop.h"
62 #endif
63
64 #if defined (HAVE_OFFIX_DND)
65 #include "offix.h"
66 #endif
67
68 #ifdef WINDOWSNT
69 /* Hmm, under unix we want X modifiers, under NT we want X modifiers if
70    we are running X and Windows modifiers otherwise.
71    gak. This is a kludge until we support multiple native GUIs!
72 */
73 #undef MOD_ALT
74 #undef MOD_CONTROL
75 #undef MOD_SHIFT
76 #endif
77
78 #include "events-mod.h"
79
80 static void enqueue_Xt_dispatch_event (Lisp_Object event);
81 static void handle_focus_event_1 (struct frame *f, int in_p);
82
83 static struct event_stream *Xt_event_stream;
84
85 /* With the new event model, all events go through XtDispatchEvent()
86    and are picked up by an event handler that is added to each frame
87    widget. (This is how it's supposed to be.) In the old method,
88    Emacs sucks out events directly from XtNextEvent() and only
89    dispatches the events that it doesn't need to deal with.  This
90    old way has lots of corresponding junk that is no longer
91    necessary: lwlib extensions, synthetic XAnyEvents, unnecessary
92    magic events, etc. */
93
94 /* The one and only one application context that Emacs uses. */
95 XtAppContext Xt_app_con;
96
97 /* Do we accept events sent by other clients? */
98 int x_allow_sendevents;
99
100 int modifier_keys_are_sticky;
101
102 #ifdef DEBUG_XEMACS
103 int x_debug_events;
104 #endif
105
106 static int process_events_occurred;
107 static int tty_events_occurred;
108
109 /* Mask of bits indicating the descriptors that we wait for input on */
110 extern SELECT_TYPE input_wait_mask, process_only_mask, tty_only_mask;
111
112 static CONST String x_fallback_resources[] =
113 {
114   /* This file is automatically generated from the app-defaults file
115      in ../etc/Emacs.ad.  These resources are consulted only if no
116      app-defaults file is found at all.
117    */
118 #include <Emacs.ad.h>
119   0
120 };
121
122 static Lisp_Object x_keysym_to_emacs_keysym (KeySym keysym, int simple_p);
123 void emacs_Xt_mapping_action (Widget w, XEvent *event);
124 void debug_process_finalization (struct Lisp_Process *p);
125 void emacs_Xt_event_handler (Widget wid, XtPointer closure, XEvent *event,
126                              Boolean *continue_to_dispatch);
127
128 static int last_quit_check_signal_tick_count;
129
130 Lisp_Object Qkey_mapping;
131 Lisp_Object Qsans_modifiers;
132
133 \f
134 /************************************************************************/
135 /*                            keymap handling                           */
136 /************************************************************************/
137
138 /* X bogusly doesn't define the interpretations of any bits besides
139    ModControl, ModShift, and ModLock; so the Interclient Communication
140    Conventions Manual says that we have to bend over backwards to figure
141    out what the other modifier bits mean.  According to ICCCM:
142
143    - Any keycode which is assigned ModControl is a "control" key.
144
145    - Any modifier bit which is assigned to a keycode which generates Meta_L
146      or Meta_R is the modifier bit meaning "meta".  Likewise for Super, Hyper,
147      etc.
148
149    - Any keypress event which contains ModControl in its state should be
150      interpreted as a "control" character.
151
152    - Any keypress event which contains a modifier bit in its state which is
153      generated by a keycode whose corresponding keysym is Meta_L or Meta_R
154      should be interpreted as a "meta" character.  Likewise for Super, Hyper,
155      etc.
156
157    - It is illegal for a keysym to be associated with more than one modifier
158      bit.
159
160    This means that the only thing that emacs can reasonably interpret as a
161    "meta" key is a key whose keysym is Meta_L or Meta_R, and which generates
162    one of the modifier bits Mod1-Mod5.
163
164    Unfortunately, many keyboards don't have Meta keys in their default
165    configuration.  So, if there are no Meta keys, but there are "Alt" keys,
166    emacs will interpret Alt as Meta.  If there are both Meta and Alt keys,
167    then the Meta keys mean "Meta", and the Alt keys mean "Alt" (it used to
168    mean "Symbol," but that just confused the hell out of way too many people).
169
170    This works with the default configurations of the 19 keyboard-types I've
171    checked.
172
173    Emacs detects keyboard configurations which violate the above rules, and
174    prints an error message on the standard-error-output.  (Perhaps it should
175    use a pop-up-window instead.)
176  */
177
178 static void
179 x_reset_key_mapping (struct device *d)
180 {
181   Display *display = DEVICE_X_DISPLAY (d);
182   struct x_device *xd = DEVICE_X_DATA (d);
183   KeySym *keysym, *keysym_end;
184   Lisp_Object hash_table;
185   int key_code_count, keysyms_per_code;
186
187   if (xd->x_keysym_map)
188     XFree ((char *) xd->x_keysym_map);
189   XDisplayKeycodes (display,
190                     &xd->x_keysym_map_min_code,
191                     &xd->x_keysym_map_max_code);
192   key_code_count = xd->x_keysym_map_max_code - xd->x_keysym_map_min_code + 1;
193   xd->x_keysym_map =
194     XGetKeyboardMapping (display, xd->x_keysym_map_min_code, key_code_count,
195                          &xd->x_keysym_map_keysyms_per_code);
196
197   hash_table = xd->x_keysym_map_hash_table;
198   if (HASH_TABLEP (hash_table))
199     Fclrhash (hash_table);
200   else
201     xd->x_keysym_map_hash_table = hash_table =
202       make_lisp_hash_table (128, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
203
204   for (keysym = xd->x_keysym_map,
205          keysyms_per_code = xd->x_keysym_map_keysyms_per_code,
206          keysym_end = keysym + (key_code_count * keysyms_per_code);
207        keysym < keysym_end;
208        keysym += keysyms_per_code)
209     {
210       int j;
211
212       if (keysym[0] == NoSymbol)
213         continue;
214
215       {
216         char *name = XKeysymToString (keysym[0]);
217         Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[0], 0);
218         if (name)
219           {
220             Fputhash (build_string (name), Qsans_modifiers, hash_table);
221             Fputhash (sym, Qsans_modifiers, hash_table);
222           }
223       }
224
225       for (j = 1; j < keysyms_per_code; j++)
226         {
227           if (keysym[j] != keysym[0] &&
228               keysym[j] != NoSymbol)
229             {
230               char *name = XKeysymToString (keysym[j]);
231               Lisp_Object sym = x_keysym_to_emacs_keysym (keysym[j], 0);
232               if (name && NILP (Fgethash (sym, hash_table, Qnil)))
233                 {
234                   Fputhash (build_string (name), Qt, hash_table);
235                   Fputhash (sym, Qt, hash_table);
236                 }
237             }
238         }
239     }
240 }
241
242 static CONST char *
243 index_to_name (int indice)
244 {
245   switch (indice)
246     {
247     case ShiftMapIndex:   return "ModShift";
248     case LockMapIndex:    return "ModLock";
249     case ControlMapIndex: return "ModControl";
250     case Mod1MapIndex:    return "Mod1";
251     case Mod2MapIndex:    return "Mod2";
252     case Mod3MapIndex:    return "Mod3";
253     case Mod4MapIndex:    return "Mod4";
254     case Mod5MapIndex:    return "Mod5";
255     default:              return "???";
256     }
257 }
258
259 /* Boy, I really wish C had local functions... */
260 struct c_doesnt_have_closures   /* #### not yet used */
261 {
262   int warned_about_overlapping_modifiers;
263   int warned_about_predefined_modifiers;
264   int warned_about_duplicate_modifiers;
265   int meta_bit;
266   int hyper_bit;
267   int super_bit;
268   int alt_bit;
269   int mode_bit;
270 };
271
272 static void
273 x_reset_modifier_mapping (struct device *d)
274 {
275   Display *display = DEVICE_X_DISPLAY (d);
276   struct x_device *xd = DEVICE_X_DATA (d);
277   int modifier_index, modifier_key, column, mkpm;
278   int warned_about_overlapping_modifiers = 0;
279   int warned_about_predefined_modifiers  = 0;
280   int warned_about_duplicate_modifiers   = 0;
281   int meta_bit  = 0;
282   int hyper_bit = 0;
283   int super_bit = 0;
284   int alt_bit   = 0;
285   int mode_bit  = 0;
286
287   xd->lock_interpretation = 0;
288
289   if (xd->x_modifier_keymap)
290     XFreeModifiermap (xd->x_modifier_keymap);
291
292   x_reset_key_mapping (d);
293
294   xd->x_modifier_keymap = XGetModifierMapping (display);
295
296   /* Boy, I really wish C had local functions...
297    */
298
299   /* The call to warn_when_safe must be on the same line as the string or
300      make-msgfile won't pick it up properly (the newline doesn't confuse
301      it, but the backslash does). */
302
303 #define modwarn(name,old,other)                                         \
304   warn_when_safe (Qkey_mapping, Qwarning, "XEmacs:  %s (0x%x) generates %s, which is generated by %s.", \
305                   name, code, index_to_name (old), other),              \
306   warned_about_overlapping_modifiers = 1
307
308 #define modbarf(name,other)                                                 \
309   warn_when_safe (Qkey_mapping, Qwarning, "XEmacs:  %s (0x%x) generates %s, which is nonsensical.", \
310                   name, code, other),                                       \
311   warned_about_predefined_modifiers = 1
312
313 #define check_modifier(name,mask)                                             \
314   if ((1<<modifier_index) != mask)                                            \
315     warn_when_safe (Qkey_mapping, Qwarning, "XEmacs:  %s (0x%x) generates %s, which is nonsensical.", \
316                     name, code, index_to_name (modifier_index)),              \
317     warned_about_predefined_modifiers = 1
318
319 #define store_modifier(name,old)                                           \
320   if (old && old != modifier_index)                                        \
321     warn_when_safe (Qkey_mapping, Qwarning, "XEmacs:  %s (0x%x) generates both %s and %s, which is nonsensical.",\
322                     name, code, index_to_name (old),                       \
323                     index_to_name (modifier_index)),                       \
324     warned_about_duplicate_modifiers = 1;                                  \
325   if (modifier_index == ShiftMapIndex) modbarf (name,"ModShift");          \
326   else if (modifier_index == LockMapIndex) modbarf (name,"ModLock");       \
327   else if (modifier_index == ControlMapIndex) modbarf (name,"ModControl"); \
328   else if (sym == XK_Mode_switch)                                          \
329     mode_bit = modifier_index; /* Mode_switch is special, see below... */  \
330   else if (modifier_index == meta_bit && old != meta_bit)                  \
331     modwarn (name, meta_bit, "Meta");                                      \
332   else if (modifier_index == super_bit && old != super_bit)                \
333     modwarn (name, super_bit, "Super");                                    \
334   else if (modifier_index == hyper_bit && old != hyper_bit)                \
335     modwarn (name, hyper_bit, "Hyper");                                    \
336   else if (modifier_index == alt_bit && old != alt_bit)                    \
337     modwarn (name, alt_bit, "Alt");                                        \
338   else                                                                     \
339     old = modifier_index;
340
341   mkpm = xd->x_modifier_keymap->max_keypermod;
342   for (modifier_index = 0; modifier_index < 8; modifier_index++)
343     for (modifier_key = 0; modifier_key < mkpm; modifier_key++) {
344       KeySym last_sym = 0;
345       for (column = 0; column < 4; column += 2) {
346         KeyCode code = xd->x_modifier_keymap->modifiermap[modifier_index * mkpm
347                                                           + modifier_key];
348         KeySym sym = (code ? XKeycodeToKeysym (display, code, column) : 0);
349         if (sym == last_sym) continue;
350         last_sym = sym;
351         switch (sym) {
352         case XK_Mode_switch:store_modifier ("Mode_switch", mode_bit); break;
353         case XK_Meta_L:     store_modifier ("Meta_L", meta_bit); break;
354         case XK_Meta_R:     store_modifier ("Meta_R", meta_bit); break;
355         case XK_Super_L:    store_modifier ("Super_L", super_bit); break;
356         case XK_Super_R:    store_modifier ("Super_R", super_bit); break;
357         case XK_Hyper_L:    store_modifier ("Hyper_L", hyper_bit); break;
358         case XK_Hyper_R:    store_modifier ("Hyper_R", hyper_bit); break;
359         case XK_Alt_L:      store_modifier ("Alt_L", alt_bit); break;
360         case XK_Alt_R:      store_modifier ("Alt_R", alt_bit); break;
361         case XK_Control_L:  check_modifier ("Control_L", ControlMask); break;
362         case XK_Control_R:  check_modifier ("Control_R", ControlMask); break;
363         case XK_Shift_L:    check_modifier ("Shift_L", ShiftMask); break;
364         case XK_Shift_R:    check_modifier ("Shift_R", ShiftMask); break;
365         case XK_Shift_Lock: check_modifier ("Shift_Lock", LockMask);
366           xd->lock_interpretation = XK_Shift_Lock; break;
367         case XK_Caps_Lock:  check_modifier ("Caps_Lock", LockMask);
368           xd->lock_interpretation = XK_Caps_Lock; break;
369
370         /* It probably doesn't make any sense for a modifier bit to be
371            assigned to a key that is not one of the above, but OpenWindows
372            assigns modifier bits to a couple of random function keys for
373            no reason that I can discern, so printing a warning here would
374            be annoying. */
375         }
376       }
377     }
378 #undef store_modifier
379 #undef check_modifier
380 #undef modwarn
381 #undef modbarf
382
383   /* If there was no Meta key, then try using the Alt key instead.
384      If there is both a Meta key and an Alt key, then the Alt key
385      is not disturbed and remains an Alt key. */
386   if (! meta_bit && alt_bit)
387     meta_bit = alt_bit, alt_bit = 0;
388
389   /* mode_bit overrides everything, since it's processed down inside of
390      XLookupString() instead of by us.  If Meta and Mode_switch both
391      generate the same modifier bit (which is an error), then we don't
392      interpret that bit as Meta, because we can't make XLookupString()
393      not interpret it as Mode_switch; and interpreting it as both would
394      be totally wrong. */
395   if (mode_bit)
396     {
397       CONST char *warn = 0;
398       if      (mode_bit == meta_bit)  warn = "Meta",  meta_bit  = 0;
399       else if (mode_bit == hyper_bit) warn = "Hyper", hyper_bit = 0;
400       else if (mode_bit == super_bit) warn = "Super", super_bit = 0;
401       else if (mode_bit == alt_bit)   warn = "Alt",   alt_bit   = 0;
402       if (warn)
403         {
404           warn_when_safe
405             (Qkey_mapping, Qwarning,
406              "XEmacs:  %s is being used for both Mode_switch and %s.",
407              index_to_name (mode_bit), warn),
408             warned_about_overlapping_modifiers = 1;
409         }
410     }
411 #undef index_to_name
412
413   xd->MetaMask   = (meta_bit   ? (1 << meta_bit)  : 0);
414   xd->HyperMask  = (hyper_bit  ? (1 << hyper_bit) : 0);
415   xd->SuperMask  = (super_bit  ? (1 << super_bit) : 0);
416   xd->AltMask    = (alt_bit    ? (1 << alt_bit)   : 0);
417   xd->ModeMask   = (mode_bit   ? (1 << mode_bit)  : 0); /* unused */
418
419
420   if (warned_about_overlapping_modifiers)
421     warn_when_safe (Qkey_mapping, Qwarning, "\n"
422 "       Two distinct modifier keys (such as Meta and Hyper) cannot generate\n"
423 "       the same modifier bit, because Emacs won't be able to tell which\n"
424 "       modifier was actually held down when some other key is pressed.  It\n"
425 "       won't be able to tell Meta-x and Hyper-x apart, for example.  Change\n"
426 "       one of these keys to use some other modifier bit.  If you intend for\n"
427 "       these keys to have the same behavior, then change them to have the\n"
428 "       same keysym as well as the same modifier bit.");
429
430   if (warned_about_predefined_modifiers)
431     warn_when_safe (Qkey_mapping, Qwarning, "\n"
432 "       The semantics of the modifier bits ModShift, ModLock, and ModControl\n"
433 "       are predefined.  It does not make sense to assign ModControl to any\n"
434 "       keysym other than Control_L or Control_R, or to assign any modifier\n"
435 "       bits to the \"control\" keysyms other than ModControl.  You can't\n"
436 "       turn a \"control\" key into a \"meta\" key (or vice versa) by simply\n"
437 "       assigning the key a different modifier bit.  You must also make that\n"
438 "       key generate an appropriate keysym (Control_L, Meta_L, etc).");
439
440   /* No need to say anything more for warned_about_duplicate_modifiers. */
441
442   if (warned_about_overlapping_modifiers || warned_about_predefined_modifiers)
443     warn_when_safe (Qkey_mapping, Qwarning, "\n"
444 "       The meanings of the modifier bits Mod1 through Mod5 are determined\n"
445 "       by the keysyms used to control those bits.  Mod1 does NOT always\n"
446 "       mean Meta, although some non-ICCCM-compliant programs assume that.");
447 }
448
449 void
450 x_init_modifier_mapping (struct device *d)
451 {
452   struct x_device *xd = DEVICE_X_DATA (d);
453   xd->x_keysym_map_hash_table = Qnil;
454   xd->x_keysym_map = NULL;
455   xd->x_modifier_keymap = NULL;
456   x_reset_modifier_mapping (d);
457 }
458
459 static int
460 x_key_is_modifier_p (KeyCode keycode, struct device *d)
461 {
462   struct x_device *xd = DEVICE_X_DATA (d);
463   KeySym *syms;
464   int i;
465
466   if (keycode < xd->x_keysym_map_min_code ||
467       keycode > xd->x_keysym_map_max_code)
468     return 0;
469
470   syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
471                            xd->x_keysym_map_keysyms_per_code];
472   for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
473     if (IsModifierKey (syms [i]) ||
474         syms [i] == XK_Mode_switch) /* why doesn't IsModifierKey count this? */
475       return 1;
476   return 0;
477 }
478
479 /* key-handling code is always ugly.  It just ends up working out
480    that way.
481
482    Here are some pointers:
483
484    -- DOWN_MASK indicates which modifiers should be treated as "down"
485       when the corresponding upstroke happens.  It gets reset for
486       a particular modifier when that modifier goes up, and reset
487       for all modifiers when a non-modifier key is pressed.  Example:
488
489       I press Control-A-Shift and then release Control-A-Shift.
490       I want the Shift key to be sticky but not the Control key.
491
492    -- LAST_DOWNKEY and RELEASE_TIME are used to keep track of
493       auto-repeat -- see below.
494
495    -- If a modifier key is sticky, I can unstick it by pressing
496       the modifier key again. */
497
498 static void
499 x_handle_sticky_modifiers (XEvent *ev, struct device *d)
500 {
501   struct x_device *xd;
502   KeyCode keycode;
503   int type;
504
505   if (!modifier_keys_are_sticky) /* Optimize for non-sticky modifiers */
506     return;
507
508   xd = DEVICE_X_DATA (d);
509   keycode = ev->xkey.keycode;
510   type = ev->type;
511
512   if (keycode < xd->x_keysym_map_min_code ||
513       keycode > xd->x_keysym_map_max_code)
514     return;
515
516   if (! ((type == KeyPress || type == KeyRelease) &&
517          x_key_is_modifier_p (keycode, d)))
518     { /* Not a modifier key */
519       Bool key_event_p = (type == KeyPress || type == KeyRelease);
520
521       if (type == KeyPress && !xd->last_downkey)
522         xd->last_downkey = keycode;
523       else if (type == ButtonPress ||
524                (type == KeyPress && xd->last_downkey &&
525                 (keycode != xd->last_downkey ||
526                  ev->xkey.time != xd->release_time)))
527         {
528           xd->need_to_add_mask = 0;
529           xd->last_downkey = 0;
530         }
531       if (type == KeyPress)
532         xd->release_time = 0;
533       if (type == KeyPress || type == ButtonPress)
534         xd->down_mask = 0;
535
536       if (key_event_p)
537         ev->xkey.state    |= xd->need_to_add_mask;
538       else
539         ev->xbutton.state |= xd->need_to_add_mask;
540
541       if (type == KeyRelease && keycode == xd->last_downkey)
542         /* If I hold press-and-release the Control key and then press
543            and hold down the right arrow, I want it to auto-repeat
544            Control-Right.  On the other hand, if I do the same but
545            manually press the Right arrow a bunch of times, I want
546            to see one Control-Right and then a bunch of Rights.
547            This means that we need to distinguish between an
548            auto-repeated key and a key pressed and released a bunch
549            of times.
550
551            Naturally, the designers of the X spec didn't see fit
552            to provide an obvious way to distinguish these cases.
553            So we assume that if the release and the next press
554            occur at the same time, the key was actually auto-
555            repeated.  Under Open-Windows, at least, this works. */
556         xd->release_time = key_event_p ? ev->xkey.time : ev->xbutton.time;
557     }
558   else                          /* Modifier key pressed */
559     {
560       int i;
561       KeySym *syms = &xd->x_keysym_map [(keycode - xd->x_keysym_map_min_code) *
562                                         xd->x_keysym_map_keysyms_per_code];
563
564       /* If a non-modifier key was pressed in the middle of a bunch
565          of modifiers, then it unsticks all the modifiers that were
566          previously pressed.  We cannot unstick the modifiers until
567          now because we want to check for auto-repeat of the
568          non-modifier key. */
569
570       if (xd->last_downkey)
571         {
572           xd->last_downkey = 0;
573           xd->need_to_add_mask = 0;
574         }
575
576 #define FROB(mask)                              \
577 do {                                            \
578   if (type == KeyPress)                         \
579     {                                           \
580       /* If modifier key is already sticky,     \
581          then unstick it.  Note that we do      \
582          not test down_mask to deal with the    \
583          unlikely but possible case that the    \
584          modifier key auto-repeats. */          \
585       if (xd->need_to_add_mask & mask)          \
586         {                                       \
587           xd->need_to_add_mask &= ~mask;        \
588           xd->down_mask &= ~mask;               \
589         }                                       \
590       else                                      \
591         xd->down_mask |= mask;                  \
592     }                                           \
593   else                                          \
594     {                                           \
595       if (xd->down_mask & mask)                 \
596         {                                       \
597           xd->down_mask &= ~mask;               \
598           xd->need_to_add_mask |= mask;         \
599         }                                       \
600     }                                           \
601 } while (0)
602
603       for (i = 0; i < xd->x_keysym_map_keysyms_per_code; i++)
604         switch (syms[i])
605           {
606           case XK_Control_L: case XK_Control_R: FROB (ControlMask);   break;
607           case XK_Shift_L:   case XK_Shift_R:   FROB (ShiftMask);     break;
608           case XK_Meta_L:    case XK_Meta_R:    FROB (xd->MetaMask);  break;
609           case XK_Super_L:   case XK_Super_R:   FROB (xd->SuperMask); break;
610           case XK_Hyper_L:   case XK_Hyper_R:   FROB (xd->HyperMask); break;
611           case XK_Alt_L:     case XK_Alt_R:     FROB (xd->AltMask);   break;
612           }
613     }
614 #undef FROB
615 }
616
617 static void
618 clear_sticky_modifiers (struct device *d)
619 {
620   struct x_device *xd = DEVICE_X_DATA (d);
621
622   xd->need_to_add_mask = 0;
623   xd->last_downkey     = 0;
624   xd->release_time     = 0;
625   xd->down_mask        = 0;
626 }
627
628 static int
629 keysym_obeys_caps_lock_p (KeySym sym, struct device *d)
630 {
631   struct x_device *xd = DEVICE_X_DATA (d);
632   /* Eeeeevil hack.  Don't apply Caps_Lock to things that aren't alphabetic
633      characters, where "alphabetic" means something more than simply A-Z.
634      That is, if Caps_Lock is down, typing ESC doesn't produce Shift-ESC.
635      But if shift-lock is down, then it does. */
636   if (xd->lock_interpretation == XK_Shift_Lock)
637     return 1;
638
639   return
640     ((sym >= XK_A)        && (sym <= XK_Z))          ||
641     ((sym >= XK_a)        && (sym <= XK_z))          ||
642     ((sym >= XK_Agrave)   && (sym <= XK_Odiaeresis)) ||
643     ((sym >= XK_agrave)   && (sym <= XK_odiaeresis)) ||
644     ((sym >= XK_Ooblique) && (sym <= XK_Thorn))      ||
645     ((sym >= XK_oslash)   && (sym <= XK_thorn));
646 }
647
648 /* called from EmacsFrame.c (actually from Xt itself) when a
649    MappingNotify event is received.  In its infinite wisdom, Xt
650    decided that Xt event handlers never get MappingNotify events.
651    O'Reilly Xt Programming Manual 9.1.2 says:
652
653    MappingNotify is automatically handled by Xt, so it isn't passed
654    to event handlers and you don't need to worry about it.
655
656    Of course, we DO worry about it, so we need a special translation. */
657 void
658 emacs_Xt_mapping_action (Widget w, XEvent* event)
659 {
660   struct device *d = get_device_from_display (event->xany.display);
661
662   if (DEVICE_X_BEING_DELETED (d))
663     return;
664 #if 0
665   /* nyet.  Now this is handled by Xt. */
666   XRefreshKeyboardMapping (&event->xmapping);
667 #endif
668   /* xmodmap generates about a billion MappingKeyboard events, followed
669      by a single MappingModifier event, so it might be worthwhile to
670      take extra MappingKeyboard events out of the queue before requesting
671      the current keymap from the server. */
672   switch (event->xmapping.request)
673     {
674     case MappingKeyboard:  x_reset_key_mapping      (d); break;
675     case MappingModifier:  x_reset_modifier_mapping (d); break;
676     case MappingPointer:   /* Do something here? */      break;
677     default: abort();
678     }
679 }
680
681 \f
682 /************************************************************************/
683 /*                  X to Emacs event conversion                         */
684 /************************************************************************/
685
686 static Lisp_Object
687 x_keysym_to_emacs_keysym (KeySym keysym, int simple_p)
688 {
689   char *name;
690   if (keysym >= XK_exclam && keysym <= XK_asciitilde)
691     /* We must assume that the X keysym numbers for the ASCII graphic
692        characters are the same as their ASCII codes.  */
693     return make_char (keysym);
694
695   switch (keysym)
696     {
697       /* These would be handled correctly by the default case, but by
698          special-casing them here we don't garbage a string or call
699          intern().  */
700     case XK_BackSpace:  return QKbackspace;
701     case XK_Tab:        return QKtab;
702     case XK_Linefeed:   return QKlinefeed;
703     case XK_Return:     return QKreturn;
704     case XK_Escape:     return QKescape;
705     case XK_space:      return QKspace;
706     case XK_Delete:     return QKdelete;
707     case 0:             return Qnil;
708     default:
709       if (simple_p) return Qnil;
710       /* !!#### not Mule-ized */
711       name = XKeysymToString (keysym);
712       if (!name || !name[0])
713         /* This happens if there is a mismatch between the Xlib of
714            XEmacs and the Xlib of the X server...
715
716            Let's hard-code in some knowledge of common keysyms introduced
717            in recent X11 releases.  Snarfed from X11/keysymdef.h
718
719            Probably we should add some stuff here for X11R6. */
720         switch (keysym)
721           {
722           case 0xFF95: return KEYSYM ("kp-home");
723           case 0xFF96: return KEYSYM ("kp-left");
724           case 0xFF97: return KEYSYM ("kp-up");
725           case 0xFF98: return KEYSYM ("kp-right");
726           case 0xFF99: return KEYSYM ("kp-down");
727           case 0xFF9A: return KEYSYM ("kp-prior");
728           case 0xFF9B: return KEYSYM ("kp-next");
729           case 0xFF9C: return KEYSYM ("kp-end");
730           case 0xFF9D: return KEYSYM ("kp-begin");
731           case 0xFF9E: return KEYSYM ("kp-insert");
732           case 0xFF9F: return KEYSYM ("kp-delete");
733
734           case 0x1005FF10: return KEYSYM ("SunF36"); /* labeled F11 */
735           case 0x1005FF11: return KEYSYM ("SunF37"); /* labeled F12 */
736           default:
737             {
738               char buf [64];
739               sprintf (buf, "unknown-keysym-0x%X", (int) keysym);
740               return KEYSYM (buf);
741             }
742           }
743       /* If it's got a one-character name, that's good enough. */
744       if (!name[1])
745         return make_char (name[0]);
746
747       /* If it's in the "Keyboard" character set, downcase it.
748          The case of those keysyms is too totally random for us to
749          force anyone to remember them.
750          The case of the other character sets is significant, however.
751          */
752       if ((((unsigned int) keysym) & (~0x1FF)) == ((unsigned int) 0xFE00))
753         {
754           char buf [255];
755           char *s1, *s2;
756           for (s1 = name, s2 = buf; *s1; s1++, s2++) {
757             if (*s1 == '_') {
758               *s2 = '-';
759             } else {
760               *s2 = tolower (* (unsigned char *) s1);
761             }
762           }
763           *s2 = 0;
764           return KEYSYM (buf);
765         }
766       return KEYSYM (name);
767     }
768 }
769
770 static Lisp_Object
771 x_to_emacs_keysym (XKeyPressedEvent *event, int simple_p)
772      /* simple_p means don't try too hard (ASCII only) */
773 {
774   KeySym keysym = 0;
775
776 #ifdef HAVE_XIM
777   int len;
778   char buffer[64];
779   char *bufptr = buffer;
780   int   bufsiz = sizeof (buffer);
781   Status status;
782 #ifdef XIM_XLIB
783   XIC xic = FRAME_X_XIC (x_any_window_to_frame
784                          (get_device_from_display (event->display),
785                           event->window));
786 #endif /* XIM_XLIB */
787 #endif /* HAVE_XIM */
788
789   /* We use XLookupString if we're not using XIM, or are using
790      XIM_XLIB but input context creation failed. */
791 #if ! (defined (HAVE_XIM) && defined (XIM_MOTIF))
792 #if defined (HAVE_XIM) && defined (XIM_XLIB)
793      if (!xic)
794 #endif /* XIM_XLIB */
795     {
796       /* Apparently it's necessary to specify a dummy here (rather
797          than passing in 0) to avoid crashes on German IRIX */
798       char dummy[256];
799       XLookupString (event, dummy, 200, &keysym, 0);
800       return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
801         ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
802     }
803 #endif /* ! XIM_MOTIF */
804
805 #ifdef HAVE_XIM
806  Lookup_String: /* Come-From XBufferOverflow */
807 #ifdef XIM_MOTIF
808   len = XmImMbLookupString (XtWindowToWidget (event->display, event->window),
809                             event, bufptr, bufsiz, &keysym, &status);
810 #else /* XIM_XLIB */
811   if (xic)
812     len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
813 #endif /* HAVE_XIM */
814
815 #ifdef DEBUG_XEMACS
816   if (x_debug_events > 0)
817     {
818       stderr_out ("   status=");
819 #define print_status_when(S) if (status == S) stderr_out (#S)
820       print_status_when (XLookupKeySym);
821       print_status_when (XLookupBoth);
822       print_status_when (XLookupChars);
823       print_status_when (XLookupNone);
824       print_status_when (XBufferOverflow);
825
826       if (status == XLookupKeySym || status == XLookupBoth)
827         stderr_out (" keysym=%s",  XKeysymToString (keysym));
828       if (status == XLookupChars  || status == XLookupBoth)
829         {
830           if (len != 1)
831             {
832               int j;
833               stderr_out (" chars=\"");
834               for (j=0; j<len; j++)
835                 stderr_out ("%c", bufptr[j]);
836               stderr_out ("\"");
837             }
838           else if (bufptr[0] <= 32 || bufptr[0] >= 127)
839             stderr_out (" char=0x%x", bufptr[0]);
840           else
841             stderr_out (" char=%c", bufptr[0]);
842         }
843       stderr_out ("\n");
844     }
845 #endif /* DEBUG_XEMACS */
846
847   switch (status)
848     {
849     case XLookupKeySym:
850     case XLookupBoth:
851       return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
852         ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
853
854     case XLookupChars:
855       {
856         /* Generate multiple emacs events */
857         struct device *d = get_device_from_display (event->display);
858         Emchar ch;
859         Lisp_Object instream, fb_instream;
860         Lstream *istr;
861         struct gcpro gcpro1, gcpro2;
862
863         fb_instream =
864           make_fixed_buffer_input_stream ((unsigned char *) bufptr, len);
865
866         /* ### Use Fget_coding_system (Vcomposed_input_coding_system) */
867         instream =
868           make_decoding_input_stream (XLSTREAM (fb_instream),
869                                       Fget_coding_system (Qundecided));
870
871         istr = XLSTREAM (instream);
872
873         GCPRO2 (instream, fb_instream);
874         while ((ch = Lstream_get_emchar (istr)) != EOF)
875           {
876             Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
877             struct Lisp_Event *ev = XEVENT (emacs_event);
878             ev->channel             = DEVICE_CONSOLE (d);
879             ev->event_type          = key_press_event;
880             ev->timestamp           = event->time;
881             ev->event.key.modifiers = 0;
882             ev->event.key.keysym    = make_char (ch);
883             enqueue_Xt_dispatch_event (emacs_event);
884           }
885         Lstream_close (istr);
886         UNGCPRO;
887         Lstream_delete (istr);
888         Lstream_delete (XLSTREAM (fb_instream));
889         return Qnil;
890       }
891     case XLookupNone: return Qnil;
892     case XBufferOverflow:
893       bufptr = (char *) alloca (len+1);
894       bufsiz = len+1;
895       goto Lookup_String;
896     }
897   return Qnil; /* not reached */
898 #endif /* HAVE_XIM */
899 }
900
901 static void
902 set_last_server_timestamp (struct device *d, XEvent *x_event)
903 {
904   Time t;
905   switch (x_event->type)
906     {
907     case KeyPress:
908     case KeyRelease:       t = x_event->xkey.time;              break;
909     case ButtonPress:
910     case ButtonRelease:    t = x_event->xbutton.time;           break;
911     case EnterNotify:
912     case LeaveNotify:      t = x_event->xcrossing.time;         break;
913     case MotionNotify:     t = x_event->xmotion.time;           break;
914     case PropertyNotify:   t = x_event->xproperty.time;         break;
915     case SelectionClear:   t = x_event->xselectionclear.time;   break;
916     case SelectionRequest: t = x_event->xselectionrequest.time; break;
917     case SelectionNotify:  t = x_event->xselection.time;        break;
918     default: return;
919     }
920   DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t;
921 }
922
923 static int
924 x_event_to_emacs_event (XEvent *x_event, struct Lisp_Event *emacs_event)
925 {
926   Display *display    = x_event->xany.display;
927   struct device *d    = get_device_from_display (display);
928   struct x_device *xd = DEVICE_X_DATA (d);
929
930   if (DEVICE_X_BEING_DELETED (d))
931      /* #### Uh, is this 0 correct? */
932      return 0;
933
934   set_last_server_timestamp (d, x_event);
935
936   switch (x_event->type)
937     {
938     case KeyRelease:
939       x_handle_sticky_modifiers (x_event, d);
940       return 0;
941
942     case KeyPress:
943     case ButtonPress:
944     case ButtonRelease:
945       {
946         unsigned int modifiers = 0;
947         int shift_p, lock_p;
948         Bool key_event_p = (x_event->type == KeyPress);
949         unsigned int *state =
950           key_event_p ? &x_event->xkey.state : &x_event->xbutton.state;
951
952         /* If this is a synthetic KeyPress or Button event, and the user
953            has expressed a disinterest in this security hole, then drop
954            it on the floor. */
955         if ((key_event_p
956              ? x_event->xkey.send_event
957              : x_event->xbutton.send_event)
958 #ifdef EXTERNAL_WIDGET
959             /* ben: events get sent to an ExternalShell using XSendEvent.
960                This is not a perfect solution. */
961             && !FRAME_X_EXTERNAL_WINDOW_P
962             (x_any_window_to_frame (d, x_event->xany.window))
963 #endif
964             && !x_allow_sendevents)
965           return 0;
966
967         DEVICE_X_MOUSE_TIMESTAMP (d) =
968           DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
969           key_event_p ? x_event->xkey.time : x_event->xbutton.time;
970
971         x_handle_sticky_modifiers (x_event, d);
972
973         if (*state & ControlMask)    modifiers |= MOD_CONTROL;
974         if (*state & xd->MetaMask)   modifiers |= MOD_META;
975         if (*state & xd->SuperMask)  modifiers |= MOD_SUPER;
976         if (*state & xd->HyperMask)  modifiers |= MOD_HYPER;
977         if (*state & xd->AltMask)    modifiers |= MOD_ALT;
978
979         /* Ignore the Caps_Lock key if:
980            - any other modifiers are down, so that Caps_Lock doesn't
981              turn C-x into C-X, which would suck.
982            - the event was a mouse event. */
983         if (modifiers || ! key_event_p)
984           *state &= (~LockMask);
985
986         shift_p = *state & ShiftMask;
987         lock_p  = *state & LockMask;
988
989         if (shift_p || lock_p)
990           modifiers |= MOD_SHIFT;
991
992         if (key_event_p)
993           {
994             Lisp_Object keysym;
995             XKeyEvent *ev = &x_event->xkey;
996             /* This used to compute the frame from the given X window and
997                store it here, but we really don't care about the frame. */
998             emacs_event->channel = DEVICE_CONSOLE (d);
999             keysym = x_to_emacs_keysym (&x_event->xkey, 0);
1000
1001             /* If the emacs keysym is nil, then that means that the X
1002                keysym was either a Modifier or NoSymbol, which
1003                probably means that we're in the midst of reading a
1004                Multi_key sequence, or a "dead" key prefix, or XIM
1005                input. Ignore it. */
1006             if (NILP (keysym))
1007               return 0;
1008
1009             /* More Caps_Lock garbage: Caps_Lock should *only* add the
1010                shift modifier to two-case keys (that is, A-Z and
1011                related characters). So at this point (after looking up
1012                the keysym) if the keysym isn't a dual-case alphabetic,
1013                and if the caps lock key was down but the shift key
1014                wasn't, then turn off the shift modifier.  Gag barf */
1015             /* #### type lossage: assuming equivalence of emacs and
1016                X keysyms */
1017             /* !!#### maybe fix for Mule */
1018             if (lock_p && !shift_p &&
1019                 ! (CHAR_OR_CHAR_INTP (keysym)
1020                    && keysym_obeys_caps_lock_p
1021                    ((KeySym) XCHAR_OR_CHAR_INT (keysym), d)))
1022               modifiers &= (~MOD_SHIFT);
1023
1024             /* If this key contains two distinct keysyms, that is,
1025                "shift" generates a different keysym than the
1026                non-shifted key, then don't apply the shift modifier
1027                bit: it's implicit.  Otherwise, if there would be no
1028                other way to tell the difference between the shifted
1029                and unshifted version of this key, apply the shift bit.
1030                Non-graphics, like Backspace and F1 get the shift bit
1031                in the modifiers slot.  Neither the characters "a",
1032                "A", "2", nor "@" normally have the shift bit set.
1033                However, "F1" normally does. */
1034             if (modifiers & MOD_SHIFT)
1035               {
1036                 int Mode_switch_p = *state & xd->ModeMask;
1037                 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0);
1038                 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1);
1039                 if (top && bot && top != bot)
1040                   modifiers &= ~MOD_SHIFT;
1041               }
1042             emacs_event->event_type          = key_press_event;
1043             emacs_event->timestamp           = ev->time;
1044             emacs_event->event.key.modifiers = modifiers;
1045             emacs_event->event.key.keysym    = keysym;
1046           }
1047         else                    /* Mouse press/release event */
1048           {
1049             XButtonEvent *ev = &x_event->xbutton;
1050             struct frame *frame = x_window_to_frame (d, ev->window);
1051
1052             if (! frame)
1053               return 0; /* not for us */
1054             XSETFRAME (emacs_event->channel, frame);
1055
1056             emacs_event->event_type = (x_event->type == ButtonPress) ?
1057               button_press_event : button_release_event;
1058
1059             emacs_event->event.button.modifiers = modifiers;
1060             emacs_event->timestamp              = ev->time;
1061             emacs_event->event.button.button    = ev->button;
1062             emacs_event->event.button.x         = ev->x;
1063             emacs_event->event.button.y         = ev->y;
1064             /* because we don't seem to get a FocusIn event for button clicks
1065                when a widget-glyph is selected we will assume that we want the
1066                focus if a button gets pressed. */
1067             if (x_event->type == ButtonPress)
1068               handle_focus_event_1 (frame, 1);
1069           }
1070       }
1071     break;
1072
1073     case MotionNotify:
1074       {
1075         XMotionEvent *ev = &x_event->xmotion;
1076         struct frame *frame = x_window_to_frame (d, ev->window);
1077         unsigned int modifiers = 0;
1078         XMotionEvent event2;
1079
1080         if (! frame)
1081           return 0; /* not for us */
1082
1083         /* We use MotionHintMask, so we will get only one motion event
1084            until the next time we call XQueryPointer or the user
1085            clicks the mouse.  So call XQueryPointer now (meaning that
1086            the event will be in sync with the server just before
1087            Fnext_event() returns).  If the mouse is still in motion,
1088            then the server will immediately generate exactly one more
1089            motion event, which will be on the queue waiting for us
1090            next time around. */
1091         event2 = *ev;
1092         if (XQueryPointer (event2.display, event2.window,
1093                            &event2.root,   &event2.subwindow,
1094                            &event2.x_root, &event2.y_root,
1095                            &event2.x,      &event2.y,
1096                            &event2.state))
1097           ev = &event2; /* only one structure copy */
1098
1099         DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
1100
1101         XSETFRAME (emacs_event->channel, frame);
1102         emacs_event->event_type     = pointer_motion_event;
1103         emacs_event->timestamp      = ev->time;
1104         emacs_event->event.motion.x = ev->x;
1105         emacs_event->event.motion.y = ev->y;
1106         if (ev->state & ShiftMask)      modifiers |= MOD_SHIFT;
1107         if (ev->state & ControlMask)    modifiers |= MOD_CONTROL;
1108         if (ev->state & xd->MetaMask)   modifiers |= MOD_META;
1109         if (ev->state & xd->SuperMask)  modifiers |= MOD_SUPER;
1110         if (ev->state & xd->HyperMask)  modifiers |= MOD_HYPER;
1111         if (ev->state & xd->AltMask)    modifiers |= MOD_ALT;
1112         /* Currently ignores Shift_Lock but probably shouldn't
1113            (but it definitely should ignore Caps_Lock). */
1114         emacs_event->event.motion.modifiers = modifiers;
1115       }
1116     break;
1117
1118     case ClientMessage:
1119       {
1120         /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
1121            passed as the timestamp of the TAKE_FOCUS, which the ICCCM
1122            explicitly prohibits. */
1123         XClientMessageEvent *ev = &x_event->xclient;
1124 #ifdef HAVE_OFFIX_DND
1125         if (DndIsDropMessage(x_event))
1126           {
1127             unsigned int state, modifiers = 0, button=0;
1128             struct frame *frame = x_any_window_to_frame (d, ev->window);
1129             Extbyte *data;
1130             unsigned long size, dtype;
1131             Lisp_Object l_type = Qnil, l_data = Qnil;
1132             Lisp_Object l_dndlist = Qnil, l_item = Qnil;
1133             struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1134
1135             GCPRO4 (l_type, l_data, l_dndlist, l_item);
1136
1137             if (! frame)
1138               return 0; /* not for us */
1139             XSETFRAME (emacs_event->channel, frame);
1140
1141             emacs_event->event_type = misc_user_event;
1142             emacs_event->timestamp  = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1143
1144             state=DndDragButtons(x_event);
1145
1146             if (state & ShiftMask)      modifiers |= MOD_SHIFT;
1147             if (state & ControlMask)    modifiers |= MOD_CONTROL;
1148             if (state & xd->MetaMask)   modifiers |= MOD_META;
1149             if (state & xd->SuperMask)  modifiers |= MOD_SUPER;
1150             if (state & xd->HyperMask)  modifiers |= MOD_HYPER;
1151             if (state & xd->AltMask)    modifiers |= MOD_ALT;
1152
1153             if (state & Button5Mask)    button = Button5;
1154             if (state & Button4Mask)    button = Button4;
1155             if (state & Button3Mask)    button = Button3;
1156             if (state & Button2Mask)    button = Button2;
1157             if (state & Button1Mask)    button = Button1;
1158
1159             emacs_event->event.misc.modifiers = modifiers;
1160             emacs_event->event.misc.button    = button;
1161
1162             DndDropCoordinates(FRAME_X_TEXT_WIDGET(frame), x_event,
1163                                &(emacs_event->event.misc.x),
1164                                &(emacs_event->event.misc.y) );
1165
1166             DndGetData(x_event,&data,&size);
1167
1168             dtype=DndDataType(x_event);
1169             switch (dtype)
1170               {
1171               case DndFiles: /* null terminated strings, end null */
1172                 {
1173                   int len;
1174                   char *hurl = NULL;
1175
1176                   while (*data)
1177                     {
1178                       len = strlen ((char*)data);
1179                       hurl = dnd_url_hexify_string ((char *)data, "file:");
1180                       l_item = make_string ((Bufbyte *)hurl, strlen (hurl));
1181                       l_dndlist = Fcons (l_item, l_dndlist);
1182                       data += len + 1;
1183                       xfree (hurl);
1184                     }
1185                   l_type = Qdragdrop_URL;
1186                 }
1187                 break;
1188               case DndText:
1189                 l_type = Qdragdrop_MIME;
1190                 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
1191                                             make_string ((Bufbyte *)"8bit", 4),
1192                                             make_ext_string ((Extbyte *)data,
1193                                                              strlen((char *)data),
1194                                                              FORMAT_CTEXT) ) );
1195                 break;
1196               case DndMIME:
1197                 /* we have to parse this in some way to extract
1198                    content-type and params (in the tm way) and
1199                    content encoding.
1200                    OR: if data is string, let tm do the job
1201                        if data is list[2], give the first two
1202                        to tm...
1203                 */
1204                 l_type = Qdragdrop_MIME;
1205                 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1206                                                      strlen((char *)data),
1207                                                      FORMAT_BINARY) );
1208                 break;
1209               case DndFile:
1210               case DndDir:
1211               case DndLink:
1212               case DndExe:
1213                 {
1214                   char *hurl = dnd_url_hexify_string ((char *) data, "file:");
1215
1216                   l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
1217                                                    strlen (hurl)) );
1218                   l_type = Qdragdrop_URL;
1219
1220                   xfree (hurl);
1221                 }
1222                 break;
1223               case DndURL:
1224                 /* as it is a real URL it should already be escaped
1225                    and escaping again will break them (cause % is unsave) */
1226                 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1227                                                      strlen ((char *)data),
1228                                                      FORMAT_FILENAME) );
1229                 l_type = Qdragdrop_URL;
1230                 break;
1231               default: /* Unknown, RawData and any other type */
1232                 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"application/octet-stream", 24) ),
1233                                             make_string ((Bufbyte *)"8bit", 4),
1234                                             make_ext_string ((Extbyte *)data,
1235                                                              size,
1236                                                              FORMAT_BINARY) ) );
1237                 l_type = Qdragdrop_MIME;
1238                 break;
1239               }
1240
1241             emacs_event->event.misc.function = Qdragdrop_drop_dispatch;
1242             emacs_event->event.misc.object = Fcons (l_type, l_dndlist);
1243
1244             UNGCPRO;
1245
1246             break;
1247           }
1248 #endif /* HAVE_OFFIX_DND */
1249         if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
1250             && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
1251             && (Atom) (ev->data.l[1]) == 0)
1252           {
1253             ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1254           }
1255       }
1256     /* fall through */
1257
1258     default: /* it's a magic event */
1259       {
1260         struct frame *frame;
1261         Window w;
1262         XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
1263
1264 #define FROB(event_member, window_member) \
1265         x_event_copy->event_member = x_event->event_member; \
1266         w = x_event->event_member.window_member
1267
1268         switch (x_event->type)
1269           {
1270           case SelectionRequest: FROB(xselectionrequest, owner);  break;
1271           case SelectionClear:   FROB(xselectionclear, window);   break;
1272           case SelectionNotify:  FROB(xselection, requestor);     break;
1273           case PropertyNotify:   FROB(xproperty, window);         break;
1274           case ClientMessage:    FROB(xclient, window);           break;
1275           case ConfigureNotify:  FROB(xconfigure, window);        break;
1276           case Expose:
1277           case GraphicsExpose:   FROB(xexpose, window);           break;
1278           case MapNotify:
1279           case UnmapNotify:      FROB(xmap, window);              break;
1280           case EnterNotify:
1281           case LeaveNotify:      FROB(xcrossing, window);         break;
1282           case FocusIn:
1283           case FocusOut:         FROB(xfocus, window);            break;
1284           case VisibilityNotify: FROB(xvisibility, window);       break;
1285           default:
1286             w = x_event->xany.window;
1287             *x_event_copy = *x_event;
1288             break;
1289           }
1290 #undef FROB
1291         frame = x_any_window_to_frame (d, w);
1292
1293         if (!frame)
1294           return 0;
1295
1296         emacs_event->event_type = magic_event;
1297         XSETFRAME (emacs_event->channel, frame);
1298
1299         break;
1300       }
1301     }
1302   return 1;
1303 }
1304
1305
1306 \f
1307 /************************************************************************/
1308 /*                           magic-event handling                       */
1309 /************************************************************************/
1310
1311 static void
1312 handle_focus_event_1 (struct frame *f, int in_p)
1313 {
1314 #if XtSpecificationRelease > 5
1315   Widget focus_widget = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f));
1316 #endif
1317 #ifdef HAVE_XIM
1318   XIM_focus_event (f, in_p);
1319 #endif /* HAVE_XIM */
1320
1321   /* On focus change, clear all memory of sticky modifiers
1322      to avoid non-intuitive behavior. */
1323   clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f)));
1324
1325   /* We don't want to handle the focus change now, because we might
1326      be in an accept-process-output, sleep-for, or sit-for.  So
1327      we enqueue it.
1328
1329      Actually, we half handle it: we handle it as far as changing the
1330      box cursor for redisplay, but we don't call any hooks or do any
1331      select-frame stuff until after the sit-for.
1332
1333      Unfortunately native widgets break the model because they grab
1334      the keyboard focus and nothing sets it back again. I cannot find
1335      any reasonable way to do this elsewhere so we assert here that
1336      the keyboard focus is on the emacs text widget. Menus and dialogs
1337      do this in their selection callback, but we don't want that since
1338      a button having focus is legitimate. An edit field having focus
1339      is mandatory. Weirdly you get a FocusOut event when you click in
1340      a widget-glyph but you don't get a correspondng FocusIn when you
1341      click in the frame. Why is this?  */
1342   if (in_p 
1343 #if XtSpecificationRelease > 5      
1344       && FRAME_X_TEXT_WIDGET (f) != focus_widget
1345 #endif
1346       )
1347     {
1348       lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f),
1349                              FRAME_X_TEXT_WIDGET (f));
1350     }
1351   /* do the generic event-stream stuff. */
1352   {
1353     Lisp_Object frm;
1354     Lisp_Object conser;
1355     struct gcpro gcpro1;
1356
1357     XSETFRAME (frm, f);
1358     conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
1359     GCPRO1 (conser);
1360     emacs_handle_focus_change_preliminary (conser);
1361     enqueue_magic_eval_event (emacs_handle_focus_change_final,
1362                               conser);
1363     UNGCPRO;
1364   }
1365 }
1366
1367 /* This is called from the external-widget code */
1368
1369 void emacs_Xt_handle_focus_event (XEvent *event);
1370 void
1371 emacs_Xt_handle_focus_event (XEvent *event)
1372 {
1373   struct device *d = get_device_from_display (event->xany.display);
1374   struct frame *f;
1375
1376   if (DEVICE_X_BEING_DELETED (d))
1377     return;
1378
1379   /*
1380    * It's curious that we're using x_any_window_to_frame() instead
1381    * of x_window_to_frame().  I don't know what the impact of this is.
1382    */
1383   f = x_any_window_to_frame (d, event->xfocus.window);
1384   if (!f)
1385     /* focus events are sometimes generated just before
1386        a frame is destroyed. */
1387     return;
1388   handle_focus_event_1 (f, event->type == FocusIn);
1389 }
1390
1391 /* both MapNotify and VisibilityNotify can cause this
1392    JV is_visible has the same semantics as f->visible*/
1393 static void
1394 change_frame_visibility (struct frame *f, int is_visible)
1395 {
1396   Lisp_Object frame;
1397
1398   XSETFRAME (frame, f);
1399
1400   if (!FRAME_VISIBLE_P (f) && is_visible)
1401     {
1402       FRAME_VISIBLE_P (f) = is_visible;
1403       /* This improves the double flicker when uniconifying a frame
1404          some.  A lot of it is not showing a buffer which has changed
1405          while the frame was iconified.  To fix it further requires
1406          the good 'ol double redisplay structure. */
1407       MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1408       va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1409     }
1410   else if (FRAME_VISIBLE_P (f) && !is_visible)
1411     {
1412       FRAME_VISIBLE_P (f) = 0;
1413       va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
1414     }
1415   else if (FRAME_VISIBLE_P (f) * is_visible < 0)
1416     {
1417       FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f);
1418       if (FRAME_REPAINT_P(f))
1419               MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1420       va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1421     }
1422 }
1423
1424 static void
1425 handle_map_event (struct frame *f, XEvent *event)
1426 {
1427   Lisp_Object frame;
1428
1429   XSETFRAME (frame, f);
1430   if (event->type == MapNotify)
1431     {
1432       XWindowAttributes xwa;
1433
1434       /* Bleagh!!!!!!  Apparently some window managers (e.g. MWM)
1435          send synthetic MapNotify events when a window is first
1436          created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE.
1437          Or something like that.  We initially tried a different
1438          solution below, but that ran into a different window-
1439          manager bug.
1440
1441          It seems that the only reliable way is to treat a
1442          MapNotify event as a "hint" that the window might or
1443          might not be visible, and check explicitly. */
1444
1445       XGetWindowAttributes (event->xany.display, event->xmap.window,
1446                             &xwa);
1447       if (xwa.map_state != IsViewable)
1448         {
1449           /* Calling Fframe_iconified_p is the only way we have to
1450              correctly update FRAME_ICONIFIED_P */
1451           Fframe_iconified_p (frame);
1452           return;
1453         }
1454
1455       FRAME_X_TOTALLY_VISIBLE_P (f) = 1;
1456 #if 0
1457       /* Bleagh again!!!!  We initially tried the following hack
1458          around the MWM problem, but it turns out that TWM
1459          has a race condition when you un-iconify, where it maps
1460          the window and then tells the server that the window
1461          is un-iconified.  Usually, XEmacs wakes up between
1462          those two occurrences, and thus thinks that un-iconified
1463          windows are still iconified.
1464
1465          Ah, the joys of X. */
1466
1467       /* By Emacs definition, a frame that is iconified is not
1468          visible.  Marking a frame as visible will automatically cause
1469          frame-iconified-p to return nil, regardless of whether the
1470          frame is actually iconified.  Therefore, we have to ignore
1471          MapNotify events on iconified frames. (It's not obvious
1472          to me why these are being sent, but it happens at startup
1473          with frames that are initially iconified; perhaps they are
1474          synthetic MapNotify events coming from the window manager.)
1475          Note that `frame-iconified-p' queries the server
1476          to determine whether the frame is currently iconified,
1477          rather than consulting some internal (and likely
1478          inaccurate) state flag.  Therefore, ignoring the MapNotify
1479          is correct. */
1480       if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (frame)))
1481 #endif /* 0 */
1482         change_frame_visibility (f, 1);
1483     }
1484   else
1485     {
1486       FRAME_X_TOTALLY_VISIBLE_P (f) = 0;
1487       change_frame_visibility (f, 0);
1488       /* Calling Fframe_iconified_p is the only way we have to
1489          correctly update FRAME_ICONIFIED_P */
1490       Fframe_iconified_p (frame);
1491     }
1492 }
1493
1494 static void
1495 handle_client_message (struct frame *f, XEvent *event)
1496 {
1497   struct device *d = XDEVICE (FRAME_DEVICE (f));
1498   Lisp_Object frame;
1499
1500   XSETFRAME (frame, f);
1501
1502   if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1503       (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d))
1504     {
1505       /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages,
1506          such as WM_TAKE_FOCUS, are eval events.  That's because delete-window
1507          was probably executed with a mouse click, while the others could
1508          have been sent as a result of mouse motion or some other implicit
1509          action.  (Call this a "heuristic"...)  The reason for caring about
1510          this is so that clicking on the close-box will make emacs prompt
1511          using a dialog box instead of the minibuffer if there are unsaved
1512          buffers.
1513          */
1514       enqueue_misc_user_event (frame, Qeval,
1515                                list3 (Qdelete_frame, frame, Qt));
1516     }
1517   else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1518            (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
1519     {
1520       handle_focus_event_1 (f, 1);
1521 #if 0
1522       /* If there is a dialog box up, focus on it.
1523
1524          #### Actually, we're raising it too, which is wrong.  We should
1525          #### just focus on it, but lwlib doesn't currently give us an
1526          #### easy way to do that.  This should be fixed.
1527          */
1528       unsigned long take_focus_timestamp = event->xclient.data.l[1];
1529       Widget widget = lw_raise_all_pop_up_widgets ();
1530       if (widget)
1531         {
1532           /* kludge: raise_all returns bottommost widget, but we really
1533              want the topmost.  So just raise it for now. */
1534           XMapRaised (XtDisplay (widget), XtWindow (widget));
1535           /* Grab the focus with the timestamp of the TAKE_FOCUS. */
1536           XSetInputFocus (XtDisplay (widget), XtWindow (widget),
1537                           RevertToParent, take_focus_timestamp);
1538         }
1539 #endif
1540     }
1541 }
1542
1543 static void
1544 emacs_Xt_handle_magic_event (struct Lisp_Event *emacs_event)
1545 {
1546   /* This function can GC */
1547   XEvent *event = &emacs_event->event.magic.underlying_x_event;
1548   struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
1549
1550   if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
1551     return;
1552
1553   switch (event->type)
1554     {
1555     case SelectionRequest:
1556       x_handle_selection_request (&event->xselectionrequest);
1557       break;
1558
1559     case SelectionClear:
1560       x_handle_selection_clear (&event->xselectionclear);
1561       break;
1562
1563     case SelectionNotify:
1564       x_handle_selection_notify (&event->xselection);
1565       break;
1566
1567     case PropertyNotify:
1568       x_handle_property_notify (&event->xproperty);
1569       break;
1570
1571     case Expose:
1572       if (!check_for_ignored_expose (f, event->xexpose.x, event->xexpose.y,
1573                                      event->xexpose.width, event->xexpose.height)
1574           &&
1575           !find_matching_subwindow (f, event->xexpose.x, event->xexpose.y,
1576           event->xexpose.width, event->xexpose.height))
1577         x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1578                                event->xexpose.width, event->xexpose.height);
1579       break;
1580
1581     case GraphicsExpose: /* This occurs when an XCopyArea's source area was
1582                             obscured or not available. */
1583       x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1584                              event->xexpose.width, event->xexpose.height);
1585       break;
1586
1587     case MapNotify:
1588     case UnmapNotify:
1589       handle_map_event (f, event);
1590       break;
1591
1592     case EnterNotify:
1593       if (event->xcrossing.detail != NotifyInferior)
1594         {
1595           Lisp_Object frame;
1596
1597           XSETFRAME (frame, f);
1598           /* FRAME_X_MOUSE_P (f) = 1; */
1599           va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
1600         }
1601       break;
1602
1603     case LeaveNotify:
1604       if (event->xcrossing.detail != NotifyInferior)
1605         {
1606           Lisp_Object frame;
1607
1608           XSETFRAME (frame, f);
1609           /* FRAME_X_MOUSE_P (f) = 0; */
1610           va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
1611         }
1612       break;
1613
1614     case FocusIn:
1615     case FocusOut:
1616
1617 #ifdef EXTERNAL_WIDGET
1618       /* External widget lossage: Ben said:
1619          YUCK.  The only way to make focus changes work properly is to
1620          completely ignore all FocusIn/FocusOut events and depend only
1621          on notifications from the ExternalClient widget. */
1622       if (FRAME_X_EXTERNAL_WINDOW_P (f))
1623         break;
1624 #endif
1625       handle_focus_event_1 (f, event->type == FocusIn);
1626       break;
1627
1628     case ClientMessage:
1629       handle_client_message (f, event);
1630       break;
1631
1632     case VisibilityNotify: /* window visibility has changed */
1633       if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
1634         {
1635           FRAME_X_TOTALLY_VISIBLE_P (f) =
1636             (event->xvisibility.state == VisibilityUnobscured);
1637           /* Note that the fvwm pager only sends VisibilityNotify when
1638              changing pages. Is this all we need to do ? JV */
1639           /* Nope.  We must at least trigger a redisplay here.
1640              Since this case seems similar to MapNotify, I've
1641              factored out some code to change_frame_visibility().
1642              This triggers the necessary redisplay and runs
1643              (un)map-frame-hook.  - dkindred@cs.cmu.edu */
1644           /* Changed it again to support the tristate visibility flag */
1645           change_frame_visibility (f, (event->xvisibility.state
1646                                        != VisibilityFullyObscured) ? 1 : -1);
1647         }
1648       break;
1649
1650     case ConfigureNotify:
1651 #ifdef HAVE_XIM
1652       XIM_SetGeometry (f);
1653 #endif
1654       break;
1655
1656     default:
1657       break;
1658     }
1659 }
1660
1661 \f
1662 /************************************************************************/
1663 /*                              timeout events                          */
1664 /************************************************************************/
1665
1666 static int timeout_id_tick;
1667
1668 /* Xt interval id's might not fit into an int (they're pointers, as it
1669    happens), so we need to provide a conversion list. */
1670
1671 static struct Xt_timeout
1672 {
1673   int id;
1674   XtIntervalId interval_id;
1675   struct Xt_timeout *next;
1676 } *pending_timeouts, *completed_timeouts;
1677
1678 static struct Xt_timeout_blocktype
1679 {
1680   Blocktype_declare (struct Xt_timeout);
1681 } *the_Xt_timeout_blocktype;
1682
1683 /* called by XtAppNextEvent() */
1684 static void
1685 Xt_timeout_callback (XtPointer closure, XtIntervalId *id)
1686 {
1687   struct Xt_timeout *timeout = (struct Xt_timeout *) closure;
1688   struct Xt_timeout *t2 = pending_timeouts;
1689   /* Remove this one from the list of pending timeouts */
1690   if (t2 == timeout)
1691     pending_timeouts = pending_timeouts->next;
1692   else
1693     {
1694       while (t2->next && t2->next != timeout) t2 = t2->next;
1695       assert (t2->next);
1696       t2->next = t2->next->next;
1697     }
1698   /* Add this one to the list of completed timeouts */
1699   timeout->next = completed_timeouts;
1700   completed_timeouts = timeout;
1701 }
1702
1703 static int
1704 emacs_Xt_add_timeout (EMACS_TIME thyme)
1705 {
1706   struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype);
1707   EMACS_TIME current_time;
1708   int milliseconds;
1709
1710   timeout->id = timeout_id_tick++;
1711   timeout->next = pending_timeouts;
1712   pending_timeouts = timeout;
1713   EMACS_GET_TIME (current_time);
1714   EMACS_SUB_TIME (thyme, thyme, current_time);
1715   milliseconds = EMACS_SECS (thyme) * 1000 +
1716     EMACS_USECS (thyme) / 1000;
1717   if (milliseconds < 1)
1718     milliseconds = 1;
1719   timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds,
1720                                           Xt_timeout_callback,
1721                                           (XtPointer) timeout);
1722   return timeout->id;
1723 }
1724
1725 static void
1726 emacs_Xt_remove_timeout (int id)
1727 {
1728   struct Xt_timeout *timeout, *t2;
1729
1730   timeout = NULL;
1731
1732   /* Find the timeout on the list of pending ones, if it's still there. */
1733   if (pending_timeouts)
1734     {
1735       if (id == pending_timeouts->id)
1736         {
1737           timeout = pending_timeouts;
1738           pending_timeouts = pending_timeouts->next;
1739         }
1740       else
1741         {
1742           t2 = pending_timeouts;
1743           while (t2->next && t2->next->id != id) t2 = t2->next;
1744           if ( t2->next)   /*found it */
1745             {
1746               timeout = t2->next;
1747               t2->next = t2->next->next;
1748             }
1749         }
1750       /* if it was pending, we have removed it from the list */
1751       if (timeout)
1752         XtRemoveTimeOut (timeout->interval_id);
1753     }
1754
1755   /* It could be that the Xt call back was already called but we didn't convert
1756      into an Emacs event yet */
1757   if (!timeout && completed_timeouts)
1758     {
1759       /* Code duplication! */
1760       if (id == completed_timeouts->id)
1761         {
1762           timeout = completed_timeouts;
1763           completed_timeouts = completed_timeouts->next;
1764         }
1765       else
1766         {
1767           t2 = completed_timeouts;
1768           while (t2->next && t2->next->id != id) t2 = t2->next;
1769           if ( t2->next)   /*found it */
1770             {
1771               timeout = t2->next;
1772               t2->next = t2->next->next;
1773             }
1774         }
1775     }
1776
1777   /* If we found the thing on the lists of timeouts,
1778      and removed it, deallocate
1779   */
1780   if (timeout)
1781     Blocktype_free (the_Xt_timeout_blocktype, timeout);
1782 }
1783
1784 static void
1785 Xt_timeout_to_emacs_event (struct Lisp_Event *emacs_event)
1786 {
1787   struct Xt_timeout *timeout = completed_timeouts;
1788   assert (timeout);
1789   completed_timeouts = completed_timeouts->next;
1790   emacs_event->event_type = timeout_event;
1791   /* timeout events have nil as channel */
1792   emacs_event->timestamp  = 0; /* #### wrong!! */
1793   emacs_event->event.timeout.interval_id = timeout->id;
1794   emacs_event->event.timeout.function = Qnil;
1795   emacs_event->event.timeout.object = Qnil;
1796   Blocktype_free (the_Xt_timeout_blocktype, timeout);
1797 }
1798
1799 \f
1800 /************************************************************************/
1801 /*                      process and tty events                          */
1802 /************************************************************************/
1803
1804 struct what_is_ready_closure
1805 {
1806   int fd;
1807   Lisp_Object what;
1808   XtInputId id;
1809 };
1810
1811 static Lisp_Object *filedesc_with_input;
1812 static struct what_is_ready_closure **filedesc_to_what_closure;
1813
1814 static void
1815 init_what_input_once (void)
1816 {
1817   int i;
1818
1819   filedesc_with_input = xnew_array (Lisp_Object, MAXDESC);
1820   filedesc_to_what_closure =
1821     xnew_array (struct what_is_ready_closure *, MAXDESC);
1822
1823   for (i = 0; i < MAXDESC; i++)
1824     {
1825       filedesc_to_what_closure[i] = 0;
1826       filedesc_with_input[i] = Qnil;
1827     }
1828
1829   process_events_occurred = 0;
1830   tty_events_occurred = 0;
1831 }
1832
1833 static void
1834 mark_what_as_being_ready (struct what_is_ready_closure *closure)
1835 {
1836   if (NILP (filedesc_with_input[closure->fd]))
1837     {
1838       SELECT_TYPE temp_mask;
1839       FD_ZERO (&temp_mask);
1840       FD_SET (closure->fd, &temp_mask);
1841       /* Check to make sure there's *really* input available.
1842          Sometimes things seem to get confused and this gets called
1843          for the tty fd when there's really only input available
1844          on some process's fd.  (It will subsequently get called
1845          for that process's fd, so returning without setting any
1846          flags will take care of it.)  To see the problem, uncomment
1847          the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
1848          down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
1849          and press return repeatedly.  (Seen under AIX & Linux.)
1850          -dkindred@cs.cmu.edu */
1851       if (!poll_fds_for_input (temp_mask))
1852         {
1853 #if 0
1854           stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
1855                       closure->fd);
1856 #endif
1857           return;
1858         }
1859       filedesc_with_input[closure->fd] = closure->what;
1860       if (PROCESSP (closure->what))
1861       /* Don't increment this if the current process is already marked
1862        *  as having input. */
1863         process_events_occurred++;
1864       else
1865         tty_events_occurred++;
1866     }
1867 }
1868
1869 static void
1870 Xt_what_callback (void *closure, int *source, XtInputId *id)
1871 {
1872   /* If closure is 0, then we got a fake event from a signal handler.
1873      The only purpose of this is to make XtAppProcessEvent() stop
1874      blocking. */
1875   if (closure)
1876     mark_what_as_being_ready ((struct what_is_ready_closure *) closure);
1877   else
1878     {
1879       fake_event_occurred++;
1880       drain_signal_event_pipe ();
1881     }
1882 }
1883
1884 static void
1885 select_filedesc (int fd, Lisp_Object what)
1886 {
1887   struct what_is_ready_closure *closure;
1888
1889   /* If somebody is trying to select something that's already selected
1890      for, then something went wrong.  The generic routines ought to
1891      detect this and error before here. */
1892   assert (!filedesc_to_what_closure[fd]);
1893
1894   closure = xnew (struct what_is_ready_closure);
1895   closure->fd = fd;
1896   closure->what = what;
1897   closure->id =
1898     XtAppAddInput (Xt_app_con, fd,
1899                    (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
1900                    Xt_what_callback, closure);
1901   filedesc_to_what_closure[fd] = closure;
1902 }
1903
1904 static void
1905 unselect_filedesc (int fd)
1906 {
1907   struct what_is_ready_closure *closure = filedesc_to_what_closure[fd];
1908
1909   assert (closure);
1910   if (!NILP (filedesc_with_input[fd]))
1911     {
1912       /* We are unselecting this process before we have drained the rest of
1913          the input from it, probably from status_notify() in the command loop.
1914          This can happen like so:
1915
1916           - We are waiting in XtAppNextEvent()
1917           - Process generates output
1918           - Process is marked as being ready
1919           - Process dies, SIGCHLD gets generated before we return (!?)
1920             It could happen I guess.
1921           - sigchld_handler() marks process as dead
1922           - Somehow we end up getting a new KeyPress event on the queue
1923             at the same time (I'm really so sure how that happens but I'm
1924             not sure it can't either so let's assume it can...).
1925           - Key events have priority so we return that instead of the proc.
1926           - Before dispatching the lisp key event we call status_notify()
1927           - Which deselects the process that SIGCHLD marked as dead.
1928
1929          Thus we never remove it from _with_input and turn it into a lisp
1930          event, so we need to do it here.  But this does not mean that we're
1931          throwing away the last block of output - status_notify() has already
1932          taken care of running the proc filter or whatever.
1933        */
1934       filedesc_with_input[fd] = Qnil;
1935       if (PROCESSP (closure->what))
1936         {
1937           assert (process_events_occurred > 0);
1938           process_events_occurred--;
1939         }
1940       else
1941         {
1942           assert (tty_events_occurred > 0);
1943           tty_events_occurred--;
1944         }
1945     }
1946   XtRemoveInput (closure->id);
1947   xfree (closure);
1948   filedesc_to_what_closure[fd] = 0;
1949 }
1950
1951 static void
1952 emacs_Xt_select_process (struct Lisp_Process *p)
1953 {
1954   Lisp_Object process;
1955   int infd = event_stream_unixoid_select_process (p);
1956
1957   XSETPROCESS (process, p);
1958   select_filedesc (infd, process);
1959 }
1960
1961 static void
1962 emacs_Xt_unselect_process (struct Lisp_Process *p)
1963 {
1964   int infd = event_stream_unixoid_unselect_process (p);
1965
1966   unselect_filedesc (infd);
1967 }
1968
1969 static USID
1970 emacs_Xt_create_stream_pair (void* inhandle, void* outhandle,
1971                 Lisp_Object* instream, Lisp_Object* outstream, int flags)
1972 {
1973   USID u = event_stream_unixoid_create_stream_pair
1974                 (inhandle, outhandle, instream, outstream, flags);
1975   if (u != USID_ERROR)
1976     u = USID_DONTHASH;
1977   return u;
1978 }
1979
1980 static USID
1981 emacs_Xt_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream)
1982 {
1983   event_stream_unixoid_delete_stream_pair (instream, outstream);
1984   return USID_DONTHASH;
1985 }
1986
1987 /* This is called from GC when a process object is about to be freed.
1988    If we've still got pointers to it in this file, we're gonna lose hard.
1989  */
1990 void
1991 debug_process_finalization (struct Lisp_Process *p)
1992 {
1993 #if 0 /* #### */
1994   int i;
1995   Lisp_Object instr, outstr;
1996
1997   get_process_streams (p, &instr, &outstr);
1998   /* if it still has fds, then it hasn't been killed yet. */
1999   assert (NILP(instr));
2000   assert (NILP(outstr));
2001   /* Better not still be in the "with input" table; we know it's got no fds. */
2002   for (i = 0; i < MAXDESC; i++)
2003     {
2004       Lisp_Object process = filedesc_fds_with_input [i];
2005       assert (!PROCESSP (process) || XPROCESS (process) != p);
2006     }
2007 #endif
2008 }
2009
2010 static void
2011 Xt_process_to_emacs_event (struct Lisp_Event *emacs_event)
2012 {
2013   int i;
2014   Lisp_Object process;
2015
2016   assert (process_events_occurred > 0);
2017   for (i = 0; i < MAXDESC; i++)
2018     {
2019       process = filedesc_with_input[i];
2020       if (PROCESSP (process))
2021         break;
2022     }
2023   assert (i < MAXDESC);
2024   filedesc_with_input[i] = Qnil;
2025   process_events_occurred--;
2026   /* process events have nil as channel */
2027   emacs_event->event_type = process_event;
2028   emacs_event->timestamp  = 0; /* #### */
2029   emacs_event->event.process.process = process;
2030 }
2031
2032 static void
2033 emacs_Xt_select_console (struct console *con)
2034 {
2035   Lisp_Object console;
2036   int infd;
2037 #ifdef HAVE_GPM
2038   int mousefd;
2039 #endif
2040
2041   if (CONSOLE_X_P (con))
2042     return; /* X consoles are automatically selected for when we
2043                initialize them in Xt */
2044   infd = event_stream_unixoid_select_console (con);
2045   XSETCONSOLE (console, con);
2046   select_filedesc (infd, console);
2047 #ifdef HAVE_GPM
2048   /* On a stream device (ie: noninteractive), bad things can happen. */
2049   if (EQ (CONSOLE_TYPE (con), Qtty)) {
2050     mousefd = CONSOLE_TTY_MOUSE_FD (con);
2051         /* We check filedesc_to_what_closure[fd] here because if you run
2052         ** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
2053         ** if you run gnuattach to connect to another TTY, it will fire up
2054         ** GPM again, and try to reselect the mouse fd.  GPM uses the same
2055         ** fd for every connection apparently, and select_filedesc will
2056         ** fail its assertion if we try to select it twice.
2057         */
2058     if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
2059       select_filedesc (mousefd, console);
2060     }
2061   }
2062 #endif
2063 }
2064
2065 static void
2066 emacs_Xt_unselect_console (struct console *con)
2067 {
2068   Lisp_Object console;
2069   int infd;
2070 #ifdef HAVE_GPM
2071   int mousefd;
2072 #endif
2073
2074   if (CONSOLE_X_P (con))
2075     return; /* X consoles are automatically selected for when we
2076                initialize them in Xt */
2077   infd = event_stream_unixoid_unselect_console (con);
2078   XSETCONSOLE (console, con);
2079   unselect_filedesc (infd);
2080 #ifdef HAVE_GPM
2081   /* On a stream device (ie: noninteractive), bad things can happen. */
2082   if (EQ (CONSOLE_TYPE (con), Qtty)) {
2083     mousefd = CONSOLE_TTY_MOUSE_FD (con);
2084     if (mousefd >= 0) {
2085       unselect_filedesc (mousefd);
2086     }
2087   }
2088 #endif
2089 }
2090
2091 /* read an event from a tty, if one is available.  Returns non-zero
2092    if an event was available.  Note that when this function is
2093    called, there should always be a tty marked as ready for input.
2094    However, the input condition might actually be EOF, so there
2095    may not really be any input available. (In this case,
2096    read_event_from_tty_or_stream_desc() will arrange for the TTY device
2097    to be deleted.) */
2098
2099 static int
2100 Xt_tty_to_emacs_event (struct Lisp_Event *emacs_event)
2101 {
2102   int i;
2103
2104   assert (tty_events_occurred > 0);
2105   for (i = 0; i < MAXDESC; i++)
2106     {
2107       Lisp_Object console = filedesc_with_input[i];
2108       if (CONSOLEP (console))
2109         {
2110           assert (tty_events_occurred > 0);
2111           tty_events_occurred--;
2112           filedesc_with_input[i] = Qnil;
2113           if (read_event_from_tty_or_stream_desc
2114               (emacs_event, XCONSOLE (console), i))
2115             return 1;
2116         }
2117     }
2118
2119   return 0;
2120 }
2121
2122 \f
2123 /************************************************************************/
2124 /*              debugging functions to decipher an event                */
2125 /************************************************************************/
2126
2127 #ifdef DEBUG_XEMACS
2128 #include "xintrinsicp.h"        /* only describe_event() needs this */
2129 #include <X11/Xproto.h>         /* only describe_event() needs this */
2130
2131 static void
2132 describe_event_window (Window window, Display *display)
2133 {
2134   struct frame *f;
2135   Widget w;
2136   stderr_out ("   window: 0x%lx", (unsigned long) window);
2137   w = XtWindowToWidget (display, window);
2138   if (w)
2139     stderr_out (" %s", w->core.widget_class->core_class.class_name);
2140   f = x_any_window_to_frame (get_device_from_display (display), window);
2141   if (f)
2142     {
2143       char *buf = alloca_array (char, XSTRING_LENGTH (f->name) + 4);
2144       sprintf (buf, " \"%s\"", XSTRING_DATA (f->name));
2145       write_string_to_stdio_stream (stderr, 0, (Bufbyte *) buf, 0,
2146                                     strlen (buf), FORMAT_TERMINAL);
2147     }
2148   stderr_out ("\n");
2149 }
2150
2151 static CONST char *
2152 XEvent_mode_to_string (int mode)
2153 {
2154   switch (mode)
2155   {
2156   case NotifyNormal:       return "Normal";
2157   case NotifyGrab:         return "Grab";
2158   case NotifyUngrab:       return "Ungrab";
2159   case NotifyWhileGrabbed: return "WhileGrabbed";
2160   default:                 return "???";
2161   }
2162 }
2163
2164 static CONST char *
2165 XEvent_detail_to_string (int detail)
2166 {
2167   switch (detail)
2168   {
2169   case NotifyAncestor:          return "Ancestor";
2170   case NotifyInferior:          return "Inferior";
2171   case NotifyNonlinear:         return "Nonlinear";
2172   case NotifyNonlinearVirtual:  return "NonlinearVirtual";
2173   case NotifyPointer:           return "Pointer";
2174   case NotifyPointerRoot:       return "PointerRoot";
2175   case NotifyDetailNone:        return "DetailNone";
2176   default:                      return "???";
2177   }
2178 }
2179
2180 static CONST char *
2181 XEvent_visibility_to_string (int state)
2182 {
2183   switch (state)
2184   {
2185   case VisibilityFullyObscured:     return "FullyObscured";
2186   case VisibilityPartiallyObscured: return "PartiallyObscured";
2187   case VisibilityUnobscured:        return "Unobscured";
2188   default:                          return "???";
2189   }
2190 }
2191
2192 static void
2193 describe_event (XEvent *event)
2194 {
2195   char buf[100];
2196   struct device *d = get_device_from_display (event->xany.display);
2197
2198   sprintf (buf, "%s%s", x_event_name (event->type),
2199            event->xany.send_event ? " (send)" : "");
2200   stderr_out ("%-30s", buf);
2201   switch (event->type)
2202     {
2203     case FocusIn:
2204     case FocusOut:
2205       {
2206         XFocusChangeEvent *ev = &event->xfocus;
2207         describe_event_window (ev->window, ev->display);
2208         stderr_out ("     mode: %s\n",   XEvent_mode_to_string  (ev->mode));
2209         stderr_out ("     detail: %s\n", XEvent_detail_to_string(ev->detail));
2210         break;
2211       }
2212
2213     case KeyPress:
2214       {
2215         XKeyEvent *ev = &event->xkey;
2216         unsigned int state = ev->state;
2217
2218         describe_event_window (ev->window, ev->display);
2219         stderr_out ("   subwindow: %ld\n", ev->subwindow);
2220         stderr_out ("   state: ");
2221         /* Complete list of modifier key masks */
2222         if (state & ShiftMask)   stderr_out ("Shift ");
2223         if (state & LockMask)    stderr_out ("Lock ");
2224         if (state & ControlMask) stderr_out ("Control ");
2225         if (state & Mod1Mask)    stderr_out ("Mod1 ");
2226         if (state & Mod2Mask)    stderr_out ("Mod2 ");
2227         if (state & Mod3Mask)    stderr_out ("Mod3 ");
2228         if (state & Mod4Mask)    stderr_out ("Mod4 ");
2229         if (state & Mod5Mask)    stderr_out ("Mod5 ");
2230
2231         if (! state)
2232           stderr_out ("vanilla\n");
2233         else
2234           stderr_out ("\n");
2235         if (x_key_is_modifier_p (ev->keycode, d))
2236           stderr_out ("   Modifier key");
2237         stderr_out ("   keycode: 0x%x\n", ev->keycode);
2238       }
2239     break;
2240
2241     case Expose:
2242       if (x_debug_events > 1)
2243         {
2244           XExposeEvent *ev = &event->xexpose;
2245           describe_event_window (ev->window, ev->display);
2246           stderr_out ("   region: x=%d y=%d width=%d height=%d\n",
2247                       ev->x, ev->y, ev->width, ev->height);
2248           stderr_out ("    count: %d\n", ev->count);
2249         }
2250       else
2251         stderr_out ("\n");
2252       break;
2253
2254     case GraphicsExpose:
2255       if (x_debug_events > 1)
2256         {
2257           XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
2258           describe_event_window (ev->drawable, ev->display);
2259           stderr_out ("    major: %s\n",
2260                       (ev ->major_code == X_CopyArea  ? "CopyArea" :
2261                        (ev->major_code == X_CopyPlane ? "CopyPlane" : "?")));
2262           stderr_out ("   region: x=%d y=%d width=%d height=%d\n",
2263                       ev->x, ev->y, ev->width, ev->height);
2264           stderr_out ("    count: %d\n", ev->count);
2265         }
2266       else
2267         stderr_out ("\n");
2268       break;
2269
2270     case EnterNotify:
2271     case LeaveNotify:
2272       if (x_debug_events > 1)
2273         {
2274           XCrossingEvent *ev = &event->xcrossing;
2275           describe_event_window (ev->window, ev->display);
2276 #if 0
2277           stderr_out(" subwindow: 0x%x\n", ev->subwindow);
2278           stderr_out("      pos: %d %d\n", ev->x, ev->y);
2279           stderr_out(" root pos: %d %d\n", ev->x_root, ev->y_root);
2280 #endif
2281           stderr_out("    mode: %s\n",   XEvent_mode_to_string(ev->mode));
2282           stderr_out("    detail: %s\n", XEvent_detail_to_string(ev->detail));
2283           stderr_out("    focus: %d\n", ev->focus);
2284 #if 0
2285           stderr_out("    state: 0x%x\n", ev->state);
2286 #endif
2287         }
2288       else
2289         stderr_out("\n");
2290       break;
2291
2292     case ConfigureNotify:
2293       if (x_debug_events > 1)
2294         {
2295           XConfigureEvent *ev = &event->xconfigure;
2296           describe_event_window (ev->window, ev->display);
2297           stderr_out("    above: 0x%lx\n", ev->above);
2298           stderr_out("     size: %d %d %d %d\n", ev->x, ev->y,
2299                      ev->width, ev->height);
2300           stderr_out("  redirect: %d\n", ev->override_redirect);
2301         }
2302       else
2303         stderr_out("\n");
2304       break;
2305
2306     case VisibilityNotify:
2307       if (x_debug_events > 1)
2308         {
2309           XVisibilityEvent *ev = &event->xvisibility;
2310           describe_event_window (ev->window, ev->display);
2311           stderr_out("    state: %s\n", XEvent_visibility_to_string(ev->state));
2312         }
2313       else
2314         stderr_out ("\n");
2315       break;
2316
2317     case ClientMessage:
2318       {
2319         XClientMessageEvent *ev = &event->xclient;
2320         char *name = XGetAtomName (ev->display, ev->message_type);
2321         stderr_out ("%s", name);
2322         if (!strcmp (name, "WM_PROTOCOLS")) {
2323           char *protname = XGetAtomName (ev->display, ev->data.l[0]);
2324           stderr_out ("(%s)", protname);
2325           XFree (protname);
2326         }
2327         XFree (name);
2328         stderr_out ("\n");
2329         break;
2330       }
2331
2332     default:
2333       stderr_out ("\n");
2334       break;
2335     }
2336
2337   fflush (stdout);
2338 }
2339
2340 #endif /* include describe_event definition */
2341
2342 \f
2343 /************************************************************************/
2344 /*                      get the next event from Xt                      */
2345 /************************************************************************/
2346
2347 static Lisp_Object dispatch_event_queue, dispatch_event_queue_tail;
2348
2349 static void
2350 enqueue_Xt_dispatch_event (Lisp_Object event)
2351 {
2352   enqueue_event (event, &dispatch_event_queue, &dispatch_event_queue_tail);
2353 }
2354
2355 static Lisp_Object
2356 dequeue_Xt_dispatch_event (void)
2357 {
2358   return dequeue_event (&dispatch_event_queue, &dispatch_event_queue_tail);
2359 }
2360
2361 /* This business exists because menu events "happen" when
2362    menubar_selection_callback() is called from somewhere deep
2363    within XtAppProcessEvent in emacs_Xt_next_event().  The
2364    callback needs to terminate the modal loop in that function
2365    or else it will continue waiting until another event is
2366    received.
2367
2368    Same business applies to scrollbar events. */
2369
2370 void
2371 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
2372                               Lisp_Object object)
2373 {
2374   Lisp_Object event = Fmake_event (Qnil, Qnil);
2375
2376   XEVENT (event)->event_type = misc_user_event;
2377   XEVENT (event)->channel = channel;
2378   XEVENT (event)->event.eval.function = function;
2379   XEVENT (event)->event.eval.object = object;
2380
2381   enqueue_Xt_dispatch_event (event);
2382 }
2383
2384 static void
2385 emacs_Xt_next_event (struct Lisp_Event *emacs_event)
2386 {
2387  we_didnt_get_an_event:
2388
2389   while (NILP (dispatch_event_queue) &&
2390          !completed_timeouts         &&
2391          !fake_event_occurred        &&
2392          !process_events_occurred    &&
2393          !tty_events_occurred)
2394     {
2395
2396       /* Stupid logic in XtAppProcessEvent() dictates that, if process
2397          events and X events are both available, the process event gets
2398          taken first.  This will cause an infinite loop if we're being
2399          called from Fdiscard_input().
2400        */
2401       if (XtAppPending (Xt_app_con) & XtIMXEvent)
2402         XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2403       else
2404         {
2405           Lisp_Object devcons, concons;
2406
2407           /* We're about to block.  Xt has a bug in it (big surprise,
2408              there) in that it blocks using select() and doesn't
2409              flush the Xlib output buffers (XNextEvent() does this
2410              automatically before blocking).  So it's necessary
2411              for us to do this ourselves.  If we don't do it, then
2412              display output may not be seen until the next time
2413              an X event is received. (This happens esp. with
2414              subprocess output that gets sent to a visible buffer.)
2415
2416              #### The above comment may not have any validity. */
2417
2418           DEVICE_LOOP_NO_BREAK (devcons, concons)
2419             {
2420               struct device *d;
2421               d = XDEVICE (XCAR (devcons));
2422
2423               if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2424                 /* emacs may be exiting */
2425                 XFlush (DEVICE_X_DISPLAY (d));
2426             }
2427           XtAppProcessEvent (Xt_app_con, XtIMAll);
2428         }
2429     }
2430
2431   if (!NILP (dispatch_event_queue))
2432     {
2433       Lisp_Object event, event2;
2434       XSETEVENT (event2, emacs_event);
2435       event = dequeue_Xt_dispatch_event ();
2436       Fcopy_event (event, event2);
2437       Fdeallocate_event (event);
2438     }
2439   else if (tty_events_occurred)
2440     {
2441       if (!Xt_tty_to_emacs_event (emacs_event))
2442         goto we_didnt_get_an_event;
2443     }
2444   else if (completed_timeouts)
2445     Xt_timeout_to_emacs_event (emacs_event);
2446   else if (fake_event_occurred)
2447     {
2448       /* A dummy event, so that a cycle of the command loop will occur. */
2449       fake_event_occurred = 0;
2450       /* eval events have nil as channel */
2451       emacs_event->event_type = eval_event;
2452       emacs_event->event.eval.function = Qidentity;
2453       emacs_event->event.eval.object = Qnil;
2454     }
2455   else /* if (process_events_occurred) */
2456     Xt_process_to_emacs_event (emacs_event);
2457
2458   /* No need to call XFilterEvent; Xt does it for us */
2459 }
2460
2461 void
2462 emacs_Xt_event_handler (Widget wid /* unused */,
2463                         XtPointer closure /* unused */,
2464                         XEvent *event,
2465                         Boolean *continue_to_dispatch /* unused */)
2466 {
2467   Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
2468
2469 #ifdef DEBUG_XEMACS
2470   if (x_debug_events > 0)
2471     {
2472       describe_event (event);
2473     }
2474 #endif /* DEBUG_XEMACS */
2475   if (x_event_to_emacs_event (event, XEVENT (emacs_event)))
2476     enqueue_Xt_dispatch_event (emacs_event);
2477   else
2478     Fdeallocate_event (emacs_event);
2479 }
2480
2481 \f
2482 /************************************************************************/
2483 /*                      input pending / C-g checking                    */
2484 /************************************************************************/
2485
2486 static Bool
2487 quit_char_predicate (Display *display, XEvent *event, XPointer data)
2488 {
2489   struct device *d = get_device_from_display (display);
2490   struct x_device *xd = DEVICE_X_DATA (d);
2491   char c, quit_char;
2492   Bool *critical = (Bool *) data;
2493   Lisp_Object keysym;
2494
2495   if (critical)
2496     *critical = False;
2497   if ((event->type != KeyPress) ||
2498       (! x_any_window_to_frame (d, event->xany.window)) ||
2499       (event->xkey.state
2500        & (xd->MetaMask | xd->HyperMask | xd->SuperMask | xd->AltMask)))
2501     return 0;
2502
2503   /* This duplicates some code that exists elsewhere, but it's relatively
2504      fast and doesn't cons. */
2505   keysym = x_to_emacs_keysym (&event->xkey, 1);
2506   if (NILP (keysym)) return 0;
2507   if (CHAR_OR_CHAR_INTP (keysym))
2508     c = XCHAR_OR_CHAR_INT (keysym);
2509   /* Highly doubtful that these are the quit character, but... */
2510   else if (EQ (keysym, QKbackspace))    c = '\b';
2511   else if (EQ (keysym, QKtab))          c = '\t';
2512   else if (EQ (keysym, QKlinefeed))     c = '\n';
2513   else if (EQ (keysym, QKreturn))       c = '\r';
2514   else if (EQ (keysym, QKescape))       c = 27;
2515   else if (EQ (keysym, QKspace))        c = ' ';
2516   else if (EQ (keysym, QKdelete))       c = 127;
2517   else return 0;
2518
2519   if (event->xkey.state & xd->MetaMask)     c |= 0x80;
2520   if ((event->xkey.state & ControlMask) && !(c >= 'A' && c <= 'Z'))
2521     c &= 0x1F;                  /* unshifted control characters */
2522   quit_char = CONSOLE_QUIT_CHAR (XCONSOLE (DEVICE_CONSOLE (d)));
2523   if (c == quit_char)
2524     return True;
2525   /* If we've got Control-Shift-G instead of Control-G, that means
2526      we have a critical_quit.  Caps_Lock is its own modifier, so it
2527      won't cause ^G to act differently than before. */
2528   if (event->xkey.state & ControlMask)  c &= 0x1F;
2529   if (c == quit_char)
2530     {
2531       if (critical) *critical = True;
2532       return True;
2533     }
2534   return False;
2535 }
2536
2537 /* This scans the X input queue for a KeyPress event that matches the
2538    quit character, and sets Vquit_flag.  This is called from the
2539    QUIT macro to determine whether we should quit.
2540
2541    In a SIGIO world, this won't be called unless a SIGIO has happened
2542    since the last time we checked.
2543
2544    In a non-SIGIO world, this is called from emacs_Xt_event_pending_p
2545    (which is called from input_pending_p).
2546  */
2547 static void
2548 x_check_for_quit_char (Display *display)
2549 {
2550   XEvent event;
2551   int queued;
2552   Bool critical_quit = False;
2553   XEventsQueued (display, QueuedAfterReading);
2554   queued = XCheckIfEvent (display, &event,
2555                           quit_char_predicate,
2556                           (char *) &critical_quit);
2557   if (queued)
2558     {
2559       Vquit_flag = (critical_quit ? Qcritical : Qt);
2560       /* don't put the event back onto the queue.  Those functions that
2561          wanted to read a ^G directly have arranged to do this. */
2562     }
2563 }
2564
2565 static void
2566 check_for_tty_quit_char (struct device *d)
2567 {
2568   SELECT_TYPE temp_mask;
2569   int infd = DEVICE_INFD (d);
2570   struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
2571   Emchar quit_char = CONSOLE_QUIT_CHAR (con);
2572
2573   FD_ZERO (&temp_mask);
2574   FD_SET (infd, &temp_mask);
2575
2576   while (1)
2577     {
2578       Lisp_Object event;
2579       Emchar the_char;
2580
2581       if (!poll_fds_for_input (temp_mask))
2582         return;
2583
2584       event = Fmake_event (Qnil, Qnil);
2585       if (!read_event_from_tty_or_stream_desc (XEVENT (event), con, infd))
2586         /* EOF, or something ... */
2587         return;
2588       /* #### bogus.  quit-char should be allowed to be any sort
2589          of event. */
2590       the_char = event_to_character (XEVENT (event), 1, 0, 0);
2591       if (the_char >= 0 && the_char == quit_char)
2592         {
2593           Vquit_flag = Qt;
2594           /* do not queue the C-g.  See above. */
2595           return;
2596         }
2597
2598       /* queue the read event to be read for real later. */
2599       enqueue_Xt_dispatch_event (event);
2600     }
2601 }
2602
2603 static void
2604 emacs_Xt_quit_p (void)
2605 {
2606   Lisp_Object devcons, concons;
2607   CONSOLE_LOOP (concons)
2608     {
2609       struct console *con = XCONSOLE (XCAR (concons));
2610       if (!con->input_enabled)
2611         continue;
2612
2613       CONSOLE_DEVICE_LOOP (devcons, con)
2614         {
2615           struct device *d;
2616           d = XDEVICE (XCAR (devcons));
2617
2618           if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2619             /* emacs may be exiting */
2620             x_check_for_quit_char (DEVICE_X_DISPLAY (d));
2621           else if (DEVICE_TTY_P (d))
2622             check_for_tty_quit_char (d);
2623         }
2624     }
2625 }
2626
2627 static void
2628 drain_X_queue (void)
2629 {
2630   while (XtAppPending (Xt_app_con) & XtIMXEvent)
2631     XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2632 }
2633
2634 static int
2635 emacs_Xt_event_pending_p (int user_p)
2636 {
2637   Lisp_Object event;
2638   int tick_count_val;
2639
2640   /* If `user_p' is false, then this function returns whether there are any
2641      X, timeout, or fd events pending (that is, whether emacs_Xt_next_event()
2642      would return immediately without blocking).
2643
2644      if `user_p' is true, then this function returns whether there are any
2645      *user generated* events available (that is, whether there are keyboard
2646      or mouse-click events ready to be read).  This also implies that
2647      emacs_Xt_next_event() would not block.
2648
2649      In a non-SIGIO world, this also checks whether the user has typed ^G,
2650      since this is a convenient place to do so.  We don't need to do this
2651      in a SIGIO world, since input causes an interrupt.
2652    */
2653
2654 #if 0
2655   /* I don't think there's any point to this and it will nullify
2656      the speed gains achieved by the sigio_happened checking below.
2657      Its only advantage is that it may possibly make C-g response
2658      a bit faster.  The C-g will be noticed within 0.25 second, anyway,
2659      even without this. */
2660 #ifndef SIGIO
2661   /* First check for C-g if necessary */
2662   emacs_Xt_quit_p ();
2663 #endif
2664 #endif
2665
2666   /* This function used to simply check whether there were any X
2667      events (or if user_p was 1, it iterated over all the pending
2668      X events using XCheckIfEvent(), looking for keystrokes and
2669      button events).  That worked in the old cheesoid event loop,
2670      which didn't go through XtAppDispatchEvent(), but it doesn't
2671      work any more -- X events may not result in anything.  For
2672      example, a button press in a blank part of the menubar appears
2673      as an X event but will not result in any Emacs events (a
2674      button press that activates the menubar results in an Emacs
2675      event through the stop_next_event mechanism).
2676
2677      The only accurate way of determining whether these X events
2678      translate into Emacs events is to go ahead and dispatch them
2679      until there's something on the dispatch queue. */
2680
2681   /* See if there are any user events already on the queue. */
2682   EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2683     if (!user_p || command_event_p (event))
2684       return 1;
2685
2686   /* See if there's any TTY input available.
2687    */
2688   if (poll_fds_for_input (tty_only_mask))
2689     return 1;
2690
2691   if (!user_p)
2692     {
2693       /* If not user_p and there are any timer or file-desc events
2694          pending, we know there will be an event so we're through. */
2695       XtInputMask pending_value;
2696
2697       /* Note that formerly we just checked the value of XtAppPending()
2698          to determine if there was file-desc input.  This doesn't
2699          work any more with the signal_event_pipe; XtAppPending()
2700          will says "yes" in this case but there isn't really any
2701          input.  Another way of fixing this problem is for the
2702          signal_event_pipe to generate actual input in the form
2703          of an identity eval event or something. (#### maybe this
2704          actually happens?) */
2705
2706       if (poll_fds_for_input (process_only_mask))
2707         return 1;
2708
2709       pending_value = XtAppPending (Xt_app_con);
2710
2711       if (pending_value & XtIMTimer)
2712         return 1;
2713     }
2714
2715   /* XtAppPending() can be super-slow, esp. over a network connection.
2716      Quantify results have indicated that in some cases the
2717      call to detect_input_pending() completely dominates the
2718      running time of redisplay().  Fortunately, in a SIGIO world
2719      we can more quickly determine whether there are any X events:
2720      if an event has happened since the last time we checked, then
2721      a SIGIO will have happened.  On a machine with broken SIGIO,
2722      we'll still be in an OK state -- the sigio_happened flag
2723      will get set at least once a second, so we'll be no more than
2724      one second behind reality. (In general it's OK if we
2725      erroneously report no input pending when input is actually
2726      pending() -- preemption is just a bit less efficient, that's
2727      all.  It's bad bad bad if you err the other way -- you've
2728      promised that `next-event' won't block but it actually will,
2729      and some action might get delayed until the next time you
2730      hit a key.)
2731      */
2732
2733   /* quit_check_signal_tick_count is volatile so try to avoid race conditions
2734      by using a temporary variable */
2735   tick_count_val = quit_check_signal_tick_count;
2736   if (last_quit_check_signal_tick_count != tick_count_val)
2737     {
2738       last_quit_check_signal_tick_count = tick_count_val;
2739
2740       /* We need to drain the entire queue now -- if we only
2741          drain part of it, we may later on end up with events
2742          actually pending but detect_input_pending() returning
2743          false because there wasn't another SIGIO. */
2744       drain_X_queue ();
2745
2746       EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2747         if (!user_p || command_event_p (event))
2748           return 1;
2749     }
2750
2751   return 0;
2752 }
2753
2754 \f
2755 /************************************************************************/
2756 /*            replacement for standard string-to-pixel converter        */
2757 /************************************************************************/
2758
2759 /* This was constructed by ripping off the standard string-to-pixel
2760    converter from Converters.c in the Xt source code and modifying
2761    appropriately. */
2762
2763 #if 0
2764
2765 /* This is exported by the Xt library (at least by mine).  If this
2766    isn't the case somewhere, rename this appropriately and remove
2767    the '#if 0'.  Note, however, that I got "unknown structure"
2768    errors when I tried this. */
2769 XtConvertArgRec Const colorConvertArgs[] = {
2770   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
2771    sizeof(Screen *)},
2772   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
2773    sizeof(Colormap)}
2774 };
2775
2776 #endif
2777
2778 #define done(type, value)               \
2779   if (toVal->addr != NULL) {             \
2780     if (toVal->size < sizeof(type)) {    \
2781       toVal->size = sizeof(type);        \
2782       return False;                      \
2783     }                                    \
2784     *(type*)(toVal->addr) = (value);     \
2785   } else {                               \
2786     static type static_val;              \
2787     static_val = (value);                \
2788     toVal->addr = (XPointer)&static_val; \
2789   }                                      \
2790   toVal->size = sizeof(type);            \
2791   return True /* Caller supplies `;' */
2792
2793 /* JH: We use this because I think there's a possibility this
2794    is called before the device is properly set up, in which case
2795    I don't want to abort. */
2796 extern struct device *get_device_from_display_1 (Display *dpy);
2797
2798 static
2799 Boolean EmacsXtCvtStringToPixel (
2800  Display     *dpy,
2801  XrmValuePtr  args,
2802  Cardinal    *num_args,
2803  XrmValuePtr  fromVal,
2804  XrmValuePtr  toVal,
2805  XtPointer   *closure_ret)
2806 {
2807   String       str = (String)fromVal->addr;
2808   XColor       screenColor;
2809   XColor       exactColor;
2810   Screen       *screen;
2811   Colormap     colormap;
2812   Visual       *visual;
2813   struct device *d;
2814   Status       status;
2815   String       params[1];
2816   Cardinal     num_params  = 1;
2817   XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
2818
2819   if (*num_args != 2) {
2820     XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
2821                     "XtToolkitError",
2822                     "String to pixel conversion needs screen and colormap arguments",
2823                     (String *)NULL, (Cardinal *)NULL);
2824     return False;
2825   }
2826
2827   screen   = *((Screen **)  args[0].addr);
2828   colormap = *((Colormap *) args[1].addr);
2829
2830   /* The original uses the private function CompareISOLatin1().
2831      Use XmuCompareISOLatin1() if you want, but I don't think it
2832      makes any difference here. */
2833   if (strcmp(str, XtDefaultBackground) == 0) {
2834     *closure_ret = False;
2835     /* This refers to the display's "*reverseVideo" resource.
2836        These display resources aren't documented anywhere that
2837        I can find, so I'm going to ignore this. */
2838     /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */
2839     done(Pixel, WhitePixelOfScreen(screen));
2840   }
2841   if (strcmp(str, XtDefaultForeground) == 0) {
2842     *closure_ret = False;
2843     /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */
2844     done(Pixel, BlackPixelOfScreen(screen));
2845   }
2846
2847   /* Originally called XAllocNamedColor() here. */
2848   if ((d = get_device_from_display_1(dpy))) {
2849     visual = DEVICE_X_VISUAL(d);
2850     if (colormap != DEVICE_X_COLORMAP(d)) {
2851       XtAppWarningMsg(the_app_con, "wierdColormap", "cvtStringToPixel",
2852                       "XtToolkitWarning",
2853                       "The colormap passed to cvtStringToPixel doesn't match the one registerd to the device.\n",
2854                       NULL, 0);
2855       status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2856     } else {
2857       status = XParseColor (dpy, colormap, (char*)str, &screenColor);
2858       if (status) {
2859         status = allocate_nearest_color (dpy, colormap, visual, &screenColor);
2860       }
2861     }
2862   } else {
2863     /* We haven't set up this device totally yet, so just punt */
2864     status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2865   }
2866   if (status == 0) {
2867     params[0] = str;
2868     /* Server returns a specific error code but Xlib discards it.  Ugh */
2869     if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
2870                      &exactColor, &screenColor)) {
2871       XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
2872                       "XtToolkitError",
2873                       "Cannot allocate colormap entry for \"%s\"",
2874                       params, &num_params);
2875
2876     } else {
2877       XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
2878                       "XtToolkitError",
2879                       "Color name \"%s\" is not defined", params, &num_params);
2880     }
2881
2882     *closure_ret = False;
2883     return False;
2884   } else {
2885     *closure_ret = (char*)True;
2886     done(Pixel, screenColor.pixel);
2887   }
2888 }
2889
2890 /* ARGSUSED */
2891 static void EmacsFreePixel (
2892   XtAppContext app,
2893   XrmValuePtr  toVal,
2894   XtPointer    closure,
2895   XrmValuePtr  args,
2896   Cardinal    *num_args)
2897 {
2898   if (*num_args != 2) {
2899     XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError",
2900                     "Freeing a pixel requires screen and colormap arguments",
2901                     (String *)NULL, (Cardinal *)NULL);
2902     return;
2903   }
2904
2905   if (closure) {
2906     Screen   *screen  = *((Screen **)  args[0].addr);
2907     Colormap colormap = *((Colormap *) args[1].addr);
2908     XFreeColors(DisplayOfScreen(screen), colormap,
2909                 (unsigned long*)toVal->addr, 1, (unsigned long)0);
2910   }
2911 }
2912
2913 \f
2914 /************************************************************************/
2915 /*                            initialization                            */
2916 /************************************************************************/
2917
2918 void
2919 syms_of_event_Xt (void)
2920 {
2921   defsymbol (&Qkey_mapping, "key-mapping");
2922   defsymbol (&Qsans_modifiers, "sans-modifiers");
2923 }
2924
2925 void
2926 reinit_vars_of_event_Xt (void)
2927 {
2928   Xt_event_stream = xnew (struct event_stream);
2929   Xt_event_stream->event_pending_p       = emacs_Xt_event_pending_p;
2930   Xt_event_stream->next_event_cb         = emacs_Xt_next_event;
2931   Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
2932   Xt_event_stream->add_timeout_cb        = emacs_Xt_add_timeout;
2933   Xt_event_stream->remove_timeout_cb     = emacs_Xt_remove_timeout;
2934   Xt_event_stream->select_console_cb     = emacs_Xt_select_console;
2935   Xt_event_stream->unselect_console_cb   = emacs_Xt_unselect_console;
2936   Xt_event_stream->select_process_cb     = emacs_Xt_select_process;
2937   Xt_event_stream->unselect_process_cb   = emacs_Xt_unselect_process;
2938   Xt_event_stream->quit_p_cb             = emacs_Xt_quit_p;
2939   Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
2940   Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
2941
2942   the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
2943
2944   last_quit_check_signal_tick_count = 0;
2945
2946   /* this function only makes safe calls */
2947   init_what_input_once ();
2948 }
2949
2950 void
2951 vars_of_event_Xt (void)
2952 {
2953   reinit_vars_of_event_Xt ();
2954
2955   dispatch_event_queue = Qnil;
2956   staticpro (&dispatch_event_queue);
2957   dispatch_event_queue_tail = Qnil;
2958   pdump_wire (&dispatch_event_queue_tail);
2959
2960   DEFVAR_BOOL ("modifier-keys-are-sticky", &modifier_keys_are_sticky /*
2961 *Non-nil makes modifier keys sticky.
2962 This means that you can release the modifier key before pressing down
2963 the key that you wish to be modified.  Although this is non-standard
2964 behavior, it is recommended because it reduces the strain on your hand,
2965 thus reducing the incidence of the dreaded Emacs-pinky syndrome.
2966 */ );
2967   modifier_keys_are_sticky = 0;
2968
2969   DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /*
2970 *Non-nil means to allow synthetic events.  Nil means they are ignored.
2971 Beware: allowing emacs to process SendEvents opens a big security hole.
2972 */ );
2973   x_allow_sendevents = 0;
2974
2975 #ifdef DEBUG_XEMACS
2976   DEFVAR_INT ("x-debug-events", &x_debug_events /*
2977 If non-zero, display debug information about X events that XEmacs sees.
2978 Information is displayed on stderr.  Currently defined values are:
2979
2980 1 == non-verbose output
2981 2 == verbose output
2982 */ );
2983   x_debug_events = 0;
2984 #endif
2985 }
2986
2987 /* This mess is a hack that patches the shell widget to treat visual inheritance
2988    the same as colormap and depth inheritance */
2989
2990 static XtInitProc orig_shell_init_proc;
2991
2992 static void ShellVisualPatch(Widget wanted, Widget new,
2993                              ArgList args, Cardinal *num_args)
2994 {
2995   Widget p;
2996   ShellWidget w = (ShellWidget) new;
2997
2998   /* first, call the original setup */
2999   (*orig_shell_init_proc)(wanted, new, args, num_args);
3000
3001   /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */
3002   if (w->shell.visual == CopyFromParent) {
3003     p = XtParent(w);
3004     while (p && !XtIsShell(p)) p = XtParent(p);
3005     if (p) w->shell.visual = ((ShellWidget)p)->shell.visual;
3006   }
3007 }
3008
3009 void
3010 init_event_Xt_late (void) /* called when already initialized */
3011 {
3012   timeout_id_tick = 1;
3013   pending_timeouts = 0;
3014   completed_timeouts = 0;
3015
3016   event_stream = Xt_event_stream;
3017
3018 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
3019   Initialize_Locale();
3020 #endif /* HAVE_XIM || USE_XFONTSET */
3021
3022   XtToolkitInitialize ();
3023   Xt_app_con = XtCreateApplicationContext ();
3024   XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
3025
3026   /* In xselect.c */
3027   x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
3028   XSetErrorHandler (x_error_handler);
3029   XSetIOErrorHandler (x_IO_error_handler);
3030
3031 #ifndef WINDOWSNT
3032   XtAppAddInput (Xt_app_con, signal_event_pipe[0],
3033                  (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
3034                  Xt_what_callback, 0);
3035 #endif
3036
3037   XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel,
3038                          EmacsXtCvtStringToPixel,
3039                          (XtConvertArgList) colorConvertArgs,
3040                          2, XtCacheByDisplay, EmacsFreePixel);
3041
3042 #ifdef XIM_XLIB
3043   XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
3044                          EmacsXtCvtStringToXIMStyles,
3045                          NULL, 0,
3046                          XtCacheByDisplay, EmacsFreeXIMStyles);
3047 #endif /* XIM_XLIB */
3048
3049   /* insert the visual inheritance patch/hack described above */
3050   orig_shell_init_proc = shellClassRec.core_class.initialize;
3051   shellClassRec.core_class.initialize = ShellVisualPatch;
3052
3053 }