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