Mercurial > hg > xemacs-beta

comparison src/events.h @ 428:3ecd8885ac67 r21-2-22

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-22
author cvs
date Mon, 13 Aug 2007 11:28:15 +0200
parents
children 3a7e78e1142d
comparison
equal deleted inserted replaced
427:0a0253eac470 428:3ecd8885ac67
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
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;
397 Lisp_Object object;
398 };
399
400 struct eval_data
401 {
402 Lisp_Object function;
403 Lisp_Object object;
404 };
405
406 struct misc_user_data
407 {
408 Lisp_Object function;
409 Lisp_Object object;
410 int button;
411 unsigned char modifiers;
412 int x, y;
413 };
414
415 struct magic_eval_data
416 {
417 void (*internal_function) (Lisp_Object);
418 Lisp_Object object;
419 };
420
421 #if defined (HAVE_X_WINDOWS) && defined(emacs)
422 # include <X11/Xlib.h>
423 #endif
424
425 union magic_data
426 {
427 #ifdef HAVE_TTY
428 char underlying_tty_event;
429 #endif
430 #ifdef HAVE_X_WINDOWS
431 XEvent underlying_x_event;
432 #endif
433 #ifdef HAVE_MS_WINDOWS
434 int underlying_mswindows_event;
435 #endif
436 };
437
438 struct Lisp_Timeout
439 {
440 struct lcrecord_header header;
441 int id; /* Id we use to identify the timeout over its lifetime */
442 int interval_id; /* Id for this particular interval; this may
443 be different each time the timeout is
444 signalled.*/
445 Lisp_Object function, object; /* Function and object associated
446 with timeout. */
447 EMACS_TIME next_signal_time; /* Absolute time when the timeout
448 is next going to be signalled. */
449 unsigned int resignal_msecs; /* How far after the next timeout
450 should the one after that
451 occur? */
452 };
453
454 DECLARE_LRECORD (timeout, struct Lisp_Timeout);
455 #define XTIMEOUT(x) XRECORD (x, timeout, struct 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, struct Lisp_Event);
489 #define XEVENT(x) XRECORD (x, event, struct 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, 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 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, struct Lisp_Event *e, int brief);
547 void character_to_event (Emchar c, struct Lisp_Event *event,
548 struct console *con,
549 int use_console_meta_flag,
550 int do_backspace_mapping);
551 void zero_event (struct 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 struct console *event_console_or_selected (Lisp_Object event);
569
570 /* from event-stream.c */
571 Lisp_Object allocate_command_builder (Lisp_Object console);
572 void enqueue_magic_eval_event (void (*fun) (Lisp_Object), Lisp_Object object);
573 void event_stream_next_event (struct Lisp_Event *event);
574 void event_stream_handle_magic_event (struct Lisp_Event *event);
575 void event_stream_select_console (struct console *con);
576 void event_stream_unselect_console (struct console *con);
577 void event_stream_select_process (struct Lisp_Process *proc);
578 void event_stream_unselect_process (struct Lisp_Process *proc);
579 USID event_stream_create_stream_pair (void* inhandle, void* outhandle,
580 Lisp_Object* instream, Lisp_Object* outstream, int flags);
581 USID event_stream_delete_stream_pair (Lisp_Object instream, Lisp_Object outstream);
582 void event_stream_quit_p (void);
583
584 struct low_level_timeout
585 {
586 int id;
587 EMACS_TIME time;
588 struct low_level_timeout *next;
589 };
590
591 int add_low_level_timeout (struct low_level_timeout **timeout_list,
592 EMACS_TIME thyme);
593 void remove_low_level_timeout (struct low_level_timeout **timeout_list,
594 int id);
595 int get_low_level_timeout_interval (struct low_level_timeout *
596 timeout_list, EMACS_TIME *interval);
597 int pop_low_level_timeout (struct low_level_timeout **timeout_list,
598 EMACS_TIME *time_out);
599 int event_stream_generate_wakeup (unsigned int milliseconds,
600 unsigned int vanilliseconds,
601 Lisp_Object function,
602 Lisp_Object object,
603 int async_p);
604 void event_stream_disable_wakeup (int id, int async_p);
605 void event_stream_deal_with_async_timeout (int interval_id);
606
607 int event_stream_add_async_timeout (EMACS_TIME thyme);
608 void event_stream_remove_async_timeout (int id);
609
610 /* from event-stream.c -- focus sanity */
611 extern int focus_follows_mouse;
612 void investigate_frame_change (void);
613
614 void emacs_handle_focus_change_preliminary (Lisp_Object frame_inp_and_dev);
615 void emacs_handle_focus_change_final (Lisp_Object frame_inp_and_dev);
616
617 Lisp_Object extract_this_command_keys_nth_mouse_event (int n);
618 Lisp_Object extract_vector_nth_mouse_event (Lisp_Object vector, int n);
619
620 void single_console_state (void);
621 void any_console_state (void);
622 int in_single_console_state (void);
623
624 extern int emacs_is_blocking;
625
626 extern volatile int sigint_happened;
627
628 #ifdef HAVE_UNIXOID_EVENT_LOOP
629 /* from event-unixoid.c */
630
631 /* Ceci n'est pas un pipe. */
632 extern int signal_event_pipe[];
633
634 void signal_fake_event (void);
635 void drain_signal_event_pipe (void);
636
637 extern int fake_event_occurred;
638
639 int event_stream_unixoid_select_console (struct console *con);
640 int event_stream_unixoid_unselect_console (struct console *con);
641 int event_stream_unixoid_select_process (struct Lisp_Process *proc);
642 int event_stream_unixoid_unselect_process (struct Lisp_Process *proc);
643 int read_event_from_tty_or_stream_desc (struct Lisp_Event *event,
644 struct console *con, int fd);
645 USID event_stream_unixoid_create_stream_pair (void* inhandle, void* outhandle,
646 Lisp_Object* instream,
647 Lisp_Object* outstream,
648 int flags);
649 USID event_stream_unixoid_delete_stream_pair (Lisp_Object instream,
650 Lisp_Object outstream);
651
652 /* Beware: this evil macro evaluates its arg many times */
653 #define FD_TO_USID(fd) ((fd)==0 ? (USID)999999 : ((fd)<0 ? USID_DONTHASH : (USID)(fd)))
654
655 #endif /* HAVE_UNIXOID_EVENT_LOOP */
656
657 /* Define this if you want the tty event stream to be used when the
658 first console is tty, even if HAVE_X_WINDOWS is defined */
659 /* #define DEBUG_TTY_EVENT_STREAM */
660
661 #endif /* emacs */
662
663 #endif /* _XEMACS_EVENTS_H_ */