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