39686774a9e3e1a8302e5553313d69153d4b103f
[chise/xemacs-chise.git-] / src / events.h
1 /* Definitions for the new event model;
2    created 16-jul-91 by Jamie Zawinski
3    Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
4    Copyright (C) 1995, 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 #ifndef _XEMACS_EVENTS_H_
26 #define _XEMACS_EVENTS_H_
27
28 #include "systime.h"
29
30 /* There is one object called an event_stream.  This object contains
31    callback functions for doing the window-system-dependent operations
32    that XEmacs requires.
33
34    If XEmacs is compiled with support for X11 and the X Toolkit, then this
35    event_stream structure will contain functions that can cope with input
36    on XEmacs windows on multiple displays, as well as input from dumb tty
37    frames.
38
39    If it is desired to have XEmacs able to open frames on the displays of
40    multiple heterogeneous machines, X11 and SunView, or X11 and NeXT, for
41    example, then it will be necessary to construct an event_stream structure
42    that can cope with the given types.  Currently, the only implemented
43    event_streams are for dumb-ttys, and for X11 plus dumb-ttys.
44
45    To implement this for one window system is relatively simple.
46    To implement this for multiple window systems is trickier and may
47    not be possible in all situations, but it's been done for X and TTY.
48
49    Note that these callbacks are *NOT* console methods; that's because
50    the routines are not specific to a particular console type but must
51    be able to simultaneously cope with all allowable console types.
52
53   The slots of the event_stream structure:
54
55  next_event_cb          A function which fills in an XEmacs_event structure
56                         with the next event available.  If there is no event
57                         available, then this should block.
58
59                         IMPORTANT: timer events and especially process
60                         events *must not* be returned if there are
61                         events of other types available; otherwise you
62                         can end up with an infinite loop in Fdiscard_input().
63
64  event_pending_cb       A function which says whether there are events to be
65                         read.  If called with an argument of 0, then this
66                         should say whether calling the next_event_cb will
67                         block.  If called with an argument of 1, then this
68                         should say whether there are user-generated events
69                         pending (that is, keypresses or mouse-clicks).  This
70                         is used for redisplay optimization, among other
71                         things.  On dumb ttys, these two results are the
72                         same, but under a window system, they are not.
73
74                         If this function is not sure whether there are events
75                         to be read, it *must* return 0.  Otherwise various
76                         undesirable effects will occur, such as redisplay
77                         not occurring until the next event occurs.
78
79  handle_magic_event_cb  XEmacs calls this with an event structure which
80                         contains window-system dependent information that
81                         XEmacs doesn't need to know about, but which must
82                         happen in order.  If the next_event_cb never returns
83                         an event of type "magic", this will never be used.
84
85  add_timeout_cb         Called with an EMACS_TIME, the absolute time at
86                         which a wakeup event should be generated; and a
87                         void *, which is an arbitrary value that will be
88                         returned in the timeout event.  The timeouts
89                         generated by this function should be one-shots:
90                         they fire once and then disappear.  This callback
91                         should return an int id-number which uniquely
92                         identifies this wakeup.  If an implementation
93                         doesn't have microseconds or millisecond
94                         granularity, it should round up to the closest
95                         value it can deal with.
96
97  remove_timeout_cb      Called with an int, the id number of a wakeup to
98                         discard.  This id number must have been returned by
99                         the add_timeout_cb.  If the given wakeup has
100                         already expired, this should do nothing.
101
102  select_process_cb      These callbacks tell the underlying implementation to
103  unselect_process_cb    add or remove a file descriptor from the list of fds
104                         which are polled for inferior-process input.  When
105                         input becomes available on the given process
106                         connection, an event of type "process" should be
107                         generated.
108
109  select_console_cb      These callbacks tell the underlying implementation
110  unselect_console_cb    to add or remove a console from the list of consoles
111                         which are polled for user-input.
112
113  select_device_cb       These callbacks are used by Unixoid event loops
114  unselect_device_cb     (those that use select() and file descriptors and
115                         have a separate input fd per device).
116
117  create_stream_pair_cb  These callbacks are called by process code to
118  delete_stream_pair_cb  create and delete a pair of input and output lstreams
119                         which are used for subprocess I/O.
120
121  quitp_cb               A handler function called from the `QUIT' macro which
122                         should check whether the quit character has been
123                         typed.  On systems with SIGIO, this will not be called
124                         unless the `sigio_happened' flag is true (it is set
125                         from the SIGIO handler).
126
127  XEmacs has its own event structures, which are distinct from the event
128  structures used by X or any other window system.  It is the job of the
129  event_stream layer to translate to this format.
130
131  NOTE: #### All timestamps should be measured as milliseconds since XEmacs
132        started.  Currently many or most events have a 0 as their
133        timestamp value, and for other timestamps, they are raw server
134        timestamps. (The X protocol doesn't provide any easy way of
135        translating between server time and real process time; yuck.)
136
137  Every event type has the following structures:
138
139  channel                Where this event occurred on.  This will be
140                         a frame, device, console, or nil, depending on the
141                         event type.  It is important that an object of
142                         a more specific type than is actually generated
143                         is not substituted -- e.g. there should not be
144                         a frame inserted when a key-press event occurs,
145                         because events on dead channels are automatically
146                         ignored.
147
148                         Specifically:
149
150                         -- for button and mouse-motion events, channel
151                            will be a frame. (The translation to a window
152                            occurs later.)
153                         -- for keyboard events, channel will be a console.
154                            Note that fake keyboard events (generated
155                            by `character-to-event' or something that
156                            calls this, such as macros) need to have
157                            the selected console stored into them when
158                            the event is created.  This is so that the
159                            correct console-local variables (e.g. the
160                            command builder) will get affected.
161                         -- for timer, process, magic-eval, and eval events,
162                            channel will be nil.
163                         -- for misc-user events, channel will be a frame.
164                         -- for magic events, channel will be a frame
165                            (usually) or a device.
166
167  timestamp              When this event occurred -- if not known, this
168                         is made up.
169
170  In addition, the following structures are specific to particular event
171  types:
172
173  key_press_event
174     key                 What keysym this is; an integer or a symbol.
175                         If this is an integer, it will be in the printing
176                         ASCII range: >32 and <127.
177     modifiers           Bucky-bits on that key: control, meta, etc.
178                         For many keys, Shift is not a bit; that is implicit
179                         in the keyboard layout.
180
181  button_press_event
182  button_release_event
183     button              What button went down or up.
184     modifiers           Bucky-bits on that button: shift, control, meta, etc.
185     x, y                Where it was at the button-state-change (in pixels).
186
187  pointer_motion_event
188     x, y                Where it was after it moved (in pixels).
189     modifiers           Bucky-bits down when the motion was detected.
190                         (Possibly not all window systems will provide this?)
191
192  process_event
193     process             the XEmacs "process" object in question
194
195  timeout_event
196     interval_id         The ID returned when the associated call to
197                         add_timeout_cb() was made
198         ------ the rest of the fields are filled in by XEmacs -----
199     id_number           The XEmacs timeout ID for this timeout (more
200                         than one timeout event can have the same value
201                         here, since XEmacs timeouts, as opposed to
202                         add_timeout_cb() timeouts, can resignal
203                         themselves)
204     function            An elisp function to call when this timeout is
205                         processed.
206     object              The object passed to that function.
207
208  eval_event
209     function            An elisp function to call with this event object.
210     internal_function   An unexported function to call with this event
211                         object.  This allows eval events to call internal
212                         functions.  For a normal eval event, this field
213                         will always be 0.
214     object              Anything.
215                         This kind of event is used internally; sometimes the
216                         window system interface would like to inform XEmacs of
217                         some user action (such as focusing on another frame)
218                         but needs that to happen synchronously with the other
219                         user input, like keypresses.  This is useful when
220                         events are reported through callbacks rather
221                         than in the standard event stream.
222
223  misc_user_event
224     function            An elisp function to call with this event object.
225     internal_function   Ignored.
226     object              Anything.
227     button              What button went down or up.
228     modifiers           Bucky-bits on that button: shift, control, meta, etc.
229     x, y                Where it was at the button-state-change (in pixels).
230                         This is similar to an eval_event, except that it is
231                         generated by user actions: selections in the
232                         menubar, scrollbar actions, or drag and drop actions.
233                         It is a "command" event, like key and mouse presses
234                         (and unlike mouse motion, process output, and enter
235                         and leave window hooks).  In many ways, eval_events
236                         are not the same as keypresses or misc_user_events.
237                         The button, modifiers, x, and y parts are only used
238                         by the XEmacs Drag'n'Drop system. Don't depend on their
239                         values for other types of misc_user_events.
240
241  magic_event
242                         No user-serviceable parts within.  This is for things
243                         like KeymapNotify and ExposeRegion events and so on
244                         that XEmacs itself doesn't care about, but which it
245                         must do something with for proper interaction with
246                         the window system.
247
248                         Magic_events are handled somewhat asynchronously, just
249                         like subprocess filters.  However, occasionally a
250                         magic_event needs to be handled synchronously; in that
251                         case, the asynchronous handling of the magic_event will
252                         push an eval_event back onto the queue, which will be
253                         handled synchronously later.  This is one of the
254                         reasons why eval_events exist; I'm not entirely happy
255                         with this aspect of this event model.
256
257  magic_eval_event
258                         This is like an eval event but its contents are
259                         not Lisp-accessible.  This allows for "internal
260                         eval events" that call non-Lisp-accessible functions.
261                         Externally, a magic_eval_event just appears as
262                         a magic_event; the Lisp programmer need not know
263                         anything more.
264
265 */
266
267 /*
268   Stream pairs description
269   ------------------------
270
271   Since there are many possible processes/event loop combinations, the event code
272   is responsible for creating an appropriate lstream type. The process
273   implementation does not care about that implementation.
274
275   The Create stream pair function is passed two void* values, which identify
276   process-dependent 'handles'. The process implementation uses these handles
277   to communicate with child processes. The function must be prepared to receive
278   handle types of any process implementation. Since there only one process
279   implementation exists in a particular XEmacs configuration, preprocessing
280   is a mean of compiling in the support for the code which deals with particular
281   handle types.
282
283   For example, a unixoid type loop, which relies on file descriptors, may be
284   asked to create a pair of streams by a unix-style process implementation.
285   In this case, the handles passed are unix file descriptors, and the code
286   may deal with these directly. Although, the same code may be used on Win32
287   system with X-Windows. In this case, Win32 process implementation passes
288   handles of type HANDLE, and the create_stream_pair function must call
289   appropriate function to get file descriptors given HANDLEs, so that these
290   descriptors may be passed to XtAddInput.
291
292   The handle given may have special denying value, in which case the
293   corresponding lstream should not be created.
294
295   The return value of the function is a unique stream identifier. It is used
296   by processes implementation, in its  platform-independent part. There is
297   the get_process_from_usid function, which returns process object given its
298   USID. The event stream is responsible for converting its internal handle
299   type into USID.
300
301   Example is the TTY event stream. When a file descriptor signals input, the
302   event loop must determine process to which the input is destined. Thus,
303   the implementation uses process input stream file descriptor as USID, by
304   simply casting the fd value to USID type.
305
306   There are two special USID values. One, USID_ERROR, indicates that the stream
307   pair cannot be created. The second, USID_DONTHASH, indicates that streams are
308   created, but the event stream does not wish to be able to find the process
309   by its USID. Specifically, if an event stream implementation never calls
310   get_process_from_usid, this value should always be returned, to prevent
311   accumulating useless information on USID to process relationship.
312 */
313
314 /* typedef unsigned int USID; in lisp.h */
315 #define USID_ERROR ((USID)-1)
316 #define USID_DONTHASH ((USID)0)
317
318 \f
319 struct Lisp_Event;
320 struct Lisp_Process;
321
322 struct event_stream
323 {
324   int  (*event_pending_p)       (int);
325   void (*next_event_cb)         (struct Lisp_Event *);
326   void (*handle_magic_event_cb) (struct Lisp_Event *);
327   int  (*add_timeout_cb)        (EMACS_TIME);
328   void (*remove_timeout_cb)     (int);
329   void (*select_console_cb)     (struct console *);
330   void (*unselect_console_cb)   (struct console *);
331   void (*select_process_cb)     (struct Lisp_Process *);
332   void (*unselect_process_cb)   (struct Lisp_Process *);
333   void (*quit_p_cb)             (void);
334   USID (*create_stream_pair_cb) (void* /* inhandle*/, void* /*outhandle*/ ,
335                                  Lisp_Object* /* instream */,
336                                  Lisp_Object* /* outstream */,
337                                  int /* flags */);
338   USID (*delete_stream_pair_cb) (Lisp_Object /* instream */,
339                                  Lisp_Object /* outstream */);
340 };
341
342 /* Flags for create_stream_pair_cb() FLAGS parameter */
343 #define STREAM_PTY_FLUSHING             0x0001
344 #define STREAM_NETWORK_CONNECTION       0x0002
345
346 extern struct event_stream *event_stream;
347
348 typedef enum emacs_event_type
349 {
350   empty_event,
351   key_press_event,
352   button_press_event,
353   button_release_event,
354   pointer_motion_event,
355   process_event,
356   timeout_event,
357   magic_event,
358   magic_eval_event,
359   eval_event,
360   misc_user_event,
361   dead_event
362 } emacs_event_type;
363
364 #define first_event_type empty_event
365 #define last_event_type dead_event
366
367
368 struct key_data
369 {
370   Lisp_Object       keysym;
371   unsigned char     modifiers;
372 };
373
374 struct button_data
375 {
376   int               button;
377   unsigned char     modifiers;
378   int               x, y;
379 };
380
381 struct motion_data
382 {
383   int               x, y;
384   unsigned char     modifiers;
385 };
386
387 struct process_data
388 {
389   Lisp_Object       process;
390 };
391
392 struct timeout_data
393 {
394   int               interval_id;
395   int               id_number;
396   Lisp_Object       function, object;
397 };
398
399 struct eval_data
400 {
401   Lisp_Object       function;
402   Lisp_Object       object;
403 };
404
405 struct misc_user_data
406 {
407   Lisp_Object       function;
408   Lisp_Object       object;
409   int               button;
410   unsigned char     modifiers;
411   int               x, y;
412 };
413
414 struct magic_eval_data
415 {
416   void              (*internal_function) (Lisp_Object);
417   Lisp_Object       object;
418 };
419
420 #if defined (HAVE_X_WINDOWS) && defined(emacs)
421 # include <X11/Xlib.h>
422 #endif
423
424 union magic_data
425 {
426 #ifdef HAVE_TTY
427   char              underlying_tty_event;
428 #endif
429 #ifdef HAVE_X_WINDOWS
430   XEvent            underlying_x_event;
431 #endif
432 #ifdef HAVE_MS_WINDOWS
433   int               underlying_mswindows_event;
434 #endif
435 };
436
437 struct Lisp_Event
438 {
439   /* header->next (aka XEVENT_NEXT ()) is used as follows:
440      - For dead events, this is the next dead one.
441      - For events on the command_event_queue, the next one on the queue.
442      - Likewise for events chained in the command builder.
443      - Otherwise it's Qnil.
444    */
445   struct lrecord_header lheader;
446   Lisp_Object           next;
447   emacs_event_type      event_type;
448   Lisp_Object           channel;
449   unsigned int          timestamp;
450   union
451     {
452       struct key_data           key;
453       struct button_data        button;
454       struct motion_data        motion;
455       struct process_data       process;
456       struct timeout_data       timeout;
457       struct eval_data          eval;   /* misc_user_event no longer uses this */
458       struct misc_user_data     misc;   /* because it needs position information */
459       union magic_data          magic;
460       struct magic_eval_data    magic_eval;
461     } event;
462 };
463
464 DECLARE_LRECORD (event, struct Lisp_Event);
465 #define XEVENT(x) XRECORD (x, event, struct Lisp_Event)
466 #define XSETEVENT(x, p) XSETRECORD (x, p, event)
467 #define EVENTP(x) RECORDP (x, event)
468 #define GC_EVENTP(x) GC_RECORDP (x, event)
469 #define CHECK_EVENT(x) CHECK_RECORD (x, event)
470 #define CONCHECK_EVENT(x) CONCHECK_RECORD (x, event)
471
472 DECLARE_LRECORD (command_builder, struct command_builder);
473
474 #define EVENT_CHANNEL(a) ((a)->channel)
475 #define EVENT_TYPE(a) ((a)->event_type)
476 #define XEVENT_TYPE(a) (XEVENT (a)->event_type)
477 #define EVENT_NEXT(a) ((a)->next)
478 #define XEVENT_NEXT(e) (XEVENT (e)->next)
479 #define XSET_EVENT_NEXT(e, n) do { (XEVENT (e)->next = (n)); } while (0)
480
481 #define EVENT_CHAIN_LOOP(event, chain) \
482   for (event = chain; !NILP (event); event = XEVENT_NEXT (event))
483
484 #define EVENT_LIVE_P(a) (EVENT_TYPE (a) != dead_event)
485
486 #define CHECK_LIVE_EVENT(x) do {                        \
487   CHECK_EVENT (x);                                      \
488   if (! EVENT_LIVE_P (XEVENT (x)))                      \
489     dead_wrong_type_argument (Qevent_live_p, (x));      \
490 } while (0)
491 #define CONCHECK_LIVE_EVENT(x) do {                     \
492   CONCHECK_EVENT (x);                                   \
493   if (! EVENT_LIVE_P (XEVENT (x)))                      \
494     x = wrong_type_argument (Qevent_live_p, (x));       \
495 } while (0)
496
497
498 EXFUN (Fcharacter_to_event, 4);
499 EXFUN (Fdeallocate_event, 1);
500 EXFUN (Fevent_glyph_extent, 1);
501 EXFUN (Fevent_modeline_position, 1);
502 EXFUN (Fevent_over_modeline_p, 1);
503 EXFUN (Fevent_over_toolbar_p, 1);
504 EXFUN (Fevent_over_vertical_divider_p, 1);
505 EXFUN (Fevent_point, 1);
506 EXFUN (Fevent_window, 1);
507 EXFUN (Fmake_event, 2);
508
509 extern Lisp_Object QKbackspace, QKdelete, QKescape, QKlinefeed, QKreturn;
510 extern Lisp_Object QKspace, QKtab, Qmouse_event_p, Vcharacter_set_property;
511 extern Lisp_Object Qcancel_mode_internal;
512
513 /* Note: under X Windows, MOD_ALT is generated by the Alt key if there are
514    both Alt and Meta keys.  If there are no Meta keys, then Alt generates
515    MOD_META instead.
516  */
517
518 #ifdef emacs
519 /* Maybe this should be trickier */
520 #define KEYSYM(x) (intern (x))
521
522 /* from events.c */
523 void format_event_object (char *buf, struct Lisp_Event *e, int brief);
524 void character_to_event (Emchar c, struct Lisp_Event *event,
525                          struct console *con,
526                          int use_console_meta_flag,
527                          int do_backspace_mapping);
528 void zero_event (struct Lisp_Event *e);
529 void deallocate_event_chain (Lisp_Object event);
530 Lisp_Object event_chain_tail (Lisp_Object event);
531 void enqueue_event (Lisp_Object event, Lisp_Object *head, Lisp_Object *tail);
532 Lisp_Object dequeue_event (Lisp_Object *head, Lisp_Object *tail);
533 void enqueue_event_chain (Lisp_Object event_chain, Lisp_Object *head,
534                           Lisp_Object *tail);
535 int event_chain_count (Lisp_Object event_chain);
536 void nth_of_key_sequence_as_event (Lisp_Object seq, int n, Lisp_Object event);
537 Lisp_Object key_sequence_to_event_chain (Lisp_Object seq);
538 Lisp_Object event_chain_find_previous (Lisp_Object event_chain,
539                                        Lisp_Object event);
540 Lisp_Object event_chain_nth (Lisp_Object event_chain, int n);
541 Lisp_Object copy_event_chain (Lisp_Object event_chain);
542 /* True if this is a non-internal event
543    (keyboard press, menu, scrollbar, mouse button) */
544 int command_event_p (Lisp_Object event);
545 struct console *event_console_or_selected (Lisp_Object event);
546
547 /* from event-stream.c */
548 Lisp_Object allocate_command_builder (Lisp_Object console);
549 void enqueue_magic_eval_event (void (*fun) (Lisp_Object), Lisp_Object object);
550 void event_stream_next_event (struct Lisp_Event *event);
551 void event_stream_handle_magic_event (struct Lisp_Event *event);
552 void event_stream_select_console   (struct console *con);
553 void event_stream_unselect_console (struct console *con);
554 void event_stream_select_process   (struct Lisp_Process *proc);
555 void event_stream_unselect_process (struct Lisp_Process *proc);
556 USID event_stream_create_stream_pair (void* inhandle, void* outhandle,
557                 Lisp_Object* instream, Lisp_Object* outstream, int flags);
558 USID event_stream_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream);
559 void event_stream_quit_p (void);
560
561 struct low_level_timeout
562 {
563   int id;
564   EMACS_TIME time;
565   struct low_level_timeout *next;
566 };
567
568 int add_low_level_timeout (struct low_level_timeout **timeout_list,
569                            EMACS_TIME thyme);
570 void remove_low_level_timeout (struct low_level_timeout **timeout_list,
571                                int id);
572 int get_low_level_timeout_interval (struct low_level_timeout *
573                                     timeout_list, EMACS_TIME *interval);
574 int pop_low_level_timeout (struct low_level_timeout **timeout_list,
575                            EMACS_TIME *time_out);
576 int event_stream_generate_wakeup (unsigned int milliseconds,
577                                   unsigned int vanilliseconds,
578                                   Lisp_Object function,
579                                   Lisp_Object object,
580                                   int async_p);
581 void event_stream_disable_wakeup (int id, int async_p);
582 void event_stream_deal_with_async_timeout (int interval_id);
583
584 int event_stream_add_async_timeout (EMACS_TIME thyme);
585 void event_stream_remove_async_timeout (int id);
586
587 /* from event-stream.c -- focus sanity */
588 extern int focus_follows_mouse;
589 void investigate_frame_change (void);
590
591 void emacs_handle_focus_change_preliminary (Lisp_Object frame_inp_and_dev);
592 void emacs_handle_focus_change_final (Lisp_Object frame_inp_and_dev);
593
594 Lisp_Object extract_this_command_keys_nth_mouse_event (int n);
595 Lisp_Object extract_vector_nth_mouse_event (Lisp_Object vector, int n);
596
597 void single_console_state (void);
598 void any_console_state (void);
599 int in_single_console_state (void);
600
601 extern int emacs_is_blocking;
602
603 extern volatile int sigint_happened;
604
605 #ifdef HAVE_UNIXOID_EVENT_LOOP
606 /* from event-unixoid.c */
607
608 /* Ceci n'est pas un pipe. */
609 extern int signal_event_pipe[];
610
611 void signal_fake_event (void);
612 void drain_signal_event_pipe (void);
613
614 extern int fake_event_occurred;
615
616 int event_stream_unixoid_select_console   (struct console *con);
617 int event_stream_unixoid_unselect_console (struct console *con);
618 int event_stream_unixoid_select_process   (struct Lisp_Process *proc);
619 int event_stream_unixoid_unselect_process (struct Lisp_Process *proc);
620 int read_event_from_tty_or_stream_desc (struct Lisp_Event *event,
621                                         struct console *con, int fd);
622 USID event_stream_unixoid_create_stream_pair (void* inhandle, void* outhandle,
623                                              Lisp_Object* instream,
624                                              Lisp_Object* outstream,
625                                              int flags);
626 USID event_stream_unixoid_delete_stream_pair (Lisp_Object instream,
627                                               Lisp_Object outstream);
628
629 /* Beware: this evil macro evaluates its arg many times */
630 #define FD_TO_USID(fd) ((fd)==0 ? (USID)999999 : ((fd)<0 ? USID_DONTHASH : (USID)(fd)))
631
632 #endif /* HAVE_UNIXOID_EVENT_LOOP */
633
634 /* Define this if you want the tty event stream to be used when the
635    first console is tty, even if HAVE_X_WINDOWS is defined */
636 /* #define DEBUG_TTY_EVENT_STREAM */
637
638 #endif /* emacs */
639
640 #endif /* _XEMACS_EVENTS_H_ */