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