Contents in release-21-2 at 1999-06-30-19.
[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   len = XmbLookupString (xic, event, bufptr, bufsiz, &keysym, &status);
812 #endif /* HAVE_XIM */
813
814 #ifdef DEBUG_XEMACS
815   if (x_debug_events > 0)
816     {
817       stderr_out ("   status=");
818 #define print_status_when(S) if (status == S) stderr_out (#S)
819       print_status_when (XLookupKeySym);
820       print_status_when (XLookupBoth);
821       print_status_when (XLookupChars);
822       print_status_when (XLookupNone);
823       print_status_when (XBufferOverflow);
824
825       if (status == XLookupKeySym || status == XLookupBoth)
826         stderr_out (" keysym=%s",  XKeysymToString (keysym));
827       if (status == XLookupChars  || status == XLookupBoth)
828         {
829           if (len != 1)
830             {
831               int j;
832               stderr_out (" chars=\"");
833               for (j=0; j<len; j++)
834                 stderr_out ("%c", bufptr[j]);
835               stderr_out ("\"");
836             }
837           else if (bufptr[0] <= 32 || bufptr[0] >= 127)
838             stderr_out (" char=0x%x", bufptr[0]);
839           else
840             stderr_out (" char=%c", bufptr[0]);
841         }
842       stderr_out ("\n");
843     }
844 #endif /* DEBUG_XEMACS */
845
846   switch (status)
847     {
848     case XLookupKeySym:
849     case XLookupBoth:
850       return (IsModifierKey (keysym) || keysym == XK_Mode_switch )
851         ? Qnil : x_keysym_to_emacs_keysym (keysym, simple_p);
852
853     case XLookupChars:
854       {
855         /* Generate multiple emacs events */
856         struct device *d = get_device_from_display (event->display);
857         Emchar ch;
858         Lisp_Object instream, fb_instream;
859         Lstream *istr;
860         struct gcpro gcpro1, gcpro2;
861
862         fb_instream =
863           make_fixed_buffer_input_stream ((unsigned char *) bufptr, len);
864
865         /* ### Use Fget_coding_system (Vcomposed_input_coding_system) */
866         instream =
867           make_decoding_input_stream (XLSTREAM (fb_instream),
868                                       Fget_coding_system (Qundecided));
869
870         istr = XLSTREAM (instream);
871
872         GCPRO2 (instream, fb_instream);
873         while ((ch = Lstream_get_emchar (istr)) != EOF)
874           {
875             Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
876             struct Lisp_Event *ev = XEVENT (emacs_event);
877             ev->channel             = DEVICE_CONSOLE (d);
878             ev->event_type          = key_press_event;
879             ev->timestamp           = event->time;
880             ev->event.key.modifiers = 0;
881             ev->event.key.keysym    = make_char (ch);
882             enqueue_Xt_dispatch_event (emacs_event);
883           }
884         Lstream_close (istr);
885         UNGCPRO;
886         Lstream_delete (istr);
887         Lstream_delete (XLSTREAM (fb_instream));
888         return Qnil;
889       }
890     case XLookupNone: return Qnil;
891     case XBufferOverflow:
892       bufptr = (char *) alloca (len+1);
893       bufsiz = len+1;
894       goto Lookup_String;
895     }
896   return Qnil; /* not reached */
897 #endif /* HAVE_XIM */
898 }
899
900 static void
901 set_last_server_timestamp (struct device *d, XEvent *x_event)
902 {
903   Time t;
904   switch (x_event->type)
905     {
906     case KeyPress:
907     case KeyRelease:       t = x_event->xkey.time;              break;
908     case ButtonPress:
909     case ButtonRelease:    t = x_event->xbutton.time;           break;
910     case EnterNotify:
911     case LeaveNotify:      t = x_event->xcrossing.time;         break;
912     case MotionNotify:     t = x_event->xmotion.time;           break;
913     case PropertyNotify:   t = x_event->xproperty.time;         break;
914     case SelectionClear:   t = x_event->xselectionclear.time;   break;
915     case SelectionRequest: t = x_event->xselectionrequest.time; break;
916     case SelectionNotify:  t = x_event->xselection.time;        break;
917     default: return;
918     }
919   DEVICE_X_LAST_SERVER_TIMESTAMP (d) = t;
920 }
921
922 static int
923 x_event_to_emacs_event (XEvent *x_event, struct Lisp_Event *emacs_event)
924 {
925   Display *display    = x_event->xany.display;
926   struct device *d    = get_device_from_display (display);
927   struct x_device *xd = DEVICE_X_DATA (d);
928
929   if (DEVICE_X_BEING_DELETED (d))
930      /* #### Uh, is this 0 correct? */
931      return 0;
932
933   set_last_server_timestamp (d, x_event);
934
935   switch (x_event->type)
936     {
937     case KeyRelease:
938       x_handle_sticky_modifiers (x_event, d);
939       return 0;
940
941     case KeyPress:
942     case ButtonPress:
943     case ButtonRelease:
944       {
945         unsigned int modifiers = 0;
946         int shift_p, lock_p;
947         Bool key_event_p = (x_event->type == KeyPress);
948         unsigned int *state =
949           key_event_p ? &x_event->xkey.state : &x_event->xbutton.state;
950
951         /* If this is a synthetic KeyPress or Button event, and the user
952            has expressed a disinterest in this security hole, then drop
953            it on the floor. */
954         if ((key_event_p
955              ? x_event->xkey.send_event
956              : x_event->xbutton.send_event)
957 #ifdef EXTERNAL_WIDGET
958             /* ben: events get sent to an ExternalShell using XSendEvent.
959                This is not a perfect solution. */
960             && !FRAME_X_EXTERNAL_WINDOW_P
961             (x_any_window_to_frame (d, x_event->xany.window))
962 #endif
963             && !x_allow_sendevents)
964           return 0;
965
966         DEVICE_X_MOUSE_TIMESTAMP (d) =
967           DEVICE_X_GLOBAL_MOUSE_TIMESTAMP (d) =
968           key_event_p ? x_event->xkey.time : x_event->xbutton.time;
969
970         x_handle_sticky_modifiers (x_event, d);
971
972         if (*state & ControlMask)    modifiers |= MOD_CONTROL;
973         if (*state & xd->MetaMask)   modifiers |= MOD_META;
974         if (*state & xd->SuperMask)  modifiers |= MOD_SUPER;
975         if (*state & xd->HyperMask)  modifiers |= MOD_HYPER;
976         if (*state & xd->AltMask)    modifiers |= MOD_ALT;
977
978         /* Ignore the Caps_Lock key if:
979            - any other modifiers are down, so that Caps_Lock doesn't
980              turn C-x into C-X, which would suck.
981            - the event was a mouse event. */
982         if (modifiers || ! key_event_p)
983           *state &= (~LockMask);
984
985         shift_p = *state & ShiftMask;
986         lock_p  = *state & LockMask;
987
988         if (shift_p || lock_p)
989           modifiers |= MOD_SHIFT;
990
991         if (key_event_p)
992           {
993             Lisp_Object keysym;
994             XKeyEvent *ev = &x_event->xkey;
995             /* This used to compute the frame from the given X window and
996                store it here, but we really don't care about the frame. */
997             emacs_event->channel = DEVICE_CONSOLE (d);
998             keysym = x_to_emacs_keysym (&x_event->xkey, 0);
999
1000             /* If the emacs keysym is nil, then that means that the X
1001                keysym was either a Modifier or NoSymbol, which
1002                probably means that we're in the midst of reading a
1003                Multi_key sequence, or a "dead" key prefix, or XIM
1004                input. Ignore it. */
1005             if (NILP (keysym))
1006               return 0;
1007
1008             /* More Caps_Lock garbage: Caps_Lock should *only* add the
1009                shift modifier to two-case keys (that is, A-Z and
1010                related characters). So at this point (after looking up
1011                the keysym) if the keysym isn't a dual-case alphabetic,
1012                and if the caps lock key was down but the shift key
1013                wasn't, then turn off the shift modifier.  Gag barf */
1014             /* #### type lossage: assuming equivalence of emacs and
1015                X keysyms */
1016             /* !!#### maybe fix for Mule */
1017             if (lock_p && !shift_p &&
1018                 ! (CHAR_OR_CHAR_INTP (keysym)
1019                    && keysym_obeys_caps_lock_p
1020                    ((KeySym) XCHAR_OR_CHAR_INT (keysym), d)))
1021               modifiers &= (~MOD_SHIFT);
1022
1023             /* If this key contains two distinct keysyms, that is,
1024                "shift" generates a different keysym than the
1025                non-shifted key, then don't apply the shift modifier
1026                bit: it's implicit.  Otherwise, if there would be no
1027                other way to tell the difference between the shifted
1028                and unshifted version of this key, apply the shift bit.
1029                Non-graphics, like Backspace and F1 get the shift bit
1030                in the modifiers slot.  Neither the characters "a",
1031                "A", "2", nor "@" normally have the shift bit set.
1032                However, "F1" normally does. */
1033             if (modifiers & MOD_SHIFT)
1034               {
1035                 int Mode_switch_p = *state & xd->ModeMask;
1036                 KeySym bot = XLookupKeysym (ev, Mode_switch_p ? 2 : 0);
1037                 KeySym top = XLookupKeysym (ev, Mode_switch_p ? 3 : 1);
1038                 if (top && bot && top != bot)
1039                   modifiers &= ~MOD_SHIFT;
1040               }
1041             emacs_event->event_type          = key_press_event;
1042             emacs_event->timestamp           = ev->time;
1043             emacs_event->event.key.modifiers = modifiers;
1044             emacs_event->event.key.keysym    = keysym;
1045           }
1046         else                    /* Mouse press/release event */
1047           {
1048             XButtonEvent *ev = &x_event->xbutton;
1049             struct frame *frame = x_window_to_frame (d, ev->window);
1050
1051             if (! frame)
1052               return 0; /* not for us */
1053             XSETFRAME (emacs_event->channel, frame);
1054
1055             emacs_event->event_type = (x_event->type == ButtonPress) ?
1056               button_press_event : button_release_event;
1057
1058             emacs_event->event.button.modifiers = modifiers;
1059             emacs_event->timestamp              = ev->time;
1060             emacs_event->event.button.button    = ev->button;
1061             emacs_event->event.button.x         = ev->x;
1062             emacs_event->event.button.y         = ev->y;
1063             /* because we don't seem to get a FocusIn event for button clicks
1064                when a widget-glyph is selected we will assume that we want the
1065                focus if a button gets pressed. */
1066             if (x_event->type == ButtonPress)
1067               handle_focus_event_1 (frame, 1);
1068           }
1069       }
1070     break;
1071
1072     case MotionNotify:
1073       {
1074         XMotionEvent *ev = &x_event->xmotion;
1075         struct frame *frame = x_window_to_frame (d, ev->window);
1076         unsigned int modifiers = 0;
1077         XMotionEvent event2;
1078
1079         if (! frame)
1080           return 0; /* not for us */
1081
1082         /* We use MotionHintMask, so we will get only one motion event
1083            until the next time we call XQueryPointer or the user
1084            clicks the mouse.  So call XQueryPointer now (meaning that
1085            the event will be in sync with the server just before
1086            Fnext_event() returns).  If the mouse is still in motion,
1087            then the server will immediately generate exactly one more
1088            motion event, which will be on the queue waiting for us
1089            next time around. */
1090         event2 = *ev;
1091         if (XQueryPointer (event2.display, event2.window,
1092                            &event2.root,   &event2.subwindow,
1093                            &event2.x_root, &event2.y_root,
1094                            &event2.x,      &event2.y,
1095                            &event2.state))
1096           ev = &event2; /* only one structure copy */
1097
1098         DEVICE_X_MOUSE_TIMESTAMP (d) = ev->time;
1099
1100         XSETFRAME (emacs_event->channel, frame);
1101         emacs_event->event_type     = pointer_motion_event;
1102         emacs_event->timestamp      = ev->time;
1103         emacs_event->event.motion.x = ev->x;
1104         emacs_event->event.motion.y = ev->y;
1105         if (ev->state & ShiftMask)      modifiers |= MOD_SHIFT;
1106         if (ev->state & ControlMask)    modifiers |= MOD_CONTROL;
1107         if (ev->state & xd->MetaMask)   modifiers |= MOD_META;
1108         if (ev->state & xd->SuperMask)  modifiers |= MOD_SUPER;
1109         if (ev->state & xd->HyperMask)  modifiers |= MOD_HYPER;
1110         if (ev->state & xd->AltMask)    modifiers |= MOD_ALT;
1111         /* Currently ignores Shift_Lock but probably shouldn't
1112            (but it definitely should ignore Caps_Lock). */
1113         emacs_event->event.motion.modifiers = modifiers;
1114       }
1115     break;
1116
1117     case ClientMessage:
1118       {
1119         /* Patch bogus TAKE_FOCUS messages from MWM; CurrentTime is
1120            passed as the timestamp of the TAKE_FOCUS, which the ICCCM
1121            explicitly prohibits. */
1122         XClientMessageEvent *ev = &x_event->xclient;
1123 #ifdef HAVE_OFFIX_DND
1124         if (DndIsDropMessage(x_event))
1125           {
1126             unsigned int state, modifiers = 0, button=0;
1127             struct frame *frame = x_any_window_to_frame (d, ev->window);
1128             Extbyte *data;
1129             unsigned long size, dtype;
1130             Lisp_Object l_type = Qnil, l_data = Qnil;
1131             Lisp_Object l_dndlist = Qnil, l_item = Qnil;
1132             struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
1133
1134             GCPRO4 (l_type, l_data, l_dndlist, l_item);
1135
1136             if (! frame)
1137               return 0; /* not for us */
1138             XSETFRAME (emacs_event->channel, frame);
1139
1140             emacs_event->event_type = misc_user_event;
1141             emacs_event->timestamp  = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1142
1143             state=DndDragButtons(x_event);
1144
1145             if (state & ShiftMask)      modifiers |= MOD_SHIFT;
1146             if (state & ControlMask)    modifiers |= MOD_CONTROL;
1147             if (state & xd->MetaMask)   modifiers |= MOD_META;
1148             if (state & xd->SuperMask)  modifiers |= MOD_SUPER;
1149             if (state & xd->HyperMask)  modifiers |= MOD_HYPER;
1150             if (state & xd->AltMask)    modifiers |= MOD_ALT;
1151
1152             if (state & Button5Mask)    button = Button5;
1153             if (state & Button4Mask)    button = Button4;
1154             if (state & Button3Mask)    button = Button3;
1155             if (state & Button2Mask)    button = Button2;
1156             if (state & Button1Mask)    button = Button1;
1157
1158             emacs_event->event.misc.modifiers = modifiers;
1159             emacs_event->event.misc.button    = button;
1160
1161             DndDropCoordinates(FRAME_X_TEXT_WIDGET(frame), x_event,
1162                                &(emacs_event->event.misc.x),
1163                                &(emacs_event->event.misc.y) );
1164
1165             DndGetData(x_event,&data,&size);
1166
1167             dtype=DndDataType(x_event);
1168             switch (dtype)
1169               {
1170               case DndFiles: /* null terminated strings, end null */
1171                 {
1172                   int len;
1173                   char *hurl = NULL;
1174
1175                   while (*data)
1176                     {
1177                       len = strlen ((char*)data);
1178                       hurl = dnd_url_hexify_string ((char *)data, "file:");
1179                       l_item = make_string ((Bufbyte *)hurl, strlen (hurl));
1180                       l_dndlist = Fcons (l_item, l_dndlist);
1181                       data += len + 1;
1182                       xfree (hurl);
1183                     }
1184                   l_type = Qdragdrop_URL;
1185                 }
1186                 break;
1187               case DndText:
1188                 l_type = Qdragdrop_MIME;
1189                 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"text/plain", 10) ),
1190                                             make_string ((Bufbyte *)"8bit", 4),
1191                                             make_ext_string ((Extbyte *)data,
1192                                                              strlen((char *)data),
1193                                                              FORMAT_CTEXT) ) );
1194                 break;
1195               case DndMIME:
1196                 /* we have to parse this in some way to extract
1197                    content-type and params (in the tm way) and
1198                    content encoding.
1199                    OR: if data is string, let tm do the job
1200                        if data is list[2], give the first two
1201                        to tm...
1202                 */
1203                 l_type = Qdragdrop_MIME;
1204                 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1205                                                      strlen((char *)data),
1206                                                      FORMAT_BINARY) );
1207                 break;
1208               case DndFile:
1209               case DndDir:
1210               case DndLink:
1211               case DndExe:
1212                 {
1213                   char *hurl = dnd_url_hexify_string ((char *) data, "file:");
1214
1215                   l_dndlist = list1 ( make_string ((Bufbyte *)hurl,
1216                                                    strlen (hurl)) );
1217                   l_type = Qdragdrop_URL;
1218
1219                   xfree (hurl);
1220                 }
1221                 break;
1222               case DndURL:
1223                 /* as it is a real URL it should already be escaped
1224                    and escaping again will break them (cause % is unsave) */
1225                 l_dndlist = list1 ( make_ext_string ((Extbyte *)data,
1226                                                      strlen ((char *)data),
1227                                                      FORMAT_FILENAME) );
1228                 l_type = Qdragdrop_URL;
1229                 break;
1230               default: /* Unknown, RawData and any other type */
1231                 l_dndlist = list1 ( list3 ( list1 ( make_string ((Bufbyte *)"application/octet-stream", 24) ),
1232                                             make_string ((Bufbyte *)"8bit", 4),
1233                                             make_ext_string ((Extbyte *)data,
1234                                                              size,
1235                                                              FORMAT_BINARY) ) );
1236                 l_type = Qdragdrop_MIME;
1237                 break;
1238               }
1239
1240             emacs_event->event.misc.function = Qdragdrop_drop_dispatch;
1241             emacs_event->event.misc.object = Fcons (l_type, l_dndlist);
1242
1243             UNGCPRO;
1244
1245             break;
1246           }
1247 #endif /* HAVE_OFFIX_DND */
1248         if (ev->message_type == DEVICE_XATOM_WM_PROTOCOLS (d)
1249             && (Atom) (ev->data.l[0]) == DEVICE_XATOM_WM_TAKE_FOCUS (d)
1250             && (Atom) (ev->data.l[1]) == 0)
1251           {
1252             ev->data.l[1] = DEVICE_X_LAST_SERVER_TIMESTAMP (d);
1253           }
1254       }
1255     /* fall through */
1256
1257     default: /* it's a magic event */
1258       {
1259         struct frame *frame;
1260         Window w;
1261         XEvent *x_event_copy = &emacs_event->event.magic.underlying_x_event;
1262
1263 #define FROB(event_member, window_member) \
1264         x_event_copy->event_member = x_event->event_member; \
1265         w = x_event->event_member.window_member
1266
1267         switch (x_event->type)
1268           {
1269           case SelectionRequest: FROB(xselectionrequest, owner);  break;
1270           case SelectionClear:   FROB(xselectionclear, window);   break;
1271           case SelectionNotify:  FROB(xselection, requestor);     break;
1272           case PropertyNotify:   FROB(xproperty, window);         break;
1273           case ClientMessage:    FROB(xclient, window);           break;
1274           case ConfigureNotify:  FROB(xconfigure, window);        break;
1275           case Expose:
1276           case GraphicsExpose:   FROB(xexpose, window);           break;
1277           case MapNotify:
1278           case UnmapNotify:      FROB(xmap, window);              break;
1279           case EnterNotify:
1280           case LeaveNotify:      FROB(xcrossing, window);         break;
1281           case FocusIn:
1282           case FocusOut:         FROB(xfocus, window);            break;
1283           case VisibilityNotify: FROB(xvisibility, window);       break;
1284           default:
1285             w = x_event->xany.window;
1286             *x_event_copy = *x_event;
1287             break;
1288           }
1289 #undef FROB
1290         frame = x_any_window_to_frame (d, w);
1291
1292         if (!frame)
1293           return 0;
1294
1295         emacs_event->event_type = magic_event;
1296         XSETFRAME (emacs_event->channel, frame);
1297
1298         break;
1299       }
1300     }
1301   return 1;
1302 }
1303
1304
1305 \f
1306 /************************************************************************/
1307 /*                           magic-event handling                       */
1308 /************************************************************************/
1309
1310 static void
1311 handle_focus_event_1 (struct frame *f, int in_p)
1312 {
1313 #if XtSpecificationRelease > 5
1314   Widget focus_widget = XtGetKeyboardFocusWidget (FRAME_X_TEXT_WIDGET (f));
1315 #endif
1316 #ifdef HAVE_XIM
1317   XIM_focus_event (f, in_p);
1318 #endif /* HAVE_XIM */
1319
1320   /* On focus change, clear all memory of sticky modifiers
1321      to avoid non-intuitive behavior. */
1322   clear_sticky_modifiers (XDEVICE (FRAME_DEVICE (f)));
1323
1324   /* We don't want to handle the focus change now, because we might
1325      be in an accept-process-output, sleep-for, or sit-for.  So
1326      we enqueue it.
1327
1328      Actually, we half handle it: we handle it as far as changing the
1329      box cursor for redisplay, but we don't call any hooks or do any
1330      select-frame stuff until after the sit-for.
1331
1332      Unfortunately native widgets break the model because they grab
1333      the keyboard focus and nothing sets it back again. I cannot find
1334      any reasonable way to do this elsewhere so we assert here that
1335      the keybpard focus is on the emacs text widget. Menus and dialogs
1336      do this in their selection callback, but we don't want that since
1337      a button having focus is legitimate. An edit field having focus
1338      is mandatory. Weirdly you get a FocusOut event when you glick in
1339      a widget-glyph but you don't get a correspondng FocusIn when you
1340      click in the frame. Why is this?  */
1341   if (in_p 
1342 #if XtSpecificationRelease > 5      
1343       && FRAME_X_TEXT_WIDGET (f) != focus_widget
1344 #endif
1345       )
1346     {
1347       lw_set_keyboard_focus (FRAME_X_SHELL_WIDGET (f),
1348                              FRAME_X_TEXT_WIDGET (f));
1349     }
1350   /* do the generic event-stream stuff. */
1351   {
1352     Lisp_Object frm;
1353     Lisp_Object conser;
1354     struct gcpro gcpro1;
1355
1356     XSETFRAME (frm, f);
1357     conser = Fcons (frm, Fcons (FRAME_DEVICE (f), in_p ? Qt : Qnil));
1358     GCPRO1 (conser);
1359     emacs_handle_focus_change_preliminary (conser);
1360     enqueue_magic_eval_event (emacs_handle_focus_change_final,
1361                               conser);
1362     UNGCPRO;
1363   }
1364 }
1365
1366 /* This is called from the external-widget code */
1367
1368 void emacs_Xt_handle_focus_event (XEvent *event);
1369 void
1370 emacs_Xt_handle_focus_event (XEvent *event)
1371 {
1372   struct device *d = get_device_from_display (event->xany.display);
1373   struct frame *f;
1374
1375   if (DEVICE_X_BEING_DELETED (d))
1376     return;
1377
1378   /*
1379    * It's curious that we're using x_any_window_to_frame() instead
1380    * of x_window_to_frame().  I don't know what the impact of this is.
1381    */
1382   f = x_any_window_to_frame (d, event->xfocus.window);
1383   if (!f)
1384     /* focus events are sometimes generated just before
1385        a frame is destroyed. */
1386     return;
1387   handle_focus_event_1 (f, event->type == FocusIn);
1388 }
1389
1390 /* both MapNotify and VisibilityNotify can cause this
1391    JV is_visible has the same semantics as f->visible*/
1392 static void
1393 change_frame_visibility (struct frame *f, int is_visible)
1394 {
1395   Lisp_Object frame;
1396
1397   XSETFRAME (frame, f);
1398
1399   if (!FRAME_VISIBLE_P (f) && is_visible)
1400     {
1401       FRAME_VISIBLE_P (f) = is_visible;
1402       /* This improves the double flicker when uniconifying a frame
1403          some.  A lot of it is not showing a buffer which has changed
1404          while the frame was iconified.  To fix it further requires
1405          the good 'ol double redisplay structure. */
1406       MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1407       va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1408     }
1409   else if (FRAME_VISIBLE_P (f) && !is_visible)
1410     {
1411       FRAME_VISIBLE_P (f) = 0;
1412       va_run_hook_with_args (Qunmap_frame_hook, 1, frame);
1413     }
1414   else if (FRAME_VISIBLE_P (f) * is_visible < 0)
1415     {
1416       FRAME_VISIBLE_P(f) = - FRAME_VISIBLE_P(f);
1417       if (FRAME_REPAINT_P(f))
1418               MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f);
1419       va_run_hook_with_args (Qmap_frame_hook, 1, frame);
1420     }
1421 }
1422
1423 static void
1424 handle_map_event (struct frame *f, XEvent *event)
1425 {
1426   Lisp_Object frame;
1427
1428   XSETFRAME (frame, f);
1429   if (event->type == MapNotify)
1430     {
1431       XWindowAttributes xwa;
1432
1433       /* Bleagh!!!!!!  Apparently some window managers (e.g. MWM)
1434          send synthetic MapNotify events when a window is first
1435          created, EVEN IF IT'S CREATED ICONIFIED OR INVISIBLE.
1436          Or something like that.  We initially tried a different
1437          solution below, but that ran into a different window-
1438          manager bug.
1439
1440          It seems that the only reliable way is to treat a
1441          MapNotify event as a "hint" that the window might or
1442          might not be visible, and check explicitly. */
1443
1444       XGetWindowAttributes (event->xany.display, event->xmap.window,
1445                             &xwa);
1446       if (xwa.map_state != IsViewable)
1447         {
1448           /* Calling Fframe_iconified_p is the only way we have to
1449              correctly update FRAME_ICONIFIED_P */
1450           Fframe_iconified_p (frame);
1451           return;
1452         }
1453
1454       FRAME_X_TOTALLY_VISIBLE_P (f) = 1;
1455 #if 0
1456       /* Bleagh again!!!!  We initially tried the following hack
1457          around the MWM problem, but it turns out that TWM
1458          has a race condition when you un-iconify, where it maps
1459          the window and then tells the server that the window
1460          is un-iconified.  Usually, XEmacs wakes up between
1461          those two occurrences, and thus thinks that un-iconified
1462          windows are still iconified.
1463
1464          Ah, the joys of X. */
1465
1466       /* By Emacs definition, a frame that is iconified is not
1467          visible.  Marking a frame as visible will automatically cause
1468          frame-iconified-p to return nil, regardless of whether the
1469          frame is actually iconified.  Therefore, we have to ignore
1470          MapNotify events on iconified frames. (It's not obvious
1471          to me why these are being sent, but it happens at startup
1472          with frames that are initially iconified; perhaps they are
1473          synthetic MapNotify events coming from the window manager.)
1474          Note that `frame-iconified-p' queries the server
1475          to determine whether the frame is currently iconified,
1476          rather than consulting some internal (and likely
1477          inaccurate) state flag.  Therefore, ignoring the MapNotify
1478          is correct. */
1479       if (!FRAME_VISIBLE_P (f) && NILP (Fframe_iconified_p (frame)))
1480 #endif /* 0 */
1481         change_frame_visibility (f, 1);
1482     }
1483   else
1484     {
1485       FRAME_X_TOTALLY_VISIBLE_P (f) = 0;
1486       change_frame_visibility (f, 0);
1487       /* Calling Fframe_iconified_p is the only way we have to
1488          correctly update FRAME_ICONIFIED_P */
1489       Fframe_iconified_p (frame);
1490     }
1491 }
1492
1493 static void
1494 handle_client_message (struct frame *f, XEvent *event)
1495 {
1496   struct device *d = XDEVICE (FRAME_DEVICE (f));
1497   Lisp_Object frame;
1498
1499   XSETFRAME (frame, f);
1500
1501   if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1502       (Atom) (event->xclient.data.l[0]) == DEVICE_XATOM_WM_DELETE_WINDOW (d))
1503     {
1504       /* WM_DELETE_WINDOW is a misc-user event, but other ClientMessages,
1505          such as WM_TAKE_FOCUS, are eval events.  That's because delete-window
1506          was probably executed with a mouse click, while the others could
1507          have been sent as a result of mouse motion or some other implicit
1508          action.  (Call this a "heuristic"...)  The reason for caring about
1509          this is so that clicking on the close-box will make emacs prompt
1510          using a dialog box instead of the minibuffer if there are unsaved
1511          buffers.
1512          */
1513       enqueue_misc_user_event (frame, Qeval,
1514                                list3 (Qdelete_frame, frame, Qt));
1515     }
1516   else if (event->xclient.message_type == DEVICE_XATOM_WM_PROTOCOLS (d) &&
1517            (Atom) event->xclient.data.l[0] == DEVICE_XATOM_WM_TAKE_FOCUS (d))
1518     {
1519       handle_focus_event_1 (f, 1);
1520 #if 0
1521       /* If there is a dialog box up, focus on it.
1522
1523          #### Actually, we're raising it too, which is wrong.  We should
1524          #### just focus on it, but lwlib doesn't currently give us an
1525          #### easy way to do that.  This should be fixed.
1526          */
1527       unsigned long take_focus_timestamp = event->xclient.data.l[1];
1528       Widget widget = lw_raise_all_pop_up_widgets ();
1529       if (widget)
1530         {
1531           /* kludge: raise_all returns bottommost widget, but we really
1532              want the topmost.  So just raise it for now. */
1533           XMapRaised (XtDisplay (widget), XtWindow (widget));
1534           /* Grab the focus with the timestamp of the TAKE_FOCUS. */
1535           XSetInputFocus (XtDisplay (widget), XtWindow (widget),
1536                           RevertToParent, take_focus_timestamp);
1537         }
1538 #endif
1539     }
1540 }
1541
1542 static void
1543 emacs_Xt_handle_magic_event (struct Lisp_Event *emacs_event)
1544 {
1545   /* This function can GC */
1546   XEvent *event = &emacs_event->event.magic.underlying_x_event;
1547   struct frame *f = XFRAME (EVENT_CHANNEL (emacs_event));
1548
1549   if (!FRAME_LIVE_P (f) || DEVICE_X_BEING_DELETED (XDEVICE (FRAME_DEVICE (f))))
1550     return;
1551
1552   switch (event->type)
1553     {
1554     case SelectionRequest:
1555       x_handle_selection_request (&event->xselectionrequest);
1556       break;
1557
1558     case SelectionClear:
1559       x_handle_selection_clear (&event->xselectionclear);
1560       break;
1561
1562     case SelectionNotify:
1563       x_handle_selection_notify (&event->xselection);
1564       break;
1565
1566     case PropertyNotify:
1567       x_handle_property_notify (&event->xproperty);
1568       break;
1569
1570     case Expose:
1571       x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1572                              event->xexpose.width, event->xexpose.height);
1573       break;
1574
1575     case GraphicsExpose: /* This occurs when an XCopyArea's source area was
1576                             obscured or not available. */
1577       x_redraw_exposed_area (f, event->xexpose.x, event->xexpose.y,
1578                              event->xexpose.width, event->xexpose.height);
1579       break;
1580
1581     case MapNotify:
1582     case UnmapNotify:
1583       handle_map_event (f, event);
1584       break;
1585
1586     case EnterNotify:
1587       if (event->xcrossing.detail != NotifyInferior)
1588         {
1589           Lisp_Object frame;
1590
1591           XSETFRAME (frame, f);
1592           /* FRAME_X_MOUSE_P (f) = 1; */
1593           va_run_hook_with_args (Qmouse_enter_frame_hook, 1, frame);
1594         }
1595       break;
1596
1597     case LeaveNotify:
1598       if (event->xcrossing.detail != NotifyInferior)
1599         {
1600           Lisp_Object frame;
1601
1602           XSETFRAME (frame, f);
1603           /* FRAME_X_MOUSE_P (f) = 0; */
1604           va_run_hook_with_args (Qmouse_leave_frame_hook, 1, frame);
1605         }
1606       break;
1607
1608     case FocusIn:
1609     case FocusOut:
1610
1611 #ifdef EXTERNAL_WIDGET
1612       /* External widget lossage: Ben said:
1613          YUCK.  The only way to make focus changes work properly is to
1614          completely ignore all FocusIn/FocusOut events and depend only
1615          on notifications from the ExternalClient widget. */
1616       if (FRAME_X_EXTERNAL_WINDOW_P (f))
1617         break;
1618 #endif
1619       handle_focus_event_1 (f, event->type == FocusIn);
1620       break;
1621
1622     case ClientMessage:
1623       handle_client_message (f, event);
1624       break;
1625
1626     case VisibilityNotify: /* window visibility has changed */
1627       if (event->xvisibility.window == XtWindow (FRAME_X_SHELL_WIDGET (f)))
1628         {
1629           FRAME_X_TOTALLY_VISIBLE_P (f) =
1630             (event->xvisibility.state == VisibilityUnobscured);
1631           /* Note that the fvwm pager only sends VisibilityNotify when
1632              changing pages. Is this all we need to do ? JV */
1633           /* Nope.  We must at least trigger a redisplay here.
1634              Since this case seems similar to MapNotify, I've
1635              factored out some code to change_frame_visibility().
1636              This triggers the necessary redisplay and runs
1637              (un)map-frame-hook.  - dkindred@cs.cmu.edu */
1638           /* Changed it again to support the tristate visibility flag */
1639           change_frame_visibility (f, (event->xvisibility.state
1640                                        != VisibilityFullyObscured) ? 1 : -1);
1641         }
1642       break;
1643
1644     case ConfigureNotify:
1645 #ifdef HAVE_XIM
1646       XIM_SetGeometry (f);
1647 #endif
1648       break;
1649
1650     default:
1651       break;
1652     }
1653 }
1654
1655 \f
1656 /************************************************************************/
1657 /*                              timeout events                          */
1658 /************************************************************************/
1659
1660 static int timeout_id_tick;
1661
1662 /* Xt interval id's might not fit into an int (they're pointers, as it
1663    happens), so we need to provide a conversion list. */
1664
1665 struct Xt_timeout
1666 {
1667   int id;
1668   XtIntervalId interval_id;
1669   struct Xt_timeout *next;
1670 } *pending_timeouts, *completed_timeouts;
1671
1672 struct Xt_timeout_blocktype
1673 {
1674   Blocktype_declare (struct Xt_timeout);
1675 } *the_Xt_timeout_blocktype;
1676
1677 /* called by XtAppNextEvent() */
1678 static void
1679 Xt_timeout_callback (XtPointer closure, XtIntervalId *id)
1680 {
1681   struct Xt_timeout *timeout = (struct Xt_timeout *) closure;
1682   struct Xt_timeout *t2 = pending_timeouts;
1683   /* Remove this one from the list of pending timeouts */
1684   if (t2 == timeout)
1685     pending_timeouts = pending_timeouts->next;
1686   else
1687     {
1688       while (t2->next && t2->next != timeout) t2 = t2->next;
1689       assert (t2->next);
1690       t2->next = t2->next->next;
1691     }
1692   /* Add this one to the list of completed timeouts */
1693   timeout->next = completed_timeouts;
1694   completed_timeouts = timeout;
1695 }
1696
1697 static int
1698 emacs_Xt_add_timeout (EMACS_TIME thyme)
1699 {
1700   struct Xt_timeout *timeout = Blocktype_alloc (the_Xt_timeout_blocktype);
1701   EMACS_TIME current_time;
1702   int milliseconds;
1703
1704   timeout->id = timeout_id_tick++;
1705   timeout->next = pending_timeouts;
1706   pending_timeouts = timeout;
1707   EMACS_GET_TIME (current_time);
1708   EMACS_SUB_TIME (thyme, thyme, current_time);
1709   milliseconds = EMACS_SECS (thyme) * 1000 +
1710     EMACS_USECS (thyme) / 1000;
1711   if (milliseconds < 1)
1712     milliseconds = 1;
1713   timeout->interval_id = XtAppAddTimeOut (Xt_app_con, milliseconds,
1714                                           Xt_timeout_callback,
1715                                           (XtPointer) timeout);
1716   return timeout->id;
1717 }
1718
1719 static void
1720 emacs_Xt_remove_timeout (int id)
1721 {
1722   struct Xt_timeout *timeout, *t2;
1723
1724   timeout = NULL;
1725
1726   /* Find the timeout on the list of pending ones, if it's still there. */
1727   if (pending_timeouts)
1728     {
1729       if (id == pending_timeouts->id)
1730         {
1731           timeout = pending_timeouts;
1732           pending_timeouts = pending_timeouts->next;
1733         }
1734       else
1735         {
1736           t2 = pending_timeouts;
1737           while (t2->next && t2->next->id != id) t2 = t2->next;
1738           if ( t2->next)   /*found it */
1739             {
1740               timeout = t2->next;
1741               t2->next = t2->next->next;
1742             }
1743         }
1744       /* if it was pending, we have removed it from the list */
1745       if (timeout)
1746         XtRemoveTimeOut (timeout->interval_id);
1747     }
1748
1749   /* It could be that the Xt call back was already called but we didn't convert
1750      into an Emacs event yet */
1751   if (!timeout && completed_timeouts)
1752     {
1753       /* Code duplication! */
1754       if (id == completed_timeouts->id)
1755         {
1756           timeout = completed_timeouts;
1757           completed_timeouts = completed_timeouts->next;
1758         }
1759       else
1760         {
1761           t2 = completed_timeouts;
1762           while (t2->next && t2->next->id != id) t2 = t2->next;
1763           if ( t2->next)   /*found it */
1764             {
1765               timeout = t2->next;
1766               t2->next = t2->next->next;
1767             }
1768         }
1769     }
1770
1771   /* If we found the thing on the lists of timeouts,
1772      and removed it, deallocate
1773   */
1774   if (timeout)
1775     Blocktype_free (the_Xt_timeout_blocktype, timeout);
1776 }
1777
1778 static void
1779 Xt_timeout_to_emacs_event (struct Lisp_Event *emacs_event)
1780 {
1781   struct Xt_timeout *timeout = completed_timeouts;
1782   assert (timeout);
1783   completed_timeouts = completed_timeouts->next;
1784   emacs_event->event_type = timeout_event;
1785   /* timeout events have nil as channel */
1786   emacs_event->timestamp  = 0; /* #### wrong!! */
1787   emacs_event->event.timeout.interval_id = timeout->id;
1788   emacs_event->event.timeout.function = Qnil;
1789   emacs_event->event.timeout.object = Qnil;
1790   Blocktype_free (the_Xt_timeout_blocktype, timeout);
1791 }
1792
1793 \f
1794 /************************************************************************/
1795 /*                      process and tty events                          */
1796 /************************************************************************/
1797
1798 struct what_is_ready_closure
1799 {
1800   int fd;
1801   Lisp_Object what;
1802   XtInputId id;
1803 };
1804
1805 static Lisp_Object *filedesc_with_input;
1806 static struct what_is_ready_closure **filedesc_to_what_closure;
1807
1808 static void
1809 init_what_input_once (void)
1810 {
1811   int i;
1812
1813   filedesc_with_input = xnew_array (Lisp_Object, MAXDESC);
1814   filedesc_to_what_closure =
1815     xnew_array (struct what_is_ready_closure *, MAXDESC);
1816
1817   for (i = 0; i < MAXDESC; i++)
1818     {
1819       filedesc_to_what_closure[i] = 0;
1820       filedesc_with_input[i] = Qnil;
1821     }
1822
1823   process_events_occurred = 0;
1824   tty_events_occurred = 0;
1825 }
1826
1827 static void
1828 mark_what_as_being_ready (struct what_is_ready_closure *closure)
1829 {
1830   if (NILP (filedesc_with_input[closure->fd]))
1831     {
1832       SELECT_TYPE temp_mask;
1833       FD_ZERO (&temp_mask);
1834       FD_SET (closure->fd, &temp_mask);
1835       /* Check to make sure there's *really* input available.
1836          Sometimes things seem to get confused and this gets called
1837          for the tty fd when there's really only input available
1838          on some process's fd.  (It will subsequently get called
1839          for that process's fd, so returning without setting any
1840          flags will take care of it.)  To see the problem, uncomment
1841          the stderr_out below, turn NORMAL_QUIT_CHECK_TIMEOUT_MSECS
1842          down to 25, do sh -c 'xemacs -nw -q -f shell 2>/tmp/log'
1843          and press return repeatedly.  (Seen under AIX & Linux.)
1844          -dkindred@cs.cmu.edu */
1845       if (!poll_fds_for_input (temp_mask))
1846         {
1847 #if 0
1848           stderr_out ("mark_what_as_being_ready: no input available (fd=%d)\n",
1849                       closure->fd);
1850 #endif
1851           return;
1852         }
1853       filedesc_with_input[closure->fd] = closure->what;
1854       if (PROCESSP (closure->what))
1855       /* Don't increment this if the current process is already marked
1856        *  as having input. */
1857         process_events_occurred++;
1858       else
1859         tty_events_occurred++;
1860     }
1861 }
1862
1863 static void
1864 Xt_what_callback (void *closure, int *source, XtInputId *id)
1865 {
1866   /* If closure is 0, then we got a fake event from a signal handler.
1867      The only purpose of this is to make XtAppProcessEvent() stop
1868      blocking. */
1869   if (closure)
1870     mark_what_as_being_ready ((struct what_is_ready_closure *) closure);
1871   else
1872     {
1873       fake_event_occurred++;
1874       drain_signal_event_pipe ();
1875     }
1876 }
1877
1878 static void
1879 select_filedesc (int fd, Lisp_Object what)
1880 {
1881   struct what_is_ready_closure *closure;
1882
1883   /* If somebody is trying to select something that's already selected
1884      for, then something went wrong.  The generic routines ought to
1885      detect this and error before here. */
1886   assert (!filedesc_to_what_closure[fd]);
1887
1888   closure = xnew (struct what_is_ready_closure);
1889   closure->fd = fd;
1890   closure->what = what;
1891   closure->id =
1892     XtAppAddInput (Xt_app_con, fd,
1893                    (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
1894                    Xt_what_callback, closure);
1895   filedesc_to_what_closure[fd] = closure;
1896 }
1897
1898 static void
1899 unselect_filedesc (int fd)
1900 {
1901   struct what_is_ready_closure *closure = filedesc_to_what_closure[fd];
1902
1903   assert (closure);
1904   if (!NILP (filedesc_with_input[fd]))
1905     {
1906       /* We are unselecting this process before we have drained the rest of
1907          the input from it, probably from status_notify() in the command loop.
1908          This can happen like so:
1909
1910           - We are waiting in XtAppNextEvent()
1911           - Process generates output
1912           - Process is marked as being ready
1913           - Process dies, SIGCHLD gets generated before we return (!?)
1914             It could happen I guess.
1915           - sigchld_handler() marks process as dead
1916           - Somehow we end up getting a new KeyPress event on the queue
1917             at the same time (I'm really so sure how that happens but I'm
1918             not sure it can't either so let's assume it can...).
1919           - Key events have priority so we return that instead of the proc.
1920           - Before dispatching the lisp key event we call status_notify()
1921           - Which deselects the process that SIGCHLD marked as dead.
1922
1923          Thus we never remove it from _with_input and turn it into a lisp
1924          event, so we need to do it here.  But this does not mean that we're
1925          throwing away the last block of output - status_notify() has already
1926          taken care of running the proc filter or whatever.
1927        */
1928       filedesc_with_input[fd] = Qnil;
1929       if (PROCESSP (closure->what))
1930         {
1931           assert (process_events_occurred > 0);
1932           process_events_occurred--;
1933         }
1934       else
1935         {
1936           assert (tty_events_occurred > 0);
1937           tty_events_occurred--;
1938         }
1939     }
1940   XtRemoveInput (closure->id);
1941   xfree (closure);
1942   filedesc_to_what_closure[fd] = 0;
1943 }
1944
1945 static void
1946 emacs_Xt_select_process (struct Lisp_Process *p)
1947 {
1948   Lisp_Object process;
1949   int infd = event_stream_unixoid_select_process (p);
1950
1951   XSETPROCESS (process, p);
1952   select_filedesc (infd, process);
1953 }
1954
1955 static void
1956 emacs_Xt_unselect_process (struct Lisp_Process *p)
1957 {
1958   int infd = event_stream_unixoid_unselect_process (p);
1959
1960   unselect_filedesc (infd);
1961 }
1962
1963 static USID
1964 emacs_Xt_create_stream_pair (void* inhandle, void* outhandle,
1965                 Lisp_Object* instream, Lisp_Object* outstream, int flags)
1966 {
1967   USID u = event_stream_unixoid_create_stream_pair
1968                 (inhandle, outhandle, instream, outstream, flags);
1969   if (u != USID_ERROR)
1970     u = USID_DONTHASH;
1971   return u;
1972 }
1973
1974 static USID
1975 emacs_Xt_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream)
1976 {
1977   event_stream_unixoid_delete_stream_pair (instream, outstream);
1978   return USID_DONTHASH;
1979 }
1980
1981 /* This is called from GC when a process object is about to be freed.
1982    If we've still got pointers to it in this file, we're gonna lose hard.
1983  */
1984 void
1985 debug_process_finalization (struct Lisp_Process *p)
1986 {
1987 #if 0 /* #### */
1988   int i;
1989   Lisp_Object instr, outstr;
1990
1991   get_process_streams (p, &instr, &outstr);
1992   /* if it still has fds, then it hasn't been killed yet. */
1993   assert (NILP(instr));
1994   assert (NILP(outstr));
1995   /* Better not still be in the "with input" table; we know it's got no fds. */
1996   for (i = 0; i < MAXDESC; i++)
1997     {
1998       Lisp_Object process = filedesc_fds_with_input [i];
1999       assert (!PROCESSP (process) || XPROCESS (process) != p);
2000     }
2001 #endif
2002 }
2003
2004 static void
2005 Xt_process_to_emacs_event (struct Lisp_Event *emacs_event)
2006 {
2007   int i;
2008   Lisp_Object process;
2009
2010   assert (process_events_occurred > 0);
2011   for (i = 0; i < MAXDESC; i++)
2012     {
2013       process = filedesc_with_input[i];
2014       if (PROCESSP (process))
2015         break;
2016     }
2017   assert (i < MAXDESC);
2018   filedesc_with_input[i] = Qnil;
2019   process_events_occurred--;
2020   /* process events have nil as channel */
2021   emacs_event->event_type = process_event;
2022   emacs_event->timestamp  = 0; /* #### */
2023   emacs_event->event.process.process = process;
2024 }
2025
2026 static void
2027 emacs_Xt_select_console (struct console *con)
2028 {
2029   Lisp_Object console;
2030   int infd;
2031 #ifdef HAVE_GPM
2032   int mousefd;
2033 #endif
2034
2035   if (CONSOLE_X_P (con))
2036     return; /* X consoles are automatically selected for when we
2037                initialize them in Xt */
2038   infd = event_stream_unixoid_select_console (con);
2039   XSETCONSOLE (console, con);
2040   select_filedesc (infd, console);
2041 #ifdef HAVE_GPM
2042   /* On a stream device (ie: noninteractive), bad things can happen. */
2043   if (EQ (CONSOLE_TYPE (con), Qtty)) {
2044     mousefd = CONSOLE_TTY_MOUSE_FD (con);
2045         /* We check filedesc_to_what_closure[fd] here because if you run
2046         ** XEmacs from a TTY, it will fire up GPM, select the mouse fd, then
2047         ** if you run gnuattach to connect to another TTY, it will fire up
2048         ** GPM again, and try to reselect the mouse fd.  GPM uses the same
2049         ** fd for every connection apparently, and select_filedesc will
2050         ** fail its assertion if we try to select it twice.
2051         */
2052     if ((mousefd >= 0) && !filedesc_to_what_closure[mousefd]) {
2053       select_filedesc (mousefd, console);
2054     }
2055   }
2056 #endif
2057 }
2058
2059 static void
2060 emacs_Xt_unselect_console (struct console *con)
2061 {
2062   Lisp_Object console;
2063   int infd;
2064 #ifdef HAVE_GPM
2065   int mousefd;
2066 #endif
2067
2068   if (CONSOLE_X_P (con))
2069     return; /* X consoles are automatically selected for when we
2070                initialize them in Xt */
2071   infd = event_stream_unixoid_unselect_console (con);
2072   XSETCONSOLE (console, con);
2073   unselect_filedesc (infd);
2074 #ifdef HAVE_GPM
2075   /* On a stream device (ie: noninteractive), bad things can happen. */
2076   if (EQ (CONSOLE_TYPE (con), Qtty)) {
2077     mousefd = CONSOLE_TTY_MOUSE_FD (con);
2078     if (mousefd >= 0) {
2079       unselect_filedesc (mousefd);
2080     }
2081   }
2082 #endif
2083 }
2084
2085 /* read an event from a tty, if one is available.  Returns non-zero
2086    if an event was available.  Note that when this function is
2087    called, there should always be a tty marked as ready for input.
2088    However, the input condition might actually be EOF, so there
2089    may not really be any input available. (In this case,
2090    read_event_from_tty_or_stream_desc() will arrange for the TTY device
2091    to be deleted.) */
2092
2093 static int
2094 Xt_tty_to_emacs_event (struct Lisp_Event *emacs_event)
2095 {
2096   int i;
2097
2098   assert (tty_events_occurred > 0);
2099   for (i = 0; i < MAXDESC; i++)
2100     {
2101       Lisp_Object console = filedesc_with_input[i];
2102       if (CONSOLEP (console))
2103         {
2104           assert (tty_events_occurred > 0);
2105           tty_events_occurred--;
2106           filedesc_with_input[i] = Qnil;
2107           if (read_event_from_tty_or_stream_desc
2108               (emacs_event, XCONSOLE (console), i))
2109             return 1;
2110         }
2111     }
2112
2113   return 0;
2114 }
2115
2116 \f
2117 /************************************************************************/
2118 /*              debugging functions to decipher an event                */
2119 /************************************************************************/
2120
2121 #ifdef DEBUG_XEMACS
2122 #include "xintrinsicp.h"        /* only describe_event() needs this */
2123 #include <X11/Xproto.h>         /* only describe_event() needs this */
2124
2125 static void
2126 describe_event_window (Window window, Display *display)
2127 {
2128   struct frame *f;
2129   Widget w;
2130   stderr_out ("   window: 0x%lx", (unsigned long) window);
2131   w = XtWindowToWidget (display, window);
2132   if (w)
2133     stderr_out (" %s", w->core.widget_class->core_class.class_name);
2134   f = x_any_window_to_frame (get_device_from_display (display), window);
2135   if (f)
2136     {
2137       char *buf = alloca_array (char, XSTRING_LENGTH (f->name) + 4);
2138       sprintf (buf, " \"%s\"", XSTRING_DATA (f->name));
2139       write_string_to_stdio_stream (stderr, 0, (Bufbyte *) buf, 0,
2140                                     strlen (buf), FORMAT_TERMINAL);
2141     }
2142   stderr_out ("\n");
2143 }
2144
2145 static CONST char *
2146 XEvent_mode_to_string (int mode)
2147 {
2148   switch (mode)
2149   {
2150   case NotifyNormal:       return "Normal";
2151   case NotifyGrab:         return "Grab";
2152   case NotifyUngrab:       return "Ungrab";
2153   case NotifyWhileGrabbed: return "WhileGrabbed";
2154   default:                 return "???";
2155   }
2156 }
2157
2158 static CONST char *
2159 XEvent_detail_to_string (int detail)
2160 {
2161   switch (detail)
2162   {
2163   case NotifyAncestor:          return "Ancestor";
2164   case NotifyInferior:          return "Inferior";
2165   case NotifyNonlinear:         return "Nonlinear";
2166   case NotifyNonlinearVirtual:  return "NonlinearVirtual";
2167   case NotifyPointer:           return "Pointer";
2168   case NotifyPointerRoot:       return "PointerRoot";
2169   case NotifyDetailNone:        return "DetailNone";
2170   default:                      return "???";
2171   }
2172 }
2173
2174 static CONST char *
2175 XEvent_visibility_to_string (int state)
2176 {
2177   switch (state)
2178   {
2179   case VisibilityFullyObscured:     return "FullyObscured";
2180   case VisibilityPartiallyObscured: return "PartiallyObscured";
2181   case VisibilityUnobscured:        return "Unobscured";
2182   default:                          return "???";
2183   }
2184 }
2185
2186 static void
2187 describe_event (XEvent *event)
2188 {
2189   char buf[100];
2190   struct device *d = get_device_from_display (event->xany.display);
2191
2192   sprintf (buf, "%s%s", x_event_name (event->type),
2193            event->xany.send_event ? " (send)" : "");
2194   stderr_out ("%-30s", buf);
2195   switch (event->type)
2196     {
2197     case FocusIn:
2198     case FocusOut:
2199       {
2200         XFocusChangeEvent *ev = &event->xfocus;
2201         describe_event_window (ev->window, ev->display);
2202         stderr_out ("     mode: %s\n",   XEvent_mode_to_string  (ev->mode));
2203         stderr_out ("     detail: %s\n", XEvent_detail_to_string(ev->detail));
2204         break;
2205       }
2206
2207     case KeyPress:
2208       {
2209         XKeyEvent *ev = &event->xkey;
2210         unsigned int state = ev->state;
2211
2212         describe_event_window (ev->window, ev->display);
2213         stderr_out ("   subwindow: %ld\n", ev->subwindow);
2214         stderr_out ("   state: ");
2215         /* Complete list of modifier key masks */
2216         if (state & ShiftMask)   stderr_out ("Shift ");
2217         if (state & LockMask)    stderr_out ("Lock ");
2218         if (state & ControlMask) stderr_out ("Control ");
2219         if (state & Mod1Mask)    stderr_out ("Mod1 ");
2220         if (state & Mod2Mask)    stderr_out ("Mod2 ");
2221         if (state & Mod3Mask)    stderr_out ("Mod3 ");
2222         if (state & Mod4Mask)    stderr_out ("Mod4 ");
2223         if (state & Mod5Mask)    stderr_out ("Mod5 ");
2224
2225         if (! state)
2226           stderr_out ("vanilla\n");
2227         else
2228           stderr_out ("\n");
2229         if (x_key_is_modifier_p (ev->keycode, d))
2230           stderr_out ("   Modifier key");
2231         stderr_out ("   keycode: 0x%x\n", ev->keycode);
2232       }
2233     break;
2234
2235     case Expose:
2236       if (x_debug_events > 1)
2237         {
2238           XExposeEvent *ev = &event->xexpose;
2239           describe_event_window (ev->window, ev->display);
2240           stderr_out ("   region: x=%d y=%d width=%d height=%d\n",
2241                       ev->x, ev->y, ev->width, ev->height);
2242           stderr_out ("    count: %d\n", ev->count);
2243         }
2244       else
2245         stderr_out ("\n");
2246       break;
2247
2248     case GraphicsExpose:
2249       if (x_debug_events > 1)
2250         {
2251           XGraphicsExposeEvent *ev = &event->xgraphicsexpose;
2252           describe_event_window (ev->drawable, ev->display);
2253           stderr_out ("    major: %s\n",
2254                       (ev ->major_code == X_CopyArea  ? "CopyArea" :
2255                        (ev->major_code == X_CopyPlane ? "CopyPlane" : "?")));
2256           stderr_out ("   region: x=%d y=%d width=%d height=%d\n",
2257                       ev->x, ev->y, ev->width, ev->height);
2258           stderr_out ("    count: %d\n", ev->count);
2259         }
2260       else
2261         stderr_out ("\n");
2262       break;
2263
2264     case EnterNotify:
2265     case LeaveNotify:
2266       if (x_debug_events > 1)
2267         {
2268           XCrossingEvent *ev = &event->xcrossing;
2269           describe_event_window (ev->window, ev->display);
2270 #if 0
2271           stderr_out(" subwindow: 0x%x\n", ev->subwindow);
2272           stderr_out("      pos: %d %d\n", ev->x, ev->y);
2273           stderr_out(" root pos: %d %d\n", ev->x_root, ev->y_root);
2274 #endif
2275           stderr_out("    mode: %s\n",   XEvent_mode_to_string(ev->mode));
2276           stderr_out("    detail: %s\n", XEvent_detail_to_string(ev->detail));
2277           stderr_out("    focus: %d\n", ev->focus);
2278 #if 0
2279           stderr_out("    state: 0x%x\n", ev->state);
2280 #endif
2281         }
2282       else
2283         stderr_out("\n");
2284       break;
2285
2286     case ConfigureNotify:
2287       if (x_debug_events > 1)
2288         {
2289           XConfigureEvent *ev = &event->xconfigure;
2290           describe_event_window (ev->window, ev->display);
2291           stderr_out("    above: 0x%lx\n", ev->above);
2292           stderr_out("     size: %d %d %d %d\n", ev->x, ev->y,
2293                      ev->width, ev->height);
2294           stderr_out("  redirect: %d\n", ev->override_redirect);
2295         }
2296       else
2297         stderr_out("\n");
2298       break;
2299
2300     case VisibilityNotify:
2301       if (x_debug_events > 1)
2302         {
2303           XVisibilityEvent *ev = &event->xvisibility;
2304           describe_event_window (ev->window, ev->display);
2305           stderr_out("    state: %s\n", XEvent_visibility_to_string(ev->state));
2306         }
2307       else
2308         stderr_out ("\n");
2309       break;
2310
2311     case ClientMessage:
2312       {
2313         XClientMessageEvent *ev = &event->xclient;
2314         char *name = XGetAtomName (ev->display, ev->message_type);
2315         stderr_out ("%s", name);
2316         if (!strcmp (name, "WM_PROTOCOLS")) {
2317           char *protname = XGetAtomName (ev->display, ev->data.l[0]);
2318           stderr_out ("(%s)", protname);
2319           XFree (protname);
2320         }
2321         XFree (name);
2322         stderr_out ("\n");
2323         break;
2324       }
2325
2326     default:
2327       stderr_out ("\n");
2328       break;
2329     }
2330
2331   fflush (stdout);
2332 }
2333
2334 #endif /* include describe_event definition */
2335
2336 \f
2337 /************************************************************************/
2338 /*                      get the next event from Xt                      */
2339 /************************************************************************/
2340
2341 static Lisp_Object dispatch_event_queue, dispatch_event_queue_tail;
2342
2343 static void
2344 enqueue_Xt_dispatch_event (Lisp_Object event)
2345 {
2346   enqueue_event (event, &dispatch_event_queue, &dispatch_event_queue_tail);
2347 }
2348
2349 static Lisp_Object
2350 dequeue_Xt_dispatch_event (void)
2351 {
2352   return dequeue_event (&dispatch_event_queue, &dispatch_event_queue_tail);
2353 }
2354
2355 /* This business exists because menu events "happen" when
2356    menubar_selection_callback() is called from somewhere deep
2357    within XtAppProcessEvent in emacs_Xt_next_event().  The
2358    callback needs to terminate the modal loop in that function
2359    or else it will continue waiting until another event is
2360    received.
2361
2362    Same business applies to scrollbar events. */
2363
2364 void
2365 signal_special_Xt_user_event (Lisp_Object channel, Lisp_Object function,
2366                               Lisp_Object object)
2367 {
2368   Lisp_Object event = Fmake_event (Qnil, Qnil);
2369
2370   XEVENT (event)->event_type = misc_user_event;
2371   XEVENT (event)->channel = channel;
2372   XEVENT (event)->event.eval.function = function;
2373   XEVENT (event)->event.eval.object = object;
2374
2375   enqueue_Xt_dispatch_event (event);
2376 }
2377
2378 static void
2379 emacs_Xt_next_event (struct Lisp_Event *emacs_event)
2380 {
2381  we_didnt_get_an_event:
2382
2383   while (NILP (dispatch_event_queue) &&
2384          !completed_timeouts         &&
2385          !fake_event_occurred        &&
2386          !process_events_occurred    &&
2387          !tty_events_occurred)
2388     {
2389
2390       /* Stupid logic in XtAppProcessEvent() dictates that, if process
2391          events and X events are both available, the process event gets
2392          taken first.  This will cause an infinite loop if we're being
2393          called from Fdiscard_input().
2394        */
2395       if (XtAppPending (Xt_app_con) & XtIMXEvent)
2396         XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2397       else
2398         {
2399           Lisp_Object devcons, concons;
2400
2401           /* We're about to block.  Xt has a bug in it (big surprise,
2402              there) in that it blocks using select() and doesn't
2403              flush the Xlib output buffers (XNextEvent() does this
2404              automatically before blocking).  So it's necessary
2405              for us to do this ourselves.  If we don't do it, then
2406              display output may not be seen until the next time
2407              an X event is received. (This happens esp. with
2408              subprocess output that gets sent to a visible buffer.)
2409
2410              #### The above comment may not have any validity. */
2411
2412           DEVICE_LOOP_NO_BREAK (devcons, concons)
2413             {
2414               struct device *d;
2415               d = XDEVICE (XCAR (devcons));
2416
2417               if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2418                 /* emacs may be exiting */
2419                 XFlush (DEVICE_X_DISPLAY (d));
2420             }
2421           XtAppProcessEvent (Xt_app_con, XtIMAll);
2422         }
2423     }
2424
2425   if (!NILP (dispatch_event_queue))
2426     {
2427       Lisp_Object event, event2;
2428       XSETEVENT (event2, emacs_event);
2429       event = dequeue_Xt_dispatch_event ();
2430       Fcopy_event (event, event2);
2431       Fdeallocate_event (event);
2432     }
2433   else if (tty_events_occurred)
2434     {
2435       if (!Xt_tty_to_emacs_event (emacs_event))
2436         goto we_didnt_get_an_event;
2437     }
2438   else if (completed_timeouts)
2439     Xt_timeout_to_emacs_event (emacs_event);
2440   else if (fake_event_occurred)
2441     {
2442       /* A dummy event, so that a cycle of the command loop will occur. */
2443       fake_event_occurred = 0;
2444       /* eval events have nil as channel */
2445       emacs_event->event_type = eval_event;
2446       emacs_event->event.eval.function = Qidentity;
2447       emacs_event->event.eval.object = Qnil;
2448     }
2449   else /* if (process_events_occurred) */
2450     Xt_process_to_emacs_event (emacs_event);
2451
2452   /* No need to call XFilterEvent; Xt does it for us */
2453 }
2454
2455 void
2456 emacs_Xt_event_handler (Widget wid /* unused */,
2457                         XtPointer closure /* unused */,
2458                         XEvent *event,
2459                         Boolean *continue_to_dispatch /* unused */)
2460 {
2461   Lisp_Object emacs_event = Fmake_event (Qnil, Qnil);
2462
2463 #ifdef DEBUG_XEMACS
2464   if (x_debug_events > 0)
2465     {
2466       describe_event (event);
2467     }
2468 #endif /* DEBUG_XEMACS */
2469   if (x_event_to_emacs_event (event, XEVENT (emacs_event)))
2470     enqueue_Xt_dispatch_event (emacs_event);
2471   else
2472     Fdeallocate_event (emacs_event);
2473 }
2474
2475 \f
2476 /************************************************************************/
2477 /*                      input pending / C-g checking                    */
2478 /************************************************************************/
2479
2480 static Bool
2481 quit_char_predicate (Display *display, XEvent *event, XPointer data)
2482 {
2483   struct device *d = get_device_from_display (display);
2484   struct x_device *xd = DEVICE_X_DATA (d);
2485   char c, quit_char;
2486   Bool *critical = (Bool *) data;
2487   Lisp_Object keysym;
2488
2489   if (critical)
2490     *critical = False;
2491   if ((event->type != KeyPress) ||
2492       (! x_any_window_to_frame (d, event->xany.window)) ||
2493       (event->xkey.state
2494        & (xd->MetaMask | xd->HyperMask | xd->SuperMask | xd->AltMask)))
2495     return 0;
2496
2497   /* This duplicates some code that exists elsewhere, but it's relatively
2498      fast and doesn't cons. */
2499   keysym = x_to_emacs_keysym (&event->xkey, 1);
2500   if (NILP (keysym)) return 0;
2501   if (CHAR_OR_CHAR_INTP (keysym))
2502     c = XCHAR_OR_CHAR_INT (keysym);
2503   /* Highly doubtful that these are the quit character, but... */
2504   else if (EQ (keysym, QKbackspace))    c = '\b';
2505   else if (EQ (keysym, QKtab))          c = '\t';
2506   else if (EQ (keysym, QKlinefeed))     c = '\n';
2507   else if (EQ (keysym, QKreturn))       c = '\r';
2508   else if (EQ (keysym, QKescape))       c = 27;
2509   else if (EQ (keysym, QKspace))        c = ' ';
2510   else if (EQ (keysym, QKdelete))       c = 127;
2511   else return 0;
2512
2513   if (event->xkey.state & xd->MetaMask)     c |= 0x80;
2514   if ((event->xkey.state & ControlMask) && !(c >= 'A' && c <= 'Z'))
2515     c &= 0x1F;                  /* unshifted control characters */
2516   quit_char = CONSOLE_QUIT_CHAR (XCONSOLE (DEVICE_CONSOLE (d)));
2517   if (c == quit_char)
2518     return True;
2519   /* If we've got Control-Shift-G instead of Control-G, that means
2520      we have a critical_quit.  Caps_Lock is its own modifier, so it
2521      won't cause ^G to act differently than before. */
2522   if (event->xkey.state & ControlMask)  c &= 0x1F;
2523   if (c == quit_char)
2524     {
2525       if (critical) *critical = True;
2526       return True;
2527     }
2528   return False;
2529 }
2530
2531 /* This scans the X input queue for a KeyPress event that matches the
2532    quit character, and sets Vquit_flag.  This is called from the
2533    QUIT macro to determine whether we should quit.
2534
2535    In a SIGIO world, this won't be called unless a SIGIO has happened
2536    since the last time we checked.
2537
2538    In a non-SIGIO world, this is called from emacs_Xt_event_pending_p
2539    (which is called from input_pending_p).
2540  */
2541 static void
2542 x_check_for_quit_char (Display *display)
2543 {
2544   XEvent event;
2545   int queued;
2546   Bool critical_quit = False;
2547   XEventsQueued (display, QueuedAfterReading);
2548   queued = XCheckIfEvent (display, &event,
2549                           quit_char_predicate,
2550                           (char *) &critical_quit);
2551   if (queued)
2552     {
2553       Vquit_flag = (critical_quit ? Qcritical : Qt);
2554       /* don't put the event back onto the queue.  Those functions that
2555          wanted to read a ^G directly have arranged to do this. */
2556     }
2557 }
2558
2559 static void
2560 check_for_tty_quit_char (struct device *d)
2561 {
2562   SELECT_TYPE temp_mask;
2563   int infd = DEVICE_INFD (d);
2564   struct console *con = XCONSOLE (DEVICE_CONSOLE (d));
2565   Emchar quit_char = CONSOLE_QUIT_CHAR (con);
2566
2567   FD_ZERO (&temp_mask);
2568   FD_SET (infd, &temp_mask);
2569
2570   while (1)
2571     {
2572       Lisp_Object event;
2573       Emchar the_char;
2574
2575       if (!poll_fds_for_input (temp_mask))
2576         return;
2577
2578       event = Fmake_event (Qnil, Qnil);
2579       if (!read_event_from_tty_or_stream_desc (XEVENT (event), con, infd))
2580         /* EOF, or something ... */
2581         return;
2582       /* #### bogus.  quit-char should be allowed to be any sort
2583          of event. */
2584       the_char = event_to_character (XEVENT (event), 1, 0, 0);
2585       if (the_char >= 0 && the_char == quit_char)
2586         {
2587           Vquit_flag = Qt;
2588           /* do not queue the C-g.  See above. */
2589           return;
2590         }
2591
2592       /* queue the read event to be read for real later. */
2593       enqueue_Xt_dispatch_event (event);
2594     }
2595 }
2596
2597 static void
2598 emacs_Xt_quit_p (void)
2599 {
2600   Lisp_Object devcons, concons;
2601   CONSOLE_LOOP (concons)
2602     {
2603       struct console *con = XCONSOLE (XCAR (concons));
2604       if (!con->input_enabled)
2605         continue;
2606
2607       CONSOLE_DEVICE_LOOP (devcons, con)
2608         {
2609           struct device *d;
2610           d = XDEVICE (XCAR (devcons));
2611
2612           if (DEVICE_X_P (d) && DEVICE_X_DISPLAY (d))
2613             /* emacs may be exiting */
2614             x_check_for_quit_char (DEVICE_X_DISPLAY (d));
2615           else if (DEVICE_TTY_P (d))
2616             check_for_tty_quit_char (d);
2617         }
2618     }
2619 }
2620
2621 static void
2622 drain_X_queue (void)
2623 {
2624   while (XtAppPending (Xt_app_con) & XtIMXEvent)
2625     XtAppProcessEvent (Xt_app_con, XtIMXEvent);
2626 }
2627
2628 static int
2629 emacs_Xt_event_pending_p (int user_p)
2630 {
2631   Lisp_Object event;
2632   int tick_count_val;
2633
2634   /* If `user_p' is false, then this function returns whether there are any
2635      X, timeout, or fd events pending (that is, whether emacs_Xt_next_event()
2636      would return immediately without blocking).
2637
2638      if `user_p' is true, then this function returns whether there are any
2639      *user generated* events available (that is, whether there are keyboard
2640      or mouse-click events ready to be read).  This also implies that
2641      emacs_Xt_next_event() would not block.
2642
2643      In a non-SIGIO world, this also checks whether the user has typed ^G,
2644      since this is a convenient place to do so.  We don't need to do this
2645      in a SIGIO world, since input causes an interrupt.
2646    */
2647
2648 #if 0
2649   /* I don't think there's any point to this and it will nullify
2650      the speed gains achieved by the sigio_happened checking below.
2651      Its only advantage is that it may possibly make C-g response
2652      a bit faster.  The C-g will be noticed within 0.25 second, anyway,
2653      even without this. */
2654 #ifndef SIGIO
2655   /* First check for C-g if necessary */
2656   emacs_Xt_quit_p ();
2657 #endif
2658 #endif
2659
2660   /* This function used to simply check whether there were any X
2661      events (or if user_p was 1, it iterated over all the pending
2662      X events using XCheckIfEvent(), looking for keystrokes and
2663      button events).  That worked in the old cheesoid event loop,
2664      which didn't go through XtAppDispatchEvent(), but it doesn't
2665      work any more -- X events may not result in anything.  For
2666      example, a button press in a blank part of the menubar appears
2667      as an X event but will not result in any Emacs events (a
2668      button press that activates the menubar results in an Emacs
2669      event through the stop_next_event mechanism).
2670
2671      The only accurate way of determining whether these X events
2672      translate into Emacs events is to go ahead and dispatch them
2673      until there's something on the dispatch queue. */
2674
2675   /* See if there are any user events already on the queue. */
2676   EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2677     if (!user_p || command_event_p (event))
2678       return 1;
2679
2680   /* See if there's any TTY input available.
2681    */
2682   if (poll_fds_for_input (tty_only_mask))
2683     return 1;
2684
2685   if (!user_p)
2686     {
2687       /* If not user_p and there are any timer or file-desc events
2688          pending, we know there will be an event so we're through. */
2689       XtInputMask pending_value;
2690
2691       /* Note that formerly we just checked the value of XtAppPending()
2692          to determine if there was file-desc input.  This doesn't
2693          work any more with the signal_event_pipe; XtAppPending()
2694          will says "yes" in this case but there isn't really any
2695          input.  Another way of fixing this problem is for the
2696          signal_event_pipe to generate actual input in the form
2697          of an identity eval event or something. (#### maybe this
2698          actually happens?) */
2699
2700       if (poll_fds_for_input (process_only_mask))
2701         return 1;
2702
2703       pending_value = XtAppPending (Xt_app_con);
2704
2705       if (pending_value & XtIMTimer)
2706         return 1;
2707     }
2708
2709   /* XtAppPending() can be super-slow, esp. over a network connection.
2710      Quantify results have indicated that in some cases the
2711      call to detect_input_pending() completely dominates the
2712      running time of redisplay().  Fortunately, in a SIGIO world
2713      we can more quickly determine whether there are any X events:
2714      if an event has happened since the last time we checked, then
2715      a SIGIO will have happened.  On a machine with broken SIGIO,
2716      we'll still be in an OK state -- the sigio_happened flag
2717      will get set at least once a second, so we'll be no more than
2718      one second behind reality. (In general it's OK if we
2719      erroneously report no input pending when input is actually
2720      pending() -- preemption is just a bit less efficient, that's
2721      all.  It's bad bad bad if you err the other way -- you've
2722      promised that `next-event' won't block but it actually will,
2723      and some action might get delayed until the next time you
2724      hit a key.)
2725      */
2726
2727   /* quit_check_signal_tick_count is volatile so try to avoid race conditions
2728      by using a temporary variable */
2729   tick_count_val = quit_check_signal_tick_count;
2730   if (last_quit_check_signal_tick_count != tick_count_val)
2731     {
2732       last_quit_check_signal_tick_count = tick_count_val;
2733
2734       /* We need to drain the entire queue now -- if we only
2735          drain part of it, we may later on end up with events
2736          actually pending but detect_input_pending() returning
2737          false because there wasn't another SIGIO. */
2738       drain_X_queue ();
2739
2740       EVENT_CHAIN_LOOP (event, dispatch_event_queue)
2741         if (!user_p || command_event_p (event))
2742           return 1;
2743     }
2744
2745   return 0;
2746 }
2747
2748 \f
2749 /************************************************************************/
2750 /*            replacement for standard string-to-pixel converter        */
2751 /************************************************************************/
2752
2753 /* This was constructed by ripping off the standard string-to-pixel
2754    converter from Converters.c in the Xt source code and modifying
2755    appropriately. */
2756
2757 #if 0
2758
2759 /* This is exported by the Xt library (at least by mine).  If this
2760    isn't the case somewhere, rename this appropriately and remove
2761    the '#if 0'.  Note, however, that I got "unknown structure"
2762    errors when I tried this. */
2763 XtConvertArgRec Const colorConvertArgs[] = {
2764   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
2765    sizeof(Screen *)},
2766   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
2767    sizeof(Colormap)}
2768 };
2769
2770 #endif
2771
2772 #define done(type, value)               \
2773   if (toVal->addr != NULL) {             \
2774     if (toVal->size < sizeof(type)) {    \
2775       toVal->size = sizeof(type);        \
2776       return False;                      \
2777     }                                    \
2778     *(type*)(toVal->addr) = (value);     \
2779   } else {                               \
2780     static type static_val;              \
2781     static_val = (value);                \
2782     toVal->addr = (XPointer)&static_val; \
2783   }                                      \
2784   toVal->size = sizeof(type);            \
2785   return True /* Caller supplies `;' */
2786
2787 /* JH: We use this because I think there's a possibility this
2788    is called before the device is properly set up, in which case
2789    I don't want to abort. */
2790 extern struct device *get_device_from_display_1 (Display *dpy);
2791
2792 static
2793 Boolean EmacsXtCvtStringToPixel (
2794  Display     *dpy,
2795  XrmValuePtr  args,
2796  Cardinal    *num_args,
2797  XrmValuePtr  fromVal,
2798  XrmValuePtr  toVal,
2799  XtPointer   *closure_ret)
2800 {
2801   String       str = (String)fromVal->addr;
2802   XColor       screenColor;
2803   XColor       exactColor;
2804   Screen       *screen;
2805   Colormap     colormap;
2806   Visual       *visual;
2807   struct device *d;
2808   Status       status;
2809   String       params[1];
2810   Cardinal     num_params  = 1;
2811   XtAppContext the_app_con = XtDisplayToApplicationContext (dpy);
2812
2813   if (*num_args != 2) {
2814     XtAppWarningMsg(the_app_con, "wrongParameters", "cvtStringToPixel",
2815                     "XtToolkitError",
2816                     "String to pixel conversion needs screen and colormap arguments",
2817                     (String *)NULL, (Cardinal *)NULL);
2818     return False;
2819   }
2820
2821   screen   = *((Screen **)  args[0].addr);
2822   colormap = *((Colormap *) args[1].addr);
2823
2824   /* The original uses the private function CompareISOLatin1().
2825      Use XmuCompareISOLatin1() if you want, but I don't think it
2826      makes any difference here. */
2827   if (strcmp(str, XtDefaultBackground) == 0) {
2828     *closure_ret = False;
2829     /* This refers to the display's "*reverseVideo" resource.
2830        These display resources aren't documented anywhere that
2831        I can find, so I'm going to ignore this. */
2832     /* if (pd->rv) done(Pixel, BlackPixelOfScreen(screen)) else */
2833     done(Pixel, WhitePixelOfScreen(screen));
2834   }
2835   if (strcmp(str, XtDefaultForeground) == 0) {
2836     *closure_ret = False;
2837     /* if (pd->rv) done(Pixel, WhitePixelOfScreen(screen)) else */
2838     done(Pixel, BlackPixelOfScreen(screen));
2839   }
2840
2841   /* Originally called XAllocNamedColor() here. */
2842   if ((d = get_device_from_display_1(dpy))) {
2843     visual = DEVICE_X_VISUAL(d);
2844     if (colormap != DEVICE_X_COLORMAP(d)) {
2845       XtAppWarningMsg(the_app_con, "wierdColormap", "cvtStringToPixel",
2846                       "XtToolkitWarning",
2847                       "The colormap passed to cvtStringToPixel doesn't match the one registerd to the device.\n",
2848                       NULL, 0);
2849       status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2850     } else {
2851       status = XParseColor (dpy, colormap, (char*)str, &screenColor);
2852       if (status) {
2853         status = allocate_nearest_color (dpy, colormap, visual, &screenColor);
2854       }
2855     }
2856   } else {
2857     /* We haven't set up this device totally yet, so just punt */
2858     status = XAllocNamedColor(dpy, colormap, (char*)str, &screenColor, &exactColor);
2859   }
2860   if (status == 0) {
2861     params[0] = str;
2862     /* Server returns a specific error code but Xlib discards it.  Ugh */
2863     if (XLookupColor(DisplayOfScreen(screen), colormap, (char*) str,
2864                      &exactColor, &screenColor)) {
2865       XtAppWarningMsg(the_app_con, "noColormap", "cvtStringToPixel",
2866                       "XtToolkitError",
2867                       "Cannot allocate colormap entry for \"%s\"",
2868                       params, &num_params);
2869
2870     } else {
2871       XtAppWarningMsg(the_app_con, "badValue", "cvtStringToPixel",
2872                       "XtToolkitError",
2873                       "Color name \"%s\" is not defined", params, &num_params);
2874     }
2875
2876     *closure_ret = False;
2877     return False;
2878   } else {
2879     *closure_ret = (char*)True;
2880     done(Pixel, screenColor.pixel);
2881   }
2882 }
2883
2884 /* ARGSUSED */
2885 static void EmacsFreePixel (
2886   XtAppContext app,
2887   XrmValuePtr  toVal,
2888   XtPointer    closure,
2889   XrmValuePtr  args,
2890   Cardinal    *num_args)
2891 {
2892   if (*num_args != 2) {
2893     XtAppWarningMsg(app, "wrongParameters","freePixel","XtToolkitError",
2894                     "Freeing a pixel requires screen and colormap arguments",
2895                     (String *)NULL, (Cardinal *)NULL);
2896     return;
2897   }
2898
2899   if (closure) {
2900     Screen   *screen  = *((Screen **)  args[0].addr);
2901     Colormap colormap = *((Colormap *) args[1].addr);
2902     XFreeColors(DisplayOfScreen(screen), colormap,
2903                 (unsigned long*)toVal->addr, 1, (unsigned long)0);
2904   }
2905 }
2906
2907 \f
2908 /************************************************************************/
2909 /*                            initialization                            */
2910 /************************************************************************/
2911
2912 void
2913 syms_of_event_Xt (void)
2914 {
2915   defsymbol (&Qkey_mapping, "key-mapping");
2916   defsymbol (&Qsans_modifiers, "sans-modifiers");
2917 }
2918
2919 void
2920 vars_of_event_Xt (void)
2921 {
2922   dispatch_event_queue = Qnil;
2923   staticpro (&dispatch_event_queue);
2924   dispatch_event_queue_tail = Qnil;
2925
2926   /* this function only makes safe calls */
2927   init_what_input_once ();
2928
2929   Xt_event_stream = xnew (struct event_stream);
2930   Xt_event_stream->event_pending_p       = emacs_Xt_event_pending_p;
2931   Xt_event_stream->next_event_cb         = emacs_Xt_next_event;
2932   Xt_event_stream->handle_magic_event_cb = emacs_Xt_handle_magic_event;
2933   Xt_event_stream->add_timeout_cb        = emacs_Xt_add_timeout;
2934   Xt_event_stream->remove_timeout_cb     = emacs_Xt_remove_timeout;
2935   Xt_event_stream->select_console_cb     = emacs_Xt_select_console;
2936   Xt_event_stream->unselect_console_cb   = emacs_Xt_unselect_console;
2937   Xt_event_stream->select_process_cb     = emacs_Xt_select_process;
2938   Xt_event_stream->unselect_process_cb   = emacs_Xt_unselect_process;
2939   Xt_event_stream->quit_p_cb             = emacs_Xt_quit_p;
2940   Xt_event_stream->create_stream_pair_cb = emacs_Xt_create_stream_pair;
2941   Xt_event_stream->delete_stream_pair_cb = emacs_Xt_delete_stream_pair;
2942
2943   DEFVAR_BOOL ("modifier-keys-are-sticky", &modifier_keys_are_sticky /*
2944 *Non-nil makes modifier keys sticky.
2945 This means that you can release the modifier key before pressing down
2946 the key that you wish to be modified.  Although this is non-standard
2947 behavior, it is recommended because it reduces the strain on your hand,
2948 thus reducing the incidence of the dreaded Emacs-pinky syndrome.
2949 */ );
2950   modifier_keys_are_sticky = 0;
2951
2952   DEFVAR_BOOL ("x-allow-sendevents", &x_allow_sendevents /*
2953 *Non-nil means to allow synthetic events.  Nil means they are ignored.
2954 Beware: allowing emacs to process SendEvents opens a big security hole.
2955 */ );
2956   x_allow_sendevents = 0;
2957
2958 #ifdef DEBUG_XEMACS
2959   DEFVAR_INT ("x-debug-events", &x_debug_events /*
2960 If non-zero, display debug information about X events that XEmacs sees.
2961 Information is displayed on stderr.  Currently defined values are:
2962
2963 1 == non-verbose output
2964 2 == verbose output
2965 */ );
2966   x_debug_events = 0;
2967 #endif
2968
2969   the_Xt_timeout_blocktype = Blocktype_new (struct Xt_timeout_blocktype);
2970
2971   last_quit_check_signal_tick_count = 0;
2972 }
2973
2974 /* This mess is a hack that patches the shell widget to treat visual inheritance
2975    the same as colormap and depth inheritance */
2976
2977 static XtInitProc orig_shell_init_proc;
2978
2979 static void ShellVisualPatch(Widget wanted, Widget new,
2980                              ArgList args, Cardinal *num_args)
2981 {
2982   Widget p;
2983   ShellWidget w = (ShellWidget) new;
2984
2985   /* first, call the original setup */
2986   (*orig_shell_init_proc)(wanted, new, args, num_args);
2987
2988   /* if the visual isn't explicitly set, grab it from the nearest shell ancestor */
2989   if (w->shell.visual == CopyFromParent) {
2990     p = XtParent(w);
2991     while (p && !XtIsShell(p)) p = XtParent(p);
2992     if (p) w->shell.visual = ((ShellWidget)p)->shell.visual;
2993   }
2994 }
2995
2996 void
2997 init_event_Xt_late (void) /* called when already initialized */
2998 {
2999   timeout_id_tick = 1;
3000   pending_timeouts = 0;
3001   completed_timeouts = 0;
3002
3003   event_stream = Xt_event_stream;
3004
3005 #if defined(HAVE_XIM) || defined(USE_XFONTSET)
3006   Initialize_Locale();
3007 #endif /* HAVE_XIM || USE_XFONTSET */
3008
3009   XtToolkitInitialize ();
3010   Xt_app_con = XtCreateApplicationContext ();
3011   XtAppSetFallbackResources (Xt_app_con, (String *) x_fallback_resources);
3012
3013   /* In xselect.c */
3014   x_selection_timeout = (XtAppGetSelectionTimeout (Xt_app_con) / 1000);
3015   XSetErrorHandler (x_error_handler);
3016   XSetIOErrorHandler (x_IO_error_handler);
3017
3018 #ifndef WINDOWSNT
3019   XtAppAddInput (Xt_app_con, signal_event_pipe[0],
3020                  (XtPointer) (XtInputReadMask /* | XtInputExceptMask */),
3021                  Xt_what_callback, 0);
3022 #endif
3023
3024   XtAppSetTypeConverter (Xt_app_con, XtRString, XtRPixel,
3025                          EmacsXtCvtStringToPixel,
3026                          (XtConvertArgList) colorConvertArgs,
3027                          2, XtCacheByDisplay, EmacsFreePixel);
3028
3029 #ifdef XIM_XLIB
3030   XtAppSetTypeConverter (Xt_app_con, XtRString, XtRXimStyles,
3031                          EmacsXtCvtStringToXIMStyles,
3032                          NULL, 0,
3033                          XtCacheByDisplay, EmacsFreeXIMStyles);
3034 #endif /* XIM_XLIB */
3035
3036   /* insert the visual inheritance patch/hack described above */
3037   orig_shell_init_proc = shellClassRec.core_class.initialize;
3038   shellClassRec.core_class.initialize = ShellVisualPatch;
3039
3040 }