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