Mercurial > hg > xemacs-beta
annotate src/events.h @ 4930:9f04877ce07e
fix up comments about finalizers and NEWGC internal objects
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-01-20 Ben Wing <ben@xemacs.org>
* lrecord.h:
* lrecord.h (enum lrecord_type):
* lrecord.h (struct lrecord_implementation):
Clean up description of finalizer methods. Clean up and expand
the long comment at the top of lrecord.h. Add a section about why
New-GC requires a bunch of new internal objects to be created (not
completely understood).
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Wed, 20 Jan 2010 04:20:49 -0600 |
| parents | 2fd201d73a92 |
| children | 6ef8256a020a e0db3c197671 |
| rev | line source |
|---|---|
| 428 | 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. | |
| 788 | 4 Copyright (C) 1995, 1996, 2002 Ben Wing. |
| 428 | 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 | |
| 440 | 25 #ifndef INCLUDED_events_h_ |
| 26 #define INCLUDED_events_h_ | |
| 428 | 27 |
| 28 #include "systime.h" | |
| 29 | |
| 2367 | 30 /* |
| 428 | 31 |
| 2367 | 32 See also |
| 428 | 33 |
| 2367 | 34 (Info-goto-node "(internals)Event Stream Callback Routines") |
| 35 (Info-goto-node "(internals)Stream Pairs") | |
| 428 | 36 |
| 37 */ | |
| 38 | |
| 39 /* typedef unsigned int USID; in lisp.h */ | |
| 40 #define USID_ERROR ((USID)-1) | |
| 41 #define USID_DONTHASH ((USID)0) | |
| 42 | |
| 43 | |
| 44 struct event_stream | |
| 45 { | |
| 46 int (*event_pending_p) (int); | |
| 440 | 47 void (*next_event_cb) (Lisp_Event *); |
| 48 void (*handle_magic_event_cb) (Lisp_Event *); | |
| 788 | 49 void (*format_magic_event_cb) (Lisp_Event *, Lisp_Object pstream); |
| 50 int (*compare_magic_event_cb) (Lisp_Event *, Lisp_Event *); | |
| 51 Hashcode (*hash_magic_event_cb)(Lisp_Event *); | |
| 428 | 52 int (*add_timeout_cb) (EMACS_TIME); |
| 53 void (*remove_timeout_cb) (int); | |
| 54 void (*select_console_cb) (struct console *); | |
| 55 void (*unselect_console_cb) (struct console *); | |
| 853 | 56 void (*select_process_cb) (Lisp_Process *, int doin, int doerr); |
| 57 void (*unselect_process_cb) (Lisp_Process *, int doin, int doerr); | |
| 1204 | 58 void (*drain_queue_cb) (void); |
| 59 void (*force_event_pending_cb)(struct frame* f); | |
| 853 | 60 void (*create_io_streams_cb) (void* /* inhandle*/, void* /*outhandle*/ , |
| 61 void * /* errhandle*/, | |
| 428 | 62 Lisp_Object* /* instream */, |
| 63 Lisp_Object* /* outstream */, | |
| 853 | 64 Lisp_Object* /* errstream */, |
| 65 USID * /* in_usid */, USID * /* err_usid */, | |
| 428 | 66 int /* flags */); |
| 853 | 67 void (*delete_io_streams_cb) (Lisp_Object /* instream */, |
| 68 Lisp_Object /* outstream */, | |
| 69 Lisp_Object /* errstream */, | |
| 70 USID * /* in_usid */, USID * /* err_usid */); | |
| 442 | 71 int (*current_event_timestamp_cb) (struct console *); |
| 428 | 72 }; |
| 73 | |
| 853 | 74 /* Flags for create_io_streams_cb() FLAGS parameter */ |
| 428 | 75 #define STREAM_PTY_FLUSHING 0x0001 |
| 76 #define STREAM_NETWORK_CONNECTION 0x0002 | |
| 77 | |
| 78 extern struct event_stream *event_stream; | |
| 79 | |
| 1204 | 80 #ifdef EVENT_DATA_AS_OBJECTS |
| 81 #define EVENT_FOO_BAR_1(extractor, field) ((extractor)->field) | |
| 82 #define EVENT_FOO_BAR(e, uptype, downtype, field) EVENT_FOO_BAR_1 (X##uptype##_DATA (EVENT_DATA (e)), field) | |
| 83 #define SET_EVENT_FOO_BAR_1(extractor, field, val) \ | |
| 84 do { (extractor)->field = (val); } while (0) | |
| 85 #define SET_EVENT_FOO_BAR(e, uptype, downtype, field, val) SET_EVENT_FOO_BAR_1 (X##uptype##_DATA (EVENT_DATA (e)), field, val) | |
| 86 #else | |
| 87 #define EVENT_FOO_BAR(e, uptype, downtype, field) ((e)->event.downtype.field) | |
| 88 #define SET_EVENT_FOO_BAR(e, uptype, downtype, field, val) \ | |
| 89 do { (e)->event.downtype.field = (val); } while (0) | |
| 90 #endif | |
| 934 | 91 |
| 428 | 92 typedef enum emacs_event_type |
| 93 { | |
| 94 empty_event, | |
| 95 key_press_event, | |
| 96 button_press_event, | |
| 97 button_release_event, | |
| 98 pointer_motion_event, | |
| 99 process_event, | |
| 100 timeout_event, | |
| 101 magic_event, | |
| 102 magic_eval_event, | |
| 103 eval_event, | |
| 104 misc_user_event, | |
| 105 dead_event | |
| 106 } emacs_event_type; | |
| 107 | |
| 108 #define first_event_type empty_event | |
| 109 #define last_event_type dead_event | |
| 110 | |
| 771 | 111 enum alternative_key_chars |
| 112 { | |
| 113 KEYCHAR_CURRENT_LANGENV, | |
| 114 KEYCHAR_DEFAULT_USER, | |
| 115 KEYCHAR_DEFAULT_SYSTEM, | |
| 116 KEYCHAR_UNDERLYING_VIRTUAL_KEY_CURRENT_LANGENV, | |
| 117 KEYCHAR_UNDERLYING_VIRTUAL_KEY_DEFAULT_USER, | |
| 118 KEYCHAR_UNDERLYING_VIRTUAL_KEY_DEFAULT_SYSTEM, | |
| 119 KEYCHAR_QWERTY, | |
| 120 KEYCHAR_LAST | |
| 121 }; | |
| 122 | |
| 934 | 123 struct Lisp_Key_Data |
| 428 | 124 { |
| 1204 | 125 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 126 struct lrecord_header lheader; |
| 1204 | 127 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 128 /* What keysym this is; a character or a symbol. */ |
| 129 Lisp_Object keysym; | |
| 130 /* Modifiers held down when key was pressed: control, meta, etc. | |
| 131 Also includes buttons. For many keys, Shift is not a bit; that | |
| 132 is implicit in the keyboard layout. */ | |
| 133 int modifiers; | |
| 134 /* Alternate character interpretations for this key in different | |
| 135 keyboard layouts. This deals with the problem of pressing C-x in | |
| 136 the Russian layout (the so-called "Russian C-x problem"), for | |
| 137 example: `x' gets mapped to a Cyrillic character, so what do we | |
| 138 do? For that matter, what about `C-x b'? What we do is look the | |
| 139 key up in the default locales (current language environment, user | |
| 140 default, system default), then check to see if the underlying | |
| 141 virtual key is alphabetic in the same three defaults, then | |
| 142 finally check US ASCII. We ignore the underlying virtual key for | |
| 143 the current layout to avoid the problem of a French speaker | |
| 144 (AZERTY layout) who temporarily switches to Russian: The virtual | |
| 145 keys underlying Russian are US-ASCII, so what the French speaker | |
| 146 things of as C-a (the key just to the right of TAB) appears as | |
| 2828 | 147 C-q. |
| 148 | |
| 149 I've just implemented this in event-stream.c, and I really want to | |
| 150 see feedback from actual Russians about it, and whether it needs to | |
| 151 be much more complete than what I've done. E.g, the mapping back to | |
| 152 US Qwerty is hardcoded on the X11 side of things, and only deals | |
| 153 with the alphabetic characters. | |
| 154 | |
| 155 Also, I think it's downright confusing for people with Roman | |
| 156 letters on their keyboard to have random other letters than are | |
| 157 described as calling some command, call that command. So I want to | |
| 158 consider enabling it by language environment. | |
| 159 | |
| 160 [[ (#### We should probably ignore the current char and look | |
| 771 | 161 *ONLY* in alt_keychars for all control keys. What about the |
| 162 English speaker who temporarily switches to the French layout and | |
| 2828 | 163 finds C-q mapped to C-a?) ]] |
| 164 | |
| 165 No, we shouldn't. People who use the French layout expect that | |
| 166 pressing control with the key to the right of tab passes C-a to | |
| 167 emacs; English speakers (more exactly, Qwerty users) who | |
| 168 temporarily switch to the French layout encounter that issue in | |
| 169 every other app too, and they normally remap the keyboard in | |
| 170 software as soon as they can, or learn to live with Azerty. That | |
| 171 applies for all the Roman-alphabet keyboard layouts. Aidan Kehoe, | |
| 172 2005-05-15 | |
| 173 | |
| 174 I've taken out the dependency on MULE for this feature because it's | |
| 175 also useful in a non-Mule XEmacs where the user has set their font | |
| 176 to something ending in iso8859-5. How many of those users there | |
| 177 are, is another question. */ | |
| 867 | 178 Ichar alt_keychars[KEYCHAR_LAST]; |
| 428 | 179 }; |
| 180 | |
| 934 | 181 typedef struct Lisp_Key_Data Lisp_Key_Data; |
| 182 | |
| 1204 | 183 #define KEY_DATA_KEYSYM(d) ((d)->keysym) |
| 184 #define KEY_DATA_MODIFIERS(d) ((d)->modifiers) | |
| 185 #define SET_KEY_DATA_KEYSYM(d, k) ((d)->keysym = k) | |
| 186 #define SET_KEY_DATA_MODIFIERS(d, m) ((d)->modifiers = m) | |
| 187 | |
| 188 #ifdef EVENT_DATA_AS_OBJECTS | |
| 934 | 189 DECLARE_LRECORD (key_data, Lisp_Key_Data); |
| 190 #define XKEY_DATA(x) XRECORD (x, key_data, Lisp_Key_Data) | |
| 191 #define wrap_key_data(p) wrap_record (p, key_data) | |
| 192 #define KEY_DATAP(x) RECORDP (x, key_data) | |
| 193 #define CHECK_KEY_DATA(x) CHECK_RECORD (x, key_data) | |
| 194 #define CONCHECK_KEY_DATA(x) CONCHECK_RECORD (x, key_data) | |
| 1204 | 195 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 196 |
| 1204 | 197 #define EVENT_KEY_KEYSYM(e) EVENT_FOO_BAR (e, KEY, key, keysym) |
| 198 #define XEVENT_KEY_KEYSYM(e) EVENT_KEY_KEYSYM (XEVENT (e)) | |
| 199 #define SET_EVENT_KEY_KEYSYM(e, val) \ | |
| 200 SET_EVENT_FOO_BAR (e, KEY, key, keysym, val) | |
| 201 #define XSET_EVENT_KEY_KEYSYM(e, val) \ | |
| 202 SET_EVENT_KEY_KEYSYM (XEVENT (e), val) | |
| 934 | 203 |
| 1204 | 204 #define EVENT_KEY_MODIFIERS(e) EVENT_FOO_BAR (e, KEY, key, modifiers) |
| 205 #define XEVENT_KEY_MODIFIERS(e) EVENT_KEY_MODIFIERS (XEVENT (e)) | |
| 206 #define SET_EVENT_KEY_MODIFIERS(e, val) \ | |
| 207 SET_EVENT_FOO_BAR (e, KEY, key, modifiers, val) | |
| 208 #define XSET_EVENT_KEY_MODIFIERS(e, val) \ | |
| 209 SET_EVENT_KEY_MODIFIERS (XEVENT (e), val) | |
| 934 | 210 |
| 1204 | 211 #define EVENT_KEY_ALT_KEYCHARS(e, n) \ |
| 212 EVENT_FOO_BAR (e, KEY, key, alt_keychars[n]) | |
| 213 #define XEVENT_KEY_ALT_KEYCHARS(e, n) EVENT_KEY_ALT_KEYCHARS (XEVENT (e), n) | |
| 214 #define SET_EVENT_KEY_ALT_KEYCHARS(e, n, val) \ | |
| 215 SET_EVENT_FOO_BAR (e, KEY, key, alt_keychars[n], val) | |
| 216 #define XSET_EVENT_KEY_ALT_KEYCHARS(e, n, val) \ | |
| 217 SET_EVENT_KEY_ALT_KEYCHARS (XEVENT (e), n, val) | |
| 218 | |
| 934 | 219 struct Lisp_Button_Data |
| 428 | 220 { |
| 1204 | 221 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 222 struct lrecord_header lheader; |
| 1204 | 223 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 224 /* What button went down or up. */ |
| 225 int button; | |
| 226 /* Bucky-bits on that button: shift, control, meta, etc. Also | |
| 227 includes other buttons (not the one pressed). */ | |
| 228 int modifiers; | |
| 229 /* Where it was at the button-state-change (in pixels). */ | |
| 230 int x, y; | |
| 428 | 231 }; |
| 934 | 232 typedef struct Lisp_Button_Data Lisp_Button_Data; |
| 428 | 233 |
| 1204 | 234 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 235 DECLARE_LRECORD (button_data, Lisp_Button_Data); |
| 236 #define XBUTTON_DATA(x) XRECORD (x, button_data, Lisp_Button_Data) | |
| 237 #define wrap_button_data(p) wrap_record (p, button_data) | |
| 238 #define BUTTON_DATAP(x) RECORDP (x, button_data) | |
| 239 #define CHECK_BUTTON_DATA(x) CHECK_RECORD (x, button_data) | |
| 240 #define CONCHECK_BUTTON_DATA(x) CONCHECK_RECORD (x, button_data) | |
| 1204 | 241 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 242 |
| 1204 | 243 #define EVENT_BUTTON_BUTTON(e) EVENT_FOO_BAR (e, BUTTON, button, button) |
| 244 #define XEVENT_BUTTON_BUTTON(e) EVENT_BUTTON_BUTTON (XEVENT (e)) | |
| 245 #define SET_EVENT_BUTTON_BUTTON(e, val) \ | |
| 246 SET_EVENT_FOO_BAR (e, BUTTON, button, button, val) | |
| 247 #define XSET_EVENT_BUTTON_BUTTON(e, val) \ | |
| 248 SET_EVENT_BUTTON_BUTTON (XEVENT (e), val) | |
| 249 | |
| 250 #define EVENT_BUTTON_MODIFIERS(e) EVENT_FOO_BAR (e, BUTTON, button, modifiers) | |
| 251 #define XEVENT_BUTTON_MODIFIERS(e) EVENT_BUTTON_MODIFIERS (XEVENT (e)) | |
| 252 #define SET_EVENT_BUTTON_MODIFIERS(e, val) \ | |
| 253 SET_EVENT_FOO_BAR (e, BUTTON, button, modifiers, val) | |
| 254 #define XSET_EVENT_BUTTON_MODIFIERS(e, val) \ | |
| 255 SET_EVENT_BUTTON_MODIFIERS (XEVENT (e), val) | |
| 934 | 256 |
| 1204 | 257 #define EVENT_BUTTON_X(e) EVENT_FOO_BAR (e, BUTTON, button, x) |
| 258 #define XEVENT_BUTTON_X(e) EVENT_BUTTON_X (XEVENT (e)) | |
| 259 #define SET_EVENT_BUTTON_X(e, val) \ | |
| 260 SET_EVENT_FOO_BAR (e, BUTTON, button, x, val) | |
| 261 #define XSET_EVENT_BUTTON_X(e, val) \ | |
| 262 SET_EVENT_BUTTON_X (XEVENT (e), val) | |
| 934 | 263 |
| 1204 | 264 #define EVENT_BUTTON_Y(e) EVENT_FOO_BAR (e, BUTTON, button, y) |
| 265 #define XEVENT_BUTTON_Y(e) EVENT_BUTTON_Y (XEVENT (e)) | |
| 266 #define SET_EVENT_BUTTON_Y(e, val) \ | |
| 267 SET_EVENT_FOO_BAR (e, BUTTON, button, y, val) | |
| 268 #define XSET_EVENT_BUTTON_Y(e, val) \ | |
| 269 SET_EVENT_BUTTON_Y (XEVENT (e), val) | |
| 270 | |
| 934 | 271 struct Lisp_Motion_Data |
| 428 | 272 { |
| 1204 | 273 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 274 struct lrecord_header lheader; |
| 1204 | 275 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 276 /* Where it was after it moved (in pixels). */ |
| 277 int x, y; | |
| 278 /* Bucky-bits down when the motion was detected. */ | |
| 279 int modifiers; | |
| 428 | 280 }; |
| 934 | 281 typedef struct Lisp_Motion_Data Lisp_Motion_Data; |
| 428 | 282 |
| 1204 | 283 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 284 DECLARE_LRECORD (motion_data, Lisp_Motion_Data); |
| 285 #define XMOTION_DATA(x) XRECORD (x, motion_data, Lisp_Motion_Data) | |
| 286 #define wrap_motion_data(p) wrap_record (p, motion_data) | |
| 287 #define MOTION_DATAP(x) RECORDP (x, motion_data) | |
| 288 #define CHECK_MOTION_DATA(x) CHECK_RECORD (x, motion_data) | |
| 289 #define CONCHECK_MOTION_DATA(x) CONCHECK_RECORD (x, motion_data) | |
| 1204 | 290 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 291 |
| 1204 | 292 #define EVENT_MOTION_X(e) EVENT_FOO_BAR (e, MOTION, motion, x) |
| 293 #define XEVENT_MOTION_X(e) EVENT_MOTION_X (XEVENT (e)) | |
| 294 #define SET_EVENT_MOTION_X(e, val) \ | |
| 295 SET_EVENT_FOO_BAR (e, MOTION, motion, x, val) | |
| 296 #define XSET_EVENT_MOTION_X(e, val) \ | |
| 297 SET_EVENT_MOTION_X (XEVENT (e), val) | |
| 934 | 298 |
| 1204 | 299 #define EVENT_MOTION_Y(e) EVENT_FOO_BAR (e, MOTION, motion, y) |
| 300 #define XEVENT_MOTION_Y(e) EVENT_MOTION_Y (XEVENT (e)) | |
| 301 #define SET_EVENT_MOTION_Y(e, val) \ | |
| 302 SET_EVENT_FOO_BAR (e, MOTION, motion, y, val) | |
| 303 #define XSET_EVENT_MOTION_Y(e, val) \ | |
| 304 SET_EVENT_MOTION_Y (XEVENT (e), val) | |
| 305 | |
| 306 #define EVENT_MOTION_MODIFIERS(e) EVENT_FOO_BAR (e, MOTION, motion, modifiers) | |
| 307 #define XEVENT_MOTION_MODIFIERS(e) EVENT_MOTION_MODIFIERS (XEVENT (e)) | |
| 308 #define SET_EVENT_MOTION_MODIFIERS(e, val) \ | |
| 309 SET_EVENT_FOO_BAR (e, MOTION, motion, modifiers, val) | |
| 310 #define XSET_EVENT_MOTION_MODIFIERS(e, val) \ | |
| 311 SET_EVENT_MOTION_MODIFIERS (XEVENT (e), val) | |
| 312 | |
| 934 | 313 struct Lisp_Process_Data |
| 428 | 314 { |
| 1204 | 315 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 316 struct lrecord_header lheader; |
| 1204 | 317 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 318 /* the XEmacs "process" object in question */ |
| 319 Lisp_Object process; | |
| 428 | 320 }; |
| 934 | 321 typedef struct Lisp_Process_Data Lisp_Process_Data; |
| 428 | 322 |
| 1204 | 323 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 324 DECLARE_LRECORD (process_data, Lisp_Process_Data); |
| 325 #define XPROCESS_DATA(x) XRECORD (x, process_data, Lisp_Process_Data) | |
| 326 #define wrap_process_data(p) wrap_record (p, process_data) | |
| 327 #define PROCESS_DATAP(x) RECORDP (x, process_data) | |
| 328 #define CHECK_PROCESS_DATA(x) CHECK_RECORD (x, process_data) | |
| 329 #define CONCHECK_PROCESS_DATA(x) CONCHECK_RECORD (x, process_data) | |
| 1204 | 330 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 331 |
| 1204 | 332 #define EVENT_PROCESS_PROCESS(e) EVENT_FOO_BAR (e, PROCESS, process, process) |
| 333 #define XEVENT_PROCESS_PROCESS(e) EVENT_PROCESS_PROCESS (XEVENT (e)) | |
| 334 #define SET_EVENT_PROCESS_PROCESS(e, val) \ | |
| 335 SET_EVENT_FOO_BAR (e, PROCESS, process, process, val) | |
| 336 #define XSET_EVENT_PROCESS_PROCESS(e, val) \ | |
| 337 SET_EVENT_PROCESS_PROCESS (XEVENT (e), val) | |
| 338 | |
| 934 | 339 struct Lisp_Timeout_Data |
| 428 | 340 { |
| 771 | 341 /* |
| 342 interval_id The ID returned when the associated call to | |
| 343 add_timeout_cb() was made | |
| 344 ------ the rest of the fields are filled in by XEmacs ----- | |
| 345 id_number The XEmacs timeout ID for this timeout (more | |
| 346 than one timeout event can have the same value | |
| 347 here, since XEmacs timeouts, as opposed to | |
| 348 add_timeout_cb() timeouts, can resignal | |
| 349 themselves) | |
| 350 function An elisp function to call when this timeout is | |
| 351 processed. | |
| 352 object The object passed to that function. | |
| 353 */ | |
| 1204 | 354 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 355 struct lrecord_header lheader; |
| 1204 | 356 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 357 int interval_id; |
| 358 int id_number; | |
| 359 Lisp_Object function; | |
| 360 Lisp_Object object; | |
| 428 | 361 }; |
| 934 | 362 typedef struct Lisp_Timeout_Data Lisp_Timeout_Data; |
| 428 | 363 |
| 1204 | 364 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 365 DECLARE_LRECORD (timeout_data, Lisp_Timeout_Data); |
| 366 #define XTIMEOUT_DATA(x) XRECORD (x, timeout_data, Lisp_Timeout_Data) | |
| 367 #define wrap_timeout_data(p) wrap_record(p, timeout_data) | |
| 368 #define TIMEOUT_DATAP(x) RECORDP (x, timeout_data) | |
| 369 #define CHECK_TIMEOUT_DATA(x) CHECK_RECORD (x, timeout_data) | |
| 370 #define CONCHECK_TIMEOUT_DATA(x) CONCHECK_RECORD (x, timeout_data) | |
| 1204 | 371 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 372 |
| 1204 | 373 #define EVENT_TIMEOUT_INTERVAL_ID(e) EVENT_FOO_BAR (e, TIMEOUT, timeout, interval_id) |
| 374 #define XEVENT_TIMEOUT_INTERVAL_ID(e) EVENT_TIMEOUT_INTERVAL_ID (XEVENT (e)) | |
| 375 #define SET_EVENT_TIMEOUT_INTERVAL_ID(e, val) \ | |
| 376 SET_EVENT_FOO_BAR (e, TIMEOUT, timeout, interval_id, val) | |
| 377 #define XSET_EVENT_TIMEOUT_INTERVAL_ID(e, val) \ | |
| 378 SET_EVENT_TIMEOUT_INTERVAL_ID (XEVENT (e), val) | |
| 379 | |
| 380 #define EVENT_TIMEOUT_ID_NUMBER(e) EVENT_FOO_BAR (e, TIMEOUT, timeout, id_number) | |
| 381 #define XEVENT_TIMEOUT_ID_NUMBER(e) EVENT_TIMEOUT_ID_NUMBER (XEVENT (e)) | |
| 382 #define SET_EVENT_TIMEOUT_ID_NUMBER(e, val) \ | |
| 383 SET_EVENT_FOO_BAR (e, TIMEOUT, timeout, id_number, val) | |
| 384 #define XSET_EVENT_TIMEOUT_ID_NUMBER(e, val) \ | |
| 385 SET_EVENT_TIMEOUT_ID_NUMBER (XEVENT (e), val) | |
| 934 | 386 |
| 1204 | 387 #define EVENT_TIMEOUT_FUNCTION(e) EVENT_FOO_BAR (e, TIMEOUT, timeout, function) |
| 388 #define XEVENT_TIMEOUT_FUNCTION(e) EVENT_TIMEOUT_FUNCTION (XEVENT (e)) | |
| 389 #define SET_EVENT_TIMEOUT_FUNCTION(e, val) \ | |
| 390 SET_EVENT_FOO_BAR (e, TIMEOUT, timeout, function, val) | |
| 391 #define XSET_EVENT_TIMEOUT_FUNCTION(e, val) \ | |
| 392 SET_EVENT_TIMEOUT_FUNCTION (XEVENT (e), val) | |
| 934 | 393 |
| 1204 | 394 #define EVENT_TIMEOUT_OBJECT(e) EVENT_FOO_BAR (e, TIMEOUT, timeout, object) |
| 395 #define XEVENT_TIMEOUT_OBJECT(e) EVENT_TIMEOUT_OBJECT (XEVENT (e)) | |
| 396 #define SET_EVENT_TIMEOUT_OBJECT(e, val) \ | |
| 397 SET_EVENT_FOO_BAR (e, TIMEOUT, timeout, object, val) | |
| 398 #define XSET_EVENT_TIMEOUT_OBJECT(e, val) \ | |
| 399 SET_EVENT_TIMEOUT_OBJECT (XEVENT (e), val) | |
| 400 | |
| 934 | 401 struct Lisp_Eval_Data |
| 428 | 402 { |
| 771 | 403 /* This kind of event is used internally; sometimes the window system |
| 404 interface would like to inform XEmacs of some user action (such as | |
| 405 focusing on another frame) but needs that to happen synchronously | |
| 406 with the other user input, like keypresses. This is useful when | |
| 407 events are reported through callbacks rather than in the standard | |
| 408 event stream. | |
| 409 | |
| 410 function An elisp function to call with this event object. | |
| 411 object Argument of function. | |
| 412 */ | |
| 1204 | 413 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 414 struct lrecord_header lheader; |
| 1204 | 415 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 416 Lisp_Object function; |
| 417 Lisp_Object object; | |
| 428 | 418 }; |
| 934 | 419 typedef struct Lisp_Eval_Data Lisp_Eval_Data; |
| 428 | 420 |
| 1204 | 421 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 422 DECLARE_LRECORD (eval_data, Lisp_Eval_Data); |
| 423 #define XEVAL_DATA(x) XRECORD (x, eval_data, Lisp_Eval_Data) | |
| 424 #define wrap_eval_data(p) wrap_record(p, eval_data) | |
| 425 #define EVAL_DATAP(x) RECORDP (x, eval_data) | |
| 426 #define CHECK_EVAL_DATA(x) CHECK_RECORD (x, eval_data) | |
| 427 #define CONCHECK_EVAL_DATA(x) CONCHECK_RECORD (x, eval_data) | |
| 1204 | 428 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 429 |
| 1204 | 430 #define EVENT_EVAL_FUNCTION(e) EVENT_FOO_BAR (e, EVAL, eval, function) |
| 431 #define XEVENT_EVAL_FUNCTION(e) EVENT_EVAL_FUNCTION (XEVENT (e)) | |
| 432 #define SET_EVENT_EVAL_FUNCTION(e, val) \ | |
| 433 SET_EVENT_FOO_BAR (e, EVAL, eval, function, val) | |
| 434 #define XSET_EVENT_EVAL_FUNCTION(e, val) \ | |
| 435 SET_EVENT_EVAL_FUNCTION (XEVENT (e), val) | |
| 934 | 436 |
| 1204 | 437 #define EVENT_EVAL_OBJECT(e) EVENT_FOO_BAR (e, EVAL, eval, object) |
| 438 #define XEVENT_EVAL_OBJECT(e) EVENT_EVAL_OBJECT (XEVENT (e)) | |
| 439 #define SET_EVENT_EVAL_OBJECT(e, val) \ | |
| 440 SET_EVENT_FOO_BAR (e, EVAL, eval, object, val) | |
| 441 #define XSET_EVENT_EVAL_OBJECT(e, val) \ | |
| 442 SET_EVENT_EVAL_OBJECT (XEVENT (e), val) | |
| 934 | 443 |
| 444 struct Lisp_Misc_User_Data | |
| 428 | 445 { |
| 771 | 446 /* #### The misc-user type is serious junk. It should be separated |
| 447 out into different events. There's no reason to create | |
| 448 sub-subtypes of events. | |
| 449 | |
| 450 function An elisp function to call with this event object. | |
| 451 object Argument of function. | |
| 452 button What button went down or up. | |
| 453 modifiers Bucky-bits on that button: shift, control, meta, etc. | |
| 454 x, y Where it was at the button-state-change (in pixels). | |
| 455 This is similar to an eval_event, except that it is | |
| 456 generated by user actions: selections in the | |
| 457 menubar, scrollbar actions, or drag and drop actions. | |
| 458 It is a "command" event, like key and mouse presses | |
| 459 (and unlike mouse motion, process output, and enter | |
| 460 and leave window hooks). In many ways, eval_events | |
| 461 are not the same as keypresses or misc_user_events. | |
| 462 The button, modifiers, x, and y parts are only used | |
| 463 by the XEmacs Drag'n'Drop system. Don't depend on their | |
| 464 values for other types of misc_user_events. | |
| 465 */ | |
| 1204 | 466 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 467 struct lrecord_header lheader; |
| 1204 | 468 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 469 Lisp_Object function; |
| 470 Lisp_Object object; | |
| 471 int button; | |
| 472 int modifiers; | |
| 473 int x, y; | |
| 428 | 474 }; |
| 934 | 475 typedef struct Lisp_Misc_User_Data Lisp_Misc_User_Data; |
| 428 | 476 |
| 1204 | 477 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 478 DECLARE_LRECORD (misc_user_data, Lisp_Misc_User_Data); |
| 479 #define XMISC_USER_DATA(x) XRECORD (x, misc_user_data, Lisp_Misc_User_Data) | |
| 480 #define wrap_misc_user_data(p) wrap_record(p, misc_user_data) | |
| 481 #define MISC_USER_DATAP(x) RECORDP (x, misc_user_data) | |
| 482 #define CHECK_MISC_USER_DATA(x) CHECK_RECORD (x, misc_user_data) | |
| 483 #define CONCHECK_MISC_USER_DATA(x) CONCHECK_RECORD (x, misc_user_data) | |
| 1204 | 484 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 485 |
| 1204 | 486 #define EVENT_MISC_USER_FUNCTION(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, function) |
| 487 #define XEVENT_MISC_USER_FUNCTION(e) EVENT_MISC_USER_FUNCTION (XEVENT (e)) | |
| 488 #define SET_EVENT_MISC_USER_FUNCTION(e, val) \ | |
| 489 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, function, val) | |
| 490 #define XSET_EVENT_MISC_USER_FUNCTION(e, val) \ | |
| 491 SET_EVENT_MISC_USER_FUNCTION (XEVENT (e), val) | |
| 492 | |
| 493 #define EVENT_MISC_USER_OBJECT(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, object) | |
| 494 #define XEVENT_MISC_USER_OBJECT(e) EVENT_MISC_USER_OBJECT (XEVENT (e)) | |
| 495 #define SET_EVENT_MISC_USER_OBJECT(e, val) \ | |
| 496 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, object, val) | |
| 497 #define XSET_EVENT_MISC_USER_OBJECT(e, val) \ | |
| 498 SET_EVENT_MISC_USER_OBJECT (XEVENT (e), val) | |
| 934 | 499 |
| 1204 | 500 #define EVENT_MISC_USER_BUTTON(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, button) |
| 501 #define XEVENT_MISC_USER_BUTTON(e) EVENT_MISC_USER_BUTTON (XEVENT (e)) | |
| 502 #define SET_EVENT_MISC_USER_BUTTON(e, val) \ | |
| 503 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, button, val) | |
| 504 #define XSET_EVENT_MISC_USER_BUTTON(e, val) \ | |
| 505 SET_EVENT_MISC_USER_BUTTON (XEVENT (e), val) | |
| 506 | |
| 507 #define EVENT_MISC_USER_MODIFIERS(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, modifiers) | |
| 508 #define XEVENT_MISC_USER_MODIFIERS(e) EVENT_MISC_USER_MODIFIERS (XEVENT (e)) | |
| 509 #define SET_EVENT_MISC_USER_MODIFIERS(e, val) \ | |
| 510 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, modifiers, val) | |
| 511 #define XSET_EVENT_MISC_USER_MODIFIERS(e, val) \ | |
| 512 SET_EVENT_MISC_USER_MODIFIERS (XEVENT (e), val) | |
| 934 | 513 |
| 1204 | 514 #define EVENT_MISC_USER_X(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, x) |
| 515 #define XEVENT_MISC_USER_X(e) EVENT_MISC_USER_X (XEVENT (e)) | |
| 516 #define SET_EVENT_MISC_USER_X(e, val) \ | |
| 517 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, x, val) | |
| 518 #define XSET_EVENT_MISC_USER_X(e, val) \ | |
| 519 SET_EVENT_MISC_USER_X (XEVENT (e), val) | |
| 934 | 520 |
| 1204 | 521 #define EVENT_MISC_USER_Y(e) EVENT_FOO_BAR (e, MISC_USER, misc_user, y) |
| 522 #define XEVENT_MISC_USER_Y(e) EVENT_MISC_USER_Y (XEVENT (e)) | |
| 523 #define SET_EVENT_MISC_USER_Y(e, val) \ | |
| 524 SET_EVENT_FOO_BAR (e, MISC_USER, misc_user, y, val) | |
| 525 #define XSET_EVENT_MISC_USER_Y(e, val) \ | |
| 526 SET_EVENT_MISC_USER_Y (XEVENT (e), val) | |
| 934 | 527 |
| 528 struct Lisp_Magic_Eval_Data | |
| 428 | 529 { |
| 771 | 530 /* This is like an eval event but its contents are not |
| 531 Lisp-accessible. This allows for "internal eval events" that call | |
| 532 non-Lisp-accessible functions. Externally, a magic_eval_event just | |
| 533 appears as a magic_event; the Lisp programmer need not know | |
| 534 anything more. | |
| 535 | |
| 536 internal_function An unexported function to call with this event | |
| 537 object. This allows eval events to call internal | |
| 538 functions. For a normal eval event, this field | |
| 539 will always be 0. | |
| 540 object Argument of function. | |
| 541 | |
| 542 */ | |
| 1204 | 543 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 544 struct lrecord_header lheader; |
| 1204 | 545 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 771 | 546 void (*internal_function) (Lisp_Object); |
| 547 Lisp_Object object; | |
| 428 | 548 }; |
| 934 | 549 typedef struct Lisp_Magic_Eval_Data Lisp_Magic_Eval_Data; |
| 550 | |
| 1204 | 551 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 552 DECLARE_LRECORD (magic_eval_data, Lisp_Magic_Eval_Data); |
| 553 #define XMAGIC_EVAL_DATA(x) XRECORD (x, magic_eval_data, Lisp_Magic_Eval_Data) | |
| 554 #define wrap_magic_eval_data(p) wrap_record(p, magic_eval_data) | |
| 555 #define MAGIC_EVAL_DATAP(x) RECORDP (x, magic_eval_data) | |
| 556 #define CHECK_MAGIC_EVAL_DATA(x) CHECK_RECORD (x, magic_eval_data) | |
| 557 #define CONCHECK_MAGIC_EVAL_DATA(x) CONCHECK_RECORD (x, magic_eval_data) | |
| 1204 | 558 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 559 |
| 1204 | 560 #define EVENT_MAGIC_EVAL_INTERNAL_FUNCTION(e) EVENT_FOO_BAR (e, MAGIC_EVAL, magic_eval, internal_function) |
| 561 #define XEVENT_MAGIC_EVAL_INTERNAL_FUNCTION(e) EVENT_MAGIC_EVAL_INTERNAL_FUNCTION (XEVENT (e)) | |
| 562 #define SET_EVENT_MAGIC_EVAL_INTERNAL_FUNCTION(e, val) \ | |
| 563 SET_EVENT_FOO_BAR (e, MAGIC_EVAL, magic_eval, internal_function, val) | |
| 564 #define XSET_EVENT_MAGIC_EVAL_INTERNAL_FUNCTION(e, val) \ | |
| 565 SET_EVENT_MAGIC_EVAL_INTERNAL_FUNCTION (XEVENT (e), val) | |
| 566 | |
| 567 #define EVENT_MAGIC_EVAL_OBJECT(e) EVENT_FOO_BAR (e, MAGIC_EVAL, magic_eval, object) | |
| 568 #define XEVENT_MAGIC_EVAL_OBJECT(e) EVENT_MAGIC_EVAL_OBJECT (XEVENT (e)) | |
| 569 #define SET_EVENT_MAGIC_EVAL_OBJECT(e, val) \ | |
| 570 SET_EVENT_FOO_BAR (e, MAGIC_EVAL, magic_eval, object, val) | |
| 571 #define XSET_EVENT_MAGIC_EVAL_OBJECT(e, val) \ | |
| 572 SET_EVENT_MAGIC_EVAL_OBJECT (XEVENT (e), val) | |
| 428 | 573 |
| 574 #if defined (HAVE_X_WINDOWS) && defined(emacs) | |
| 575 # include <X11/Xlib.h> | |
| 576 #endif | |
| 577 | |
| 462 | 578 #ifdef HAVE_GTK |
| 579 #include <gdk/gdk.h> | |
| 580 #endif | |
| 581 | |
| 934 | 582 |
| 583 struct Lisp_Magic_Data | |
| 584 { | |
| 1204 | 585 /* No user-serviceable parts within. This is for things like |
| 586 KeymapNotify and ExposeRegion events and so on that XEmacs itself | |
| 587 doesn't care about, but which it must do something with for proper | |
| 588 interaction with the window system. | |
| 589 | |
| 590 Magic_events are handled somewhat asynchronously, just like | |
| 591 subprocess filters. However, occasionally a magic_event needs to | |
| 592 be handled synchronously; in that case, the asynchronous handling | |
| 593 of the magic_event will push an eval_event back onto the queue, | |
| 594 which will be handled synchronously later. This is one of the | |
| 595 reasons why eval_events exist; I'm not entirely happy with this | |
| 596 aspect of this event model. | |
| 597 */ | |
| 598 | |
| 599 #ifdef EVENT_DATA_AS_OBJECTS | |
| 934 | 600 struct lrecord_header lheader; |
| 1204 | 601 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 602 |
| 603 union { | |
| 604 #ifdef HAVE_GTK | |
| 605 GdkEvent gdk_event; | |
| 606 #endif | |
| 607 #ifdef HAVE_X_WINDOWS | |
| 608 XEvent x_event; | |
| 609 #endif | |
| 610 #ifdef HAVE_MS_WINDOWS | |
| 611 int mswindows_event; | |
| 612 #endif | |
| 613 } underlying; | |
| 614 }; | |
| 615 | |
| 616 typedef struct Lisp_Magic_Data Lisp_Magic_Data; | |
| 617 | |
| 1204 | 618 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 619 DECLARE_LRECORD (magic_data, Lisp_Magic_Data); |
| 620 #define XMAGIC_DATA(x) XRECORD (x, magic_data, Lisp_Magic_Data) | |
| 621 #define wrap_magic_data(p) wrap_record(p, magic_data) | |
| 622 #define MAGIC_DATAP(x) RECORDP (x, magic_data) | |
| 623 #define CHECK_MAGIC_DATA(x) CHECK_RECORD (x, magic_data) | |
| 624 #define CONCHECK_MAGIC_DATA(x) CONCHECK_RECORD (x, magic_data) | |
| 1204 | 625 #endif /* EVENT_DATA_AS_OBJECTS */ |
| 934 | 626 |
| 1204 | 627 #define EVENT_MAGIC_UNDERLYING(e) EVENT_FOO_BAR (e, MAGIC, magic, underlying) |
| 628 #define XEVENT_MAGIC_UNDERLYING(e) EVENT_MAGIC_UNDERLYING (XEVENT (e)) | |
| 629 #define SET_EVENT_MAGIC_UNDERLYING(e, val) \ | |
| 630 SET_EVENT_FOO_BAR (e, MAGIC, magic, underlying, val) | |
| 631 #define XSET_EVENT_MAGIC_UNDERLYING(e, val) \ | |
| 632 SET_EVENT_MAGIC_UNDERLYING (XEVENT (e), val) | |
| 934 | 633 |
| 634 #ifdef HAVE_GTK | |
| 1204 | 635 #define EVENT_MAGIC_GDK_EVENT(e) EVENT_FOO_BAR (e, MAGIC, magic, underlying.gdk_event) |
| 636 #define XEVENT_MAGIC_GDK_EVENT(e) EVENT_MAGIC_GDK_EVENT (XEVENT (e)) | |
| 637 #define SET_EVENT_MAGIC_GDK_EVENT(e, val) \ | |
| 638 SET_EVENT_FOO_BAR (e, MAGIC, magic, underlying.gdk_event, val) | |
| 639 #define XSET_EVENT_MAGIC_GDK_EVENT(e, val) \ | |
| 640 SET_EVENT_MAGIC_GDK_EVENT (XEVENT (e), val) | |
| 641 #endif | |
| 934 | 642 |
| 643 #ifdef HAVE_X_WINDOWS | |
| 1204 | 644 #define EVENT_MAGIC_X_EVENT(e) EVENT_FOO_BAR (e, MAGIC, magic, underlying.x_event) |
| 645 #define XEVENT_MAGIC_X_EVENT(e) EVENT_MAGIC_X_EVENT (XEVENT (e)) | |
| 646 #define SET_EVENT_MAGIC_X_EVENT(e, val) \ | |
| 647 SET_EVENT_FOO_BAR (e, MAGIC, magic, underlying.x_event, val) | |
| 648 #define XSET_EVENT_MAGIC_X_EVENT(e, val) \ | |
| 649 SET_EVENT_MAGIC_X_EVENT (XEVENT (e), val) | |
| 934 | 650 #endif |
| 651 | |
| 652 #ifdef HAVE_MS_WINDOWS | |
| 1204 | 653 #define EVENT_MAGIC_MSWINDOWS_EVENT(e) EVENT_FOO_BAR (e, MAGIC, magic, underlying.mswindows_event) |
| 654 #define XEVENT_MAGIC_MSWINDOWS_EVENT(e) EVENT_MAGIC_MSWINDOWS_EVENT (XEVENT (e)) | |
| 655 #define SET_EVENT_MAGIC_MSWINDOWS_EVENT(e, val) \ | |
| 656 SET_EVENT_FOO_BAR (e, MAGIC, magic, underlying.mswindows_event, val) | |
| 657 #define XSET_EVENT_MAGIC_MSWINDOWS_EVENT(e, val) \ | |
| 658 SET_EVENT_MAGIC_MSWINDOWS_EVENT (XEVENT (e), val) | |
| 934 | 659 #endif |
| 660 | |
| 428 | 661 struct Lisp_Timeout |
| 662 { | |
| 3017 | 663 struct LCRECORD_HEADER header; |
| 428 | 664 int id; /* Id we use to identify the timeout over its lifetime */ |
| 665 int interval_id; /* Id for this particular interval; this may | |
| 771 | 666 be different each time the timeout is |
| 667 signalled.*/ | |
| 428 | 668 Lisp_Object function, object; /* Function and object associated |
| 771 | 669 with timeout. */ |
| 428 | 670 EMACS_TIME next_signal_time; /* Absolute time when the timeout |
| 771 | 671 is next going to be signalled. */ |
| 428 | 672 unsigned int resignal_msecs; /* How far after the next timeout |
| 771 | 673 should the one after that |
| 674 occur? */ | |
| 428 | 675 }; |
| 440 | 676 typedef struct Lisp_Timeout Lisp_Timeout; |
| 428 | 677 |
| 440 | 678 DECLARE_LRECORD (timeout, Lisp_Timeout); |
| 679 #define XTIMEOUT(x) XRECORD (x, timeout, Lisp_Timeout) | |
| 617 | 680 #define wrap_timeout(p) wrap_record (p, timeout) |
| 428 | 681 #define TIMEOUTP(x) RECORDP (x, timeout) |
| 682 #define CHECK_TIMEOUT(x) CHECK_RECORD (x, timeout) | |
| 683 #define CONCHECK_TIMEOUT(x) CONCHECK_RECORD (x, timeout) | |
| 684 | |
| 685 struct Lisp_Event | |
| 686 { | |
| 687 /* header->next (aka XEVENT_NEXT ()) is used as follows: | |
| 688 - For dead events, this is the next dead one. | |
| 689 - For events on the command_event_queue, the next one on the queue. | |
| 690 - Likewise for events chained in the command builder. | |
| 691 - Otherwise it's Qnil. | |
| 692 */ | |
| 693 struct lrecord_header lheader; | |
| 771 | 694 Lisp_Object next; |
| 695 emacs_event_type event_type; | |
| 696 | |
| 697 /* Where this event occurred on. This will be a frame, device, | |
| 698 console, or nil, depending on the event type. It is important | |
| 699 that an object of a more specific type than is actually generated | |
| 700 is not substituted -- e.g. there should not be a frame inserted | |
| 701 when a key-press event occurs, because events on dead channels | |
| 702 are automatically ignored. | |
| 703 | |
| 704 Specifically: | |
| 705 | |
| 706 -- for button and mouse-motion events, channel will be a | |
| 707 frame. (The translation to a window occurs later.) | |
| 708 | |
| 709 -- for keyboard events, channel will be a console. Note that | |
| 710 fake keyboard events (generated by `character-to-event' or | |
| 711 something that calls this, such as macros) need to have the | |
| 712 selected console stored into them when the event is created. | |
| 713 This is so that the correct console-local variables (e.g. the | |
| 714 command builder) will get affected. | |
| 715 | |
| 716 -- for timer, process, magic-eval, and eval events, channel will | |
| 717 be nil. | |
| 718 | |
| 719 -- for misc-user events, channel will be a frame. | |
| 720 | |
| 721 -- for magic events, channel will be a frame (usually) or a | |
| 722 device. */ | |
| 723 Lisp_Object channel; | |
| 724 | |
| 725 /* When this event occurred -- if not known, this is made up. #### | |
| 726 All timestamps should be measured as milliseconds since XEmacs | |
| 727 started. Currently they are raw server timestamps. (The X | |
| 728 protocol doesn't provide any easy way of translating between | |
| 729 server time and real process time; yuck.) */ | |
| 934 | 730 unsigned int timestamp; |
| 771 | 731 |
| 1204 | 732 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 733 Lisp_Object event_data; |
| 1204 | 734 #else /* not EVENT_DATA_AS_OBJECTS */ |
| 428 | 735 union |
| 736 { | |
| 1204 | 737 Lisp_Key_Data key; |
| 738 Lisp_Button_Data button; | |
| 739 Lisp_Motion_Data motion; | |
| 740 Lisp_Process_Data process; | |
| 741 Lisp_Timeout_Data timeout; | |
| 742 Lisp_Eval_Data eval; /* misc_user_event no longer uses this */ | |
| 743 Lisp_Misc_User_Data misc_user;/* because it needs position information */ | |
| 744 Lisp_Magic_Data magic; | |
| 745 Lisp_Magic_Eval_Data magic_eval; | |
| 428 | 746 } event; |
| 1204 | 747 #endif /* not EVENT_DATA_AS_OBJECTS */ |
| 428 | 748 }; |
| 749 | |
| 440 | 750 DECLARE_LRECORD (event, Lisp_Event); |
| 751 #define XEVENT(x) XRECORD (x, event, Lisp_Event) | |
| 617 | 752 #define wrap_event(p) wrap_record (p, event) |
| 428 | 753 #define EVENTP(x) RECORDP (x, event) |
| 754 #define CHECK_EVENT(x) CHECK_RECORD (x, event) | |
| 755 #define CONCHECK_EVENT(x) CONCHECK_RECORD (x, event) | |
| 756 | |
| 757 DECLARE_LRECORD (command_builder, struct command_builder); | |
| 758 | |
| 759 #define EVENT_CHANNEL(a) ((a)->channel) | |
| 1204 | 760 #define XEVENT_CHANNEL(ev) (XEVENT (ev)->channel) |
| 428 | 761 #define EVENT_TYPE(a) ((a)->event_type) |
| 762 #define XEVENT_TYPE(a) (XEVENT (a)->event_type) | |
| 763 #define EVENT_NEXT(a) ((a)->next) | |
| 764 #define XEVENT_NEXT(e) (XEVENT (e)->next) | |
| 1204 | 765 #define EVENT_TIMESTAMP(ev) ((ev)->timestamp) |
| 766 #define XEVENT_TIMESTAMP(ev) EVENT_TIMESTAMP (XEVENT (ev)) | |
| 934 | 767 |
| 1204 | 768 #ifdef EVENT_DATA_AS_OBJECTS |
| 934 | 769 #define XEVENT_DATA(ev) (XEVENT (ev)->event_data) |
| 770 #define EVENT_DATA(ev) ((ev)->event_data) | |
| 1204 | 771 #define SET_EVENT_DATA(ev, d) \ |
| 772 do { \ | |
| 773 Lisp_Event *mac_event = (ev); \ | |
| 774 mac_event->event_data = (d); \ | |
| 775 } while (0) | |
| 776 #define XSET_EVENT_DATA(ev, d) SET_EVENT_DATA (XEVENT (ev), d) | |
| 777 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 778 |
| 1204 | 779 #define SET_EVENT_TIMESTAMP_ZERO(ev) ((ev)->timestamp = 0) |
| 780 #define SET_EVENT_TIMESTAMP(ev, t) ((ev)->timestamp = (t)) | |
| 934 | 781 #define XSET_EVENT_TIMESTAMP(ev, t) SET_EVENT_TIMESTAMP (XEVENT (ev), t) |
| 782 | |
| 783 #define SET_EVENT_CHANNEL(ev, c) \ | |
| 784 do { \ | |
| 785 Lisp_Event *mac_event = (ev); \ | |
| 786 mac_event->channel = (c); \ | |
| 787 } while (0) | |
| 788 #define XSET_EVENT_CHANNEL(ev, c) SET_EVENT_CHANNEL (XEVENT (ev), c) | |
| 789 | |
| 1204 | 790 DECLARE_INLINE_HEADER ( |
| 791 void | |
| 792 set_event_type (struct Lisp_Event *event, emacs_event_type t) | |
| 793 ) | |
| 794 { | |
| 795 #ifdef EVENT_DATA_AS_OBJECTS | |
| 796 switch (EVENT_TYPE (event)) | |
| 797 { | |
| 798 case key_press_event: | |
| 799 free_key_data (event->event_data); | |
| 800 break; | |
| 801 case button_press_event: | |
| 802 case button_release_event: | |
| 803 free_button_data (event->event_data); | |
| 804 break; | |
| 805 case pointer_motion_event: | |
| 806 free_motion_data (event->event_data); | |
| 807 break; | |
| 808 case process_event: | |
| 809 free_process_data (event->event_data); | |
| 810 break; | |
| 811 case timeout_event: | |
| 812 free_timeout_data (event->event_data); | |
| 813 break; | |
| 814 case magic_event: | |
| 815 free_magic_data (event->event_data); | |
| 816 break; | |
| 817 case magic_eval_event: | |
| 818 free_magic_eval_data (event->event_data); | |
| 819 break; | |
| 820 case eval_event: | |
| 821 free_eval_data (event->event_data); | |
| 822 break; | |
| 823 case misc_user_event: | |
| 824 free_misc_user_data (event->event_data); | |
| 825 break; | |
| 826 default: | |
| 827 break; | |
| 828 } | |
| 829 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 830 |
| 831 event->event_type = t; | |
| 832 | |
| 1204 | 833 #ifdef EVENT_DATA_AS_OBJECTS |
| 834 switch (t) | |
| 835 { | |
| 836 case key_press_event: | |
| 837 event->event_data = make_key_data (); | |
| 838 break; | |
| 839 case button_press_event: | |
| 840 case button_release_event: | |
| 841 event->event_data = make_button_data (); | |
| 842 break; | |
| 843 case pointer_motion_event: | |
| 844 event->event_data = make_motion_data (); | |
| 845 break; | |
| 846 case process_event: | |
| 847 event->event_data = make_process_data (); | |
| 848 break; | |
| 849 case timeout_event: | |
| 850 event->event_data = make_timeout_data (); | |
| 851 break; | |
| 852 case magic_event: | |
| 853 event->event_data = make_magic_data (); | |
| 854 break; | |
| 855 case magic_eval_event: | |
| 856 event->event_data = make_magic_eval_data (); | |
| 857 break; | |
| 858 case eval_event: | |
| 859 event->event_data = make_eval_data (); | |
| 860 break; | |
| 861 case misc_user_event: | |
| 862 event->event_data = make_misc_user_data (); | |
| 863 break; | |
| 864 default: | |
| 865 event->event_data = Qnil; | |
| 866 break; | |
| 867 } | |
| 868 #endif /* EVENT_DATA_AS_OBJECTS */ | |
| 934 | 869 } |
| 1204 | 870 |
| 871 #define SET_EVENT_NEXT(ev, n) do { (ev)->next = (n); } while (0) | |
| 872 #define XSET_EVENT_NEXT(ev, n) SET_EVENT_NEXT (XEVENT (ev), n) | |
| 873 | |
| 934 | 874 #define XSET_EVENT_TYPE(ev, t) set_event_type (XEVENT (ev), t) |
| 875 #define SET_EVENT_TYPE(ev, t) set_event_type (ev, t) | |
| 876 | |
| 428 | 877 #define EVENT_CHAIN_LOOP(event, chain) \ |
| 878 for (event = chain; !NILP (event); event = XEVENT_NEXT (event)) | |
| 879 | |
| 880 #define EVENT_LIVE_P(a) (EVENT_TYPE (a) != dead_event) | |
| 881 | |
| 771 | 882 #define CHECK_LIVE_EVENT(x) do { \ |
| 883 CHECK_EVENT (x); \ | |
| 884 if (! EVENT_LIVE_P (XEVENT (x))) \ | |
| 885 dead_wrong_type_argument (Qevent_live_p, (x)); \ | |
| 428 | 886 } while (0) |
| 771 | 887 #define CONCHECK_LIVE_EVENT(x) do { \ |
| 888 CONCHECK_EVENT (x); \ | |
| 889 if (! EVENT_LIVE_P (XEVENT (x))) \ | |
| 890 x = wrong_type_argument (Qevent_live_p, (x)); \ | |
| 428 | 891 } while (0) |
| 892 | |
| 893 | |
| 894 EXFUN (Fcharacter_to_event, 4); | |
| 895 EXFUN (Fdeallocate_event, 1); | |
| 896 EXFUN (Fevent_glyph_extent, 1); | |
| 897 EXFUN (Fevent_modeline_position, 1); | |
| 898 EXFUN (Fevent_over_modeline_p, 1); | |
| 899 EXFUN (Fevent_over_toolbar_p, 1); | |
| 900 EXFUN (Fevent_over_vertical_divider_p, 1); | |
| 901 EXFUN (Fevent_point, 1); | |
| 902 EXFUN (Fevent_window, 1); | |
| 903 EXFUN (Fmake_event, 2); | |
| 1268 | 904 EXFUN (Fnext_command_event, 2); |
| 428 | 905 |
| 906 extern Lisp_Object QKbackspace, QKdelete, QKescape, QKlinefeed, QKreturn; | |
| 907 extern Lisp_Object QKspace, QKtab, Qmouse_event_p, Vcharacter_set_property; | |
| 908 extern Lisp_Object Qcancel_mode_internal; | |
| 444 | 909 extern Lisp_Object Vmodifier_keys_sticky_time; |
| 428 | 910 |
| 502 | 911 /* The modifiers XEmacs knows about; these appear in key and button events. */ |
| 912 | |
| 771 | 913 #define XEMACS_MOD_CONTROL (1<<0) |
| 914 #define XEMACS_MOD_META (1<<1) | |
| 915 #define XEMACS_MOD_SUPER (1<<2) | |
| 916 #define XEMACS_MOD_HYPER (1<<3) | |
| 917 #define XEMACS_MOD_ALT (1<<4) | |
| 918 #define XEMACS_MOD_SHIFT (1<<5) /* not used for dual-case characters */ | |
| 919 #define XEMACS_MOD_BUTTON1 (1<<6) | |
| 920 #define XEMACS_MOD_BUTTON2 (1<<7) | |
| 921 #define XEMACS_MOD_BUTTON3 (1<<8) | |
| 922 #define XEMACS_MOD_BUTTON4 (1<<9) | |
| 923 #define XEMACS_MOD_BUTTON5 (1<<10) | |
| 4272 | 924 #define XEMACS_MOD_BUTTON6 (1<<11) |
| 925 #define XEMACS_MOD_BUTTON7 (1<<12) | |
| 926 #define XEMACS_MOD_BUTTON8 (1<<13) | |
| 927 #define XEMACS_MOD_BUTTON9 (1<<14) | |
| 928 #define XEMACS_MOD_BUTTON10 (1<<15) | |
| 929 #define XEMACS_MOD_BUTTON11 (1<<16) | |
| 930 #define XEMACS_MOD_BUTTON12 (1<<17) | |
| 931 #define XEMACS_MOD_BUTTON13 (1<<18) | |
| 932 #define XEMACS_MOD_BUTTON14 (1<<19) | |
| 933 #define XEMACS_MOD_BUTTON15 (1<<20) | |
| 934 #define XEMACS_MOD_BUTTON16 (1<<21) | |
| 935 #define XEMACS_MOD_BUTTON17 (1<<22) | |
| 936 #define XEMACS_MOD_BUTTON18 (1<<23) | |
| 937 #define XEMACS_MOD_BUTTON19 (1<<24) | |
| 938 #define XEMACS_MOD_BUTTON20 (1<<25) | |
| 939 #define XEMACS_MOD_BUTTON21 (1<<26) | |
| 940 #define XEMACS_MOD_BUTTON22 (1<<27) | |
| 941 #define XEMACS_MOD_BUTTON23 (1<<28) | |
| 942 #define XEMACS_MOD_BUTTON24 (1<<29) | |
| 943 #define XEMACS_MOD_BUTTON25 (1<<30) | |
| 944 #define XEMACS_MOD_BUTTON26 (1<<31) | |
| 945 | |
| 502 | 946 /* Note: under X Windows, XEMACS_MOD_ALT is generated by the Alt key |
| 947 if there are both Alt and Meta keys. If there are no Meta keys, | |
| 948 then Alt generates XEMACS_MOD_META instead. | |
| 428 | 949 */ |
| 950 | |
| 951 /* Maybe this should be trickier */ | |
| 952 #define KEYSYM(x) (intern (x)) | |
| 953 | |
|
4780
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
954 typedef enum character_to_event_meta_behavior |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
955 { |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
956 high_bit_is_meta, |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
957 use_console_meta_flag, |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
958 latin_1_maps_to_itself |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
959 } character_to_event_meta_behavior; |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
960 |
| 428 | 961 /* from events.c */ |
| 934 | 962 void format_event_object (Eistring *buf, Lisp_Object event, int brief); |
| 1229 | 963 /*void format_event_data_object (Eistring *buf, Lisp_Object data, int brief);*/ |
|
4780
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
964 void character_to_event (Ichar, Lisp_Event *, struct console *, |
|
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
965 character_to_event_meta_behavior meta_flag, |
| 771 | 966 int do_backspace_mapping); |
|
4780
2fd201d73a92
Call character_to_event on characters received from XIM, event-Xt.c
Aidan Kehoe <kehoea@parhasard.net>
parents:
4272
diff
changeset
|
967 |
| 440 | 968 void zero_event (Lisp_Event *e); |
| 1204 | 969 |
| 970 #define MECR_DEALLOCATE_EVENT 1 | |
| 971 | |
| 428 | 972 void deallocate_event_chain (Lisp_Object event); |
| 973 Lisp_Object event_chain_tail (Lisp_Object event); | |
| 974 void enqueue_event (Lisp_Object event, Lisp_Object *head, Lisp_Object *tail); | |
| 975 Lisp_Object dequeue_event (Lisp_Object *head, Lisp_Object *tail); | |
| 976 void enqueue_event_chain (Lisp_Object event_chain, Lisp_Object *head, | |
| 771 | 977 Lisp_Object *tail); |
| 1204 | 978 int map_event_chain_remove (int (*fn) (Lisp_Object ev, void *user_data), |
| 979 Lisp_Object *head, Lisp_Object *tail, | |
| 980 void *user_data, int flags); | |
| 428 | 981 int event_chain_count (Lisp_Object event_chain); |
| 982 Lisp_Object event_chain_find_previous (Lisp_Object event_chain, | |
| 771 | 983 Lisp_Object event); |
| 428 | 984 Lisp_Object event_chain_nth (Lisp_Object event_chain, int n); |
| 985 Lisp_Object copy_event_chain (Lisp_Object event_chain); | |
| 1204 | 986 Lisp_Object transfer_event_chain_pointer (Lisp_Object pointer, |
| 987 Lisp_Object old_chain, | |
| 988 Lisp_Object new_chain); | |
| 989 | |
| 990 | |
| 991 void nth_of_key_sequence_as_event (Lisp_Object seq, int n, Lisp_Object event); | |
| 992 Lisp_Object key_sequence_to_event_chain (Lisp_Object seq); | |
| 428 | 993 /* True if this is a non-internal event |
| 994 (keyboard press, menu, scrollbar, mouse button) */ | |
| 995 int command_event_p (Lisp_Object event); | |
| 440 | 996 void define_self_inserting_symbol (Lisp_Object, Lisp_Object); |
| 2828 | 997 Ichar event_to_character (Lisp_Object, int, int); |
| 428 | 998 struct console *event_console_or_selected (Lisp_Object event); |
| 1204 | 999 void upshift_event (Lisp_Object event); |
| 1000 void downshift_event (Lisp_Object event); | |
| 1001 int event_upshifted_p (Lisp_Object event); | |
| 428 | 1002 |
| 1003 /* from event-stream.c */ | |
| 1204 | 1004 extern Lisp_Object dispatch_event_queue; |
| 771 | 1005 Lisp_Object allocate_command_builder (Lisp_Object console, int with_echo_buf); |
| 1204 | 1006 void enqueue_dispatch_event (Lisp_Object event); |
| 1007 Lisp_Object dequeue_dispatch_event (void); | |
| 428 | 1008 void enqueue_magic_eval_event (void (*fun) (Lisp_Object), Lisp_Object object); |
| 440 | 1009 void event_stream_handle_magic_event (Lisp_Event *event); |
| 788 | 1010 void event_stream_format_magic_event (Lisp_Event *event, Lisp_Object pstream); |
| 1011 int event_stream_compare_magic_event (Lisp_Event *e1, Lisp_Event *e2); | |
| 1012 Hashcode event_stream_hash_magic_event (Lisp_Event *e); | |
| 428 | 1013 void event_stream_select_console (struct console *con); |
| 1014 void event_stream_unselect_console (struct console *con); | |
| 853 | 1015 void event_stream_select_process (Lisp_Process *proc, int doin, int doerr); |
| 1016 void event_stream_unselect_process (Lisp_Process *proc, int doin, int doerr); | |
| 1017 void event_stream_create_io_streams (void* inhandle, void* outhandle, | |
| 1018 void *errhandle, Lisp_Object* instream, | |
| 1019 Lisp_Object* outstream, | |
| 1020 Lisp_Object* errstream, | |
| 1021 USID* in_usid, | |
| 1022 USID* err_usid, | |
| 1023 int flags); | |
| 1024 void event_stream_delete_io_streams (Lisp_Object instream, | |
| 1025 Lisp_Object outstream, | |
| 1026 Lisp_Object errstream, | |
| 1027 USID* in_usid, | |
| 1028 USID* err_usid); | |
| 1268 | 1029 Lisp_Object event_stream_protect_modal_loop (const char *error_string, |
| 1030 Lisp_Object (*bfun) (void *barg), | |
| 1031 void *barg, int flags); | |
| 1032 void event_stream_drain_queue (void); | |
| 428 | 1033 void event_stream_quit_p (void); |
| 853 | 1034 void run_pre_idle_hook (void); |
| 428 | 1035 |
| 1036 struct low_level_timeout | |
| 1037 { | |
| 1038 int id; | |
| 1039 EMACS_TIME time; | |
| 1040 struct low_level_timeout *next; | |
| 1041 }; | |
| 1042 | |
| 1043 int add_low_level_timeout (struct low_level_timeout **timeout_list, | |
| 771 | 1044 EMACS_TIME thyme); |
| 428 | 1045 void remove_low_level_timeout (struct low_level_timeout **timeout_list, |
| 771 | 1046 int id); |
| 428 | 1047 int get_low_level_timeout_interval (struct low_level_timeout * |
| 771 | 1048 timeout_list, EMACS_TIME *interval); |
| 428 | 1049 int pop_low_level_timeout (struct low_level_timeout **timeout_list, |
| 771 | 1050 EMACS_TIME *time_out); |
| 428 | 1051 int event_stream_generate_wakeup (unsigned int milliseconds, |
| 771 | 1052 unsigned int vanilliseconds, |
| 1053 Lisp_Object function, | |
| 1054 Lisp_Object object, | |
| 1055 int async_p); | |
| 593 | 1056 int event_stream_resignal_wakeup (int interval_id, int async_p, |
| 771 | 1057 Lisp_Object *function, Lisp_Object *object); |
| 428 | 1058 void event_stream_disable_wakeup (int id, int async_p); |
| 1059 | |
| 593 | 1060 /* from signal.c */ |
| 1061 int signal_add_async_interval_timeout (EMACS_TIME thyme); | |
| 1062 void signal_remove_async_interval_timeout (int id); | |
| 428 | 1063 |
| 1064 /* from event-stream.c -- focus sanity */ | |
| 1065 extern int focus_follows_mouse; | |
| 1066 void investigate_frame_change (void); | |
| 1067 | |
| 1068 void emacs_handle_focus_change_preliminary (Lisp_Object frame_inp_and_dev); | |
| 1069 void emacs_handle_focus_change_final (Lisp_Object frame_inp_and_dev); | |
| 1070 | |
| 1071 Lisp_Object extract_this_command_keys_nth_mouse_event (int n); | |
| 1072 Lisp_Object extract_vector_nth_mouse_event (Lisp_Object vector, int n); | |
| 1073 | |
| 1074 void single_console_state (void); | |
| 1075 void any_console_state (void); | |
| 1076 int in_single_console_state (void); | |
| 1077 | |
| 1078 extern int emacs_is_blocking; | |
| 1268 | 1079 extern int in_modal_loop; |
| 428 | 1080 extern volatile int sigint_happened; |
| 1081 | |
| 1082 #ifdef HAVE_UNIXOID_EVENT_LOOP | |
| 1083 /* from event-unixoid.c */ | |
| 1084 | |
| 1085 /* Ceci n'est pas un pipe. */ | |
| 1086 extern int signal_event_pipe[]; | |
| 1087 | |
| 1088 void signal_fake_event (void); | |
| 1089 void drain_signal_event_pipe (void); | |
| 1204 | 1090 void drain_tty_devices (void); |
| 428 | 1091 |
| 1092 extern int fake_event_occurred; | |
| 1093 | |
| 1094 int event_stream_unixoid_select_console (struct console *con); | |
| 1095 int event_stream_unixoid_unselect_console (struct console *con); | |
| 853 | 1096 void event_stream_unixoid_select_process (Lisp_Process *proc, int doin, |
| 1097 int doerr, int *infd, int *errfd); | |
| 1098 void event_stream_unixoid_unselect_process (Lisp_Process *proc, int doin, | |
| 1099 int doerr, int *infd, int *errfd); | |
| 1204 | 1100 struct console *find_tty_or_stream_console_from_fd (int fd); |
| 440 | 1101 int read_event_from_tty_or_stream_desc (Lisp_Event *event, |
| 771 | 1102 struct console *con); |
| 853 | 1103 void event_stream_unixoid_create_io_streams (void* inhandle, void* outhandle, |
| 1104 void *errhandle, | |
| 1105 Lisp_Object* instream, | |
| 1106 Lisp_Object* outstream, | |
| 1107 Lisp_Object* errstream, | |
| 1108 USID* in_usid, | |
| 1109 USID* err_usid, | |
| 1110 int flags); | |
| 1111 void event_stream_unixoid_delete_io_streams (Lisp_Object instream, | |
| 1112 Lisp_Object outstream, | |
| 1113 Lisp_Object errstream, | |
| 1114 USID* in_usid, | |
| 1115 USID* err_usid); | |
| 428 | 1116 |
| 1204 | 1117 #endif /* HAVE_UNIXOID_EVENT_LOOP */ |
| 1118 | |
| 1119 /* The following is not inside of HAVE_UNIXOID_EVENT_LOOP because of the | |
| 1120 possibility of combiling XEmacs with no-MSW, no-X, no-TTY -- | |
| 1121 process-unix.c is still compiled. #### Should we still compile | |
| 1122 subprocesses with no event loops? */ | |
| 428 | 1123 /* Beware: this evil macro evaluates its arg many times */ |
| 1124 #define FD_TO_USID(fd) ((fd)==0 ? (USID)999999 : ((fd)<0 ? USID_DONTHASH : (USID)(fd))) | |
| 1125 | |
| 1126 /* Define this if you want the tty event stream to be used when the | |
| 1127 first console is tty, even if HAVE_X_WINDOWS is defined */ | |
| 1128 /* #define DEBUG_TTY_EVENT_STREAM */ | |
| 1129 | |
| 1130 | |
| 442 | 1131 /* #### a hack, until accelerator shit is cleaned up */ |
| 1132 | |
| 1133 /* This structure is what we use to encapsulate the state of a command sequence | |
| 1134 being composed; key events are executed by adding themselves to the command | |
| 1135 builder; if the command builder is then complete (does not still represent | |
| 1136 a prefix key sequence) it executes the corresponding command. | |
| 1137 */ | |
| 1138 struct command_builder | |
| 1139 { | |
| 3017 | 1140 struct LCRECORD_HEADER header; |
| 442 | 1141 Lisp_Object console; /* back pointer to the console this command |
| 771 | 1142 builder is for */ |
| 1143 #if 0 | |
| 1144 /* #### Not implemented: nil, or an event representing the first | |
| 1145 event read after the last command completed. Threaded. */ | |
| 442 | 1146 Lisp_Object prefix_events; |
| 771 | 1147 #endif /* 0 */ |
| 1148 /* nil, or an event chain representing the events in the current | |
| 1149 keymap-lookup sequence. NOTE: All events in the chain MUST be | |
| 1150 freshly allocated, with no pointers to them elsewhere. */ | |
| 442 | 1151 Lisp_Object current_events; |
| 771 | 1152 /* Last elt of current_events */ |
| 442 | 1153 Lisp_Object most_current_event; |
| 771 | 1154 /* Last elt before function map code took over. What this means is: |
| 442 | 1155 All prefixes up to (but not including) this event have non-nil |
| 1156 bindings, but the prefix including this event has a nil binding. | |
| 1157 Any events in the chain after this one were read solely because | |
| 1158 we're part of a possible function key. If we end up with | |
| 1159 something that's not part of a possible function key, we have to | |
| 1160 unread all of those events. */ | |
| 1161 Lisp_Object last_non_munged_event; | |
| 1204 | 1162 /* One value for function-key-map, one for key-translation-map: |
| 1163 First event that can begin a possible function key sequence | |
| 1164 (to be translated according to function-key-map). Normally | |
| 1165 this is the first event in the chain. However, once we've | |
| 1166 translated a sequence through function-key-map, this will point | |
| 1167 to the first event after the translated sequence: we don't ever | |
| 1168 want to translate any events twice through function-key-map, or | |
| 1169 things could get really screwed up (e.g. if the user created a | |
| 1170 translation loop). If this is nil, then the next-read event is | |
| 1171 the first that can begin a function key sequence. */ | |
| 1172 Lisp_Object first_mungeable_event[2]; | |
| 934 | 1173 Ibyte *echo_buf; |
| 442 | 1174 |
| 1175 Bytecount echo_buf_length; /* size of echo_buf */ | |
| 1176 Bytecount echo_buf_index; /* index into echo_buf | |
| 771 | 1177 * -1 before doing echoing for new cmd */ |
| 442 | 1178 /* Self-insert-command is magic in that it doesn't always push an undo- |
| 1179 boundary: up to 20 consecutive self-inserts can happen before an undo- | |
| 1180 boundary is pushed. This variable is that counter. | |
| 1181 */ | |
| 1182 int self_insert_countdown; | |
| 1183 }; | |
| 1184 | |
| 440 | 1185 #endif /* INCLUDED_events_h_ */ |