Mercurial > hg > xemacs-beta

comparison src/events.c @ 412:697ef44129c6 r21-2-14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r21-2-14
author cvs
date Mon, 13 Aug 2007 11:20:41 +0200
parents de805c49cfc1
children 41dbb7a9d5f2
comparison
equal deleted inserted replaced
411:12e008d41344 412:697ef44129c6
35 #include "frame.h" 35 #include "frame.h"
36 #include "glyphs.h" 36 #include "glyphs.h"
37 #include "keymap.h" /* for key_desc_list_to_event() */ 37 #include "keymap.h" /* for key_desc_list_to_event() */
38 #include "redisplay.h" 38 #include "redisplay.h"
39 #include "window.h" 39 #include "window.h"
40
41 #ifdef WINDOWSNT
42 /* Hmm, under unix we want X modifiers, under NT we want X modifiers if
43 we are running X and Windows modifiers otherwise.
44 gak. This is a kludge until we support multiple native GUIs!
45 */
46 #undef MOD_ALT
47 #undef MOD_CONTROL
48 #undef MOD_SHIFT
49 #endif
50
40 #include "events-mod.h" 51 #include "events-mod.h"
41 52
42 /* Where old events go when they are explicitly deallocated. 53 /* Where old events go when they are explicitly deallocated.
43 The event chain here is cut loose before GC, so these will be freed 54 The event chain here is cut loose before GC, so these will be freed
44 eventually. 55 eventually.
68 /* Make sure we lose quickly if we try to use this event */ 79 /* Make sure we lose quickly if we try to use this event */
69 static void 80 static void
70 deinitialize_event (Lisp_Object ev) 81 deinitialize_event (Lisp_Object ev)
71 { 82 {
72 int i; 83 int i;
73 Lisp_Event *event = XEVENT (ev); 84 struct Lisp_Event *event = XEVENT (ev);
74 85
75 for (i = 0; i < (int) (sizeof (Lisp_Event) / sizeof (int)); i++) 86 for (i = 0; i < (int) (sizeof (struct Lisp_Event) / sizeof (int)); i++)
76 ((int *) event) [i] = 0xdeadbeef; 87 ((int *) event) [i] = 0xdeadbeef;
77 event->event_type = dead_event; 88 event->event_type = dead_event;
78 event->channel = Qnil; 89 event->channel = Qnil;
79 set_lheader_implementation (&event->lheader, &lrecord_event); 90 set_lheader_implementation (&(event->lheader), &lrecord_event);
80 XSET_EVENT_NEXT (ev, Qnil); 91 XSET_EVENT_NEXT (ev, Qnil);
81 } 92 }
82 93
83 /* Set everything to zero or nil so that it's predictable. */ 94 /* Set everything to zero or nil so that it's predictable. */
84 void 95 void
85 zero_event (Lisp_Event *e) 96 zero_event (struct Lisp_Event *e)
86 { 97 {
87 xzero (*e); 98 xzero (*e);
88 set_lheader_implementation (&e->lheader, &lrecord_event); 99 set_lheader_implementation (&(e->lheader), &lrecord_event);
89 e->event_type = empty_event; 100 e->event_type = empty_event;
90 e->next = Qnil; 101 e->next = Qnil;
91 e->channel = Qnil; 102 e->channel = Qnil;
92 } 103 }
93 104
94 static Lisp_Object 105 static Lisp_Object
95 mark_event (Lisp_Object obj) 106 mark_event (Lisp_Object obj, void (*markobj) (Lisp_Object))
96 { 107 {
97 Lisp_Event *event = XEVENT (obj); 108 struct Lisp_Event *event = XEVENT (obj);
98 109
99 switch (event->event_type) 110 switch (event->event_type)
100 { 111 {
101 case key_press_event: 112 case key_press_event:
102 mark_object (event->event.key.keysym); 113 markobj (event->event.key.keysym);
103 break; 114 break;
104 case process_event: 115 case process_event:
105 mark_object (event->event.process.process); 116 markobj (event->event.process.process);
106 break; 117 break;
107 case timeout_event: 118 case timeout_event:
108 mark_object (event->event.timeout.function); 119 markobj (event->event.timeout.function);
109 mark_object (event->event.timeout.object); 120 markobj (event->event.timeout.object);
110 break; 121 break;
111 case eval_event: 122 case eval_event:
112 case misc_user_event: 123 case misc_user_event:
113 mark_object (event->event.eval.function); 124 markobj (event->event.eval.function);
114 mark_object (event->event.eval.object); 125 markobj (event->event.eval.object);
115 break; 126 break;
116 case magic_eval_event: 127 case magic_eval_event:
117 mark_object (event->event.magic_eval.object); 128 markobj (event->event.magic_eval.object);
118 break; 129 break;
119 case button_press_event: 130 case button_press_event:
120 case button_release_event: 131 case button_release_event:
121 case pointer_motion_event: 132 case pointer_motion_event:
122 case magic_event: 133 case magic_event:
124 case dead_event: 135 case dead_event:
125 break; 136 break;
126 default: 137 default:
127 abort (); 138 abort ();
128 } 139 }
129 mark_object (event->channel); 140 markobj (event->channel);
130 return event->next; 141 return event->next;
131 } 142 }
132 143
133 static void 144 static void
134 print_event_1 (const char *str, Lisp_Object obj, Lisp_Object printcharfun) 145 print_event_1 (CONST char *str, Lisp_Object obj, Lisp_Object printcharfun)
135 { 146 {
136 char buf[255]; 147 char buf[255];
137 write_c_string (str, printcharfun); 148 write_c_string (str, printcharfun);
138 format_event_object (buf, XEVENT (obj), 0); 149 format_event_object (buf, XEVENT (obj), 0);
139 write_c_string (buf, printcharfun); 150 write_c_string (buf, printcharfun);
208 } 219 }
209 220
210 static int 221 static int
211 event_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) 222 event_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
212 { 223 {
213 Lisp_Event *e1 = XEVENT (obj1); 224 struct Lisp_Event *e1 = XEVENT (obj1);
214 Lisp_Event *e2 = XEVENT (obj2); 225 struct Lisp_Event *e2 = XEVENT (obj2);
215 226
216 if (e1->event_type != e2->event_type) return 0; 227 if (e1->event_type != e2->event_type) return 0;
217 if (!EQ (e1->channel, e2->channel)) return 0; 228 if (!EQ (e1->channel, e2->channel)) return 0;
218 /* if (e1->timestamp != e2->timestamp) return 0; */ 229 /* if (e1->timestamp != e2->timestamp) return 0; */
219 switch (e1->event_type) 230 switch (e1->event_type)
280 #endif 291 #endif
281 #ifdef HAVE_MS_WINDOWS 292 #ifdef HAVE_MS_WINDOWS
282 if (CONSOLE_MSWINDOWS_P (con)) 293 if (CONSOLE_MSWINDOWS_P (con))
283 return (!memcmp(&e1->event.magic.underlying_mswindows_event, 294 return (!memcmp(&e1->event.magic.underlying_mswindows_event,
284 &e2->event.magic.underlying_mswindows_event, 295 &e2->event.magic.underlying_mswindows_event,
285 sizeof (union magic_data))); 296 sizeof(union magic_data)));
286 #endif 297 #endif
287 abort ();
288 return 1; /* not reached */ 298 return 1; /* not reached */
289 } 299 }
290 300
291 case empty_event: /* Empty and deallocated events are equal. */ 301 case empty_event: /* Empty and deallocated events are equal. */
292 case dead_event: 302 case dead_event:
295 } 305 }
296 306
297 static unsigned long 307 static unsigned long
298 event_hash (Lisp_Object obj, int depth) 308 event_hash (Lisp_Object obj, int depth)
299 { 309 {
300 Lisp_Event *e = XEVENT (obj); 310 struct Lisp_Event *e = XEVENT (obj);
301 unsigned long hash; 311 unsigned long hash;
302 312
303 hash = HASH2 (e->event_type, LISP_HASH (e->channel)); 313 hash = HASH2 (e->event_type, LISP_HASH (e->channel));
304 switch (e->event_type) 314 switch (e->event_type)
305 { 315 {
348 #endif 358 #endif
349 #ifdef HAVE_MS_WINDOWS 359 #ifdef HAVE_MS_WINDOWS
350 if (CONSOLE_MSWINDOWS_P (con)) 360 if (CONSOLE_MSWINDOWS_P (con))
351 return HASH2 (hash, e->event.magic.underlying_mswindows_event); 361 return HASH2 (hash, e->event.magic.underlying_mswindows_event);
352 #endif 362 #endif
353 abort ();
354 return 0;
355 } 363 }
356 364
357 case empty_event: 365 case empty_event:
358 case dead_event: 366 case dead_event:
359 return hash; 367 return hash;
365 return 0; /* unreached */ 373 return 0; /* unreached */
366 } 374 }
367 375
368 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("event", event, 376 DEFINE_BASIC_LRECORD_IMPLEMENTATION ("event", event,
369 mark_event, print_event, 0, event_equal, 377 mark_event, print_event, 0, event_equal,
370 event_hash, 0, Lisp_Event); 378 event_hash, struct Lisp_Event);
371 379
372 380
373 DEFUN ("make-event", Fmake_event, 0, 2, 0, /* 381 DEFUN ("make-event", Fmake_event, 0, 2, 0, /*
374 Return a new event of type TYPE, with properties described by PLIST. 382 Return a new event of type TYPE, with properties described by PLIST.
375 383
418 */ 426 */
419 (type, plist)) 427 (type, plist))
420 { 428 {
421 Lisp_Object tail, keyword, value; 429 Lisp_Object tail, keyword, value;
422 Lisp_Object event = Qnil; 430 Lisp_Object event = Qnil;
423 Lisp_Event *e; 431 struct Lisp_Event *e;
424 EMACS_INT coord_x = 0, coord_y = 0; 432 EMACS_INT coord_x = 0, coord_y = 0;
425 struct gcpro gcpro1; 433 struct gcpro gcpro1;
426 434
427 GCPRO1 (event); 435 GCPRO1 (event);
428 436
538 int modifiers = 0; 546 int modifiers = 0;
539 Lisp_Object sym; 547 Lisp_Object sym;
540 548
541 EXTERNAL_LIST_LOOP_2 (sym, value) 549 EXTERNAL_LIST_LOOP_2 (sym, value)
542 { 550 {
543 if (EQ (sym, Qcontrol)) modifiers |= XEMACS_MOD_CONTROL; 551 if (EQ (sym, Qcontrol)) modifiers |= MOD_CONTROL;
544 else if (EQ (sym, Qmeta)) modifiers |= XEMACS_MOD_META; 552 else if (EQ (sym, Qmeta)) modifiers |= MOD_META;
545 else if (EQ (sym, Qsuper)) modifiers |= XEMACS_MOD_SUPER; 553 else if (EQ (sym, Qsuper)) modifiers |= MOD_SUPER;
546 else if (EQ (sym, Qhyper)) modifiers |= XEMACS_MOD_HYPER; 554 else if (EQ (sym, Qhyper)) modifiers |= MOD_HYPER;
547 else if (EQ (sym, Qalt)) modifiers |= XEMACS_MOD_ALT; 555 else if (EQ (sym, Qalt)) modifiers |= MOD_ALT;
548 else if (EQ (sym, Qsymbol)) modifiers |= XEMACS_MOD_ALT; 556 else if (EQ (sym, Qsymbol)) modifiers |= MOD_ALT;
549 else if (EQ (sym, Qshift)) modifiers |= XEMACS_MOD_SHIFT; 557 else if (EQ (sym, Qshift)) modifiers |= MOD_SHIFT;
550 else 558 else
551 signal_simple_error ("Invalid key modifier", sym); 559 signal_simple_error ("Invalid key modifier", sym);
552 } 560 }
553 561
554 switch (e->event_type) 562 switch (e->event_type)
753 761
754 DEFUN ("copy-event", Fcopy_event, 1, 2, 0, /* 762 DEFUN ("copy-event", Fcopy_event, 1, 2, 0, /*
755 Make a copy of the given event object. 763 Make a copy of the given event object.
756 If a second argument is given, the first event is copied into the second 764 If a second argument is given, the first event is copied into the second
757 and the second is returned. If the second argument is not supplied (or 765 and the second is returned. If the second argument is not supplied (or
758 is nil) then a new event will be made as with `make-event'. See also 766 is nil) then a new event will be made as with `allocate-event.' See also
759 the function `deallocate-event'. 767 the function `deallocate-event'.
760 */ 768 */
761 (event1, event2)) 769 (event1, event2))
762 { 770 {
763 CHECK_LIVE_EVENT (event1); 771 CHECK_LIVE_EVENT (event1);
764 if (NILP (event2)) 772 if (NILP (event2))
765 event2 = Fmake_event (Qnil, Qnil); 773 event2 = Fmake_event (Qnil, Qnil);
766 else 774 else CHECK_LIVE_EVENT (event2);
767 { 775 if (EQ (event1, event2))
768 CHECK_LIVE_EVENT (event2); 776 return signal_simple_continuable_error_2
769 if (EQ (event1, event2)) 777 ("copy-event called with `eq' events", event1, event2);
770 return signal_simple_continuable_error_2
771 ("copy-event called with `eq' events", event1, event2);
772 }
773 778
774 assert (XEVENT_TYPE (event1) <= last_event_type); 779 assert (XEVENT_TYPE (event1) <= last_event_type);
775 assert (XEVENT_TYPE (event2) <= last_event_type); 780 assert (XEVENT_TYPE (event2) <= last_event_type);
776 781
777 { 782 {
778 Lisp_Event *ev2 = XEVENT (event2); 783 Lisp_Object save_next = XEVENT_NEXT (event2);
779 Lisp_Event *ev1 = XEVENT (event1); 784
780 785 *XEVENT (event2) = *XEVENT (event1);
781 ev2->event_type = ev1->event_type; 786 XSET_EVENT_NEXT (event2, save_next);
782 ev2->channel = ev1->channel;
783 ev2->timestamp = ev1->timestamp;
784 ev2->event = ev1->event;
785
786 return event2; 787 return event2;
787 } 788 }
788 } 789 }
789 790
790 791
960 } 961 }
961 } 962 }
962 963
963 964
964 void 965 void
965 character_to_event (Emchar c, Lisp_Event *event, struct console *con, 966 character_to_event (Emchar c, struct Lisp_Event *event, struct console *con,
966 int use_console_meta_flag, int do_backspace_mapping) 967 int use_console_meta_flag, int do_backspace_mapping)
967 { 968 {
968 Lisp_Object k = Qnil; 969 Lisp_Object k = Qnil;
969 int m = 0; 970 unsigned int m = 0;
970 if (event->event_type == dead_event) 971 if (event->event_type == dead_event)
971 error ("character-to-event called with a deallocated event!"); 972 error ("character-to-event called with a deallocated event!");
972 973
973 #ifndef MULE 974 #ifndef MULE
974 c &= 255; 975 c &= 255;
983 case 0: /* ignore top bit; it's parity */ 984 case 0: /* ignore top bit; it's parity */
984 c -= 128; 985 c -= 128;
985 break; 986 break;
986 case 1: /* top bit is meta */ 987 case 1: /* top bit is meta */
987 c -= 128; 988 c -= 128;
988 m = XEMACS_MOD_META; 989 m = MOD_META;
989 break; 990 break;
990 default: /* this is a real character */ 991 default: /* this is a real character */
991 break; 992 break;
992 } 993 }
993 } 994 }
994 if (c < ' ') c += '@', m |= XEMACS_MOD_CONTROL; 995 if (c < ' ') c += '@', m |= MOD_CONTROL;
995 if (m & XEMACS_MOD_CONTROL) 996 if (m & MOD_CONTROL)
996 { 997 {
997 switch (c) 998 switch (c)
998 { 999 {
999 case 'I': k = QKtab; m &= ~XEMACS_MOD_CONTROL; break; 1000 case 'I': k = QKtab; m &= ~MOD_CONTROL; break;
1000 case 'J': k = QKlinefeed; m &= ~XEMACS_MOD_CONTROL; break; 1001 case 'J': k = QKlinefeed; m &= ~MOD_CONTROL; break;
1001 case 'M': k = QKreturn; m &= ~XEMACS_MOD_CONTROL; break; 1002 case 'M': k = QKreturn; m &= ~MOD_CONTROL; break;
1002 case '[': k = QKescape; m &= ~XEMACS_MOD_CONTROL; break; 1003 case '[': k = QKescape; m &= ~MOD_CONTROL; break;
1003 default: 1004 default:
1004 #if defined(HAVE_TTY) 1005 #if defined(HAVE_TTY)
1005 if (do_backspace_mapping && 1006 if (do_backspace_mapping &&
1006 CHARP (con->tty_erase_char) && 1007 CHARP (con->tty_erase_char) &&
1007 c - '@' == XCHAR (con->tty_erase_char)) 1008 c - '@' == XCHAR (con->tty_erase_char))
1008 { 1009 {
1009 k = QKbackspace; 1010 k = QKbackspace;
1010 m &= ~XEMACS_MOD_CONTROL; 1011 m &= ~MOD_CONTROL;
1011 } 1012 }
1012 #endif /* defined(HAVE_TTY) && !defined(CYGWIN) */ 1013 #endif /* defined(HAVE_TTY) && !defined(__CYGWIN32__) */
1013 break; 1014 break;
1014 } 1015 }
1015 if (c >= 'A' && c <= 'Z') c -= 'A'-'a'; 1016 if (c >= 'A' && c <= 'Z') c -= 'A'-'a';
1016 } 1017 }
1017 #if defined(HAVE_TTY) 1018 #if defined(HAVE_TTY)
1018 else if (do_backspace_mapping && 1019 else if (do_backspace_mapping &&
1019 CHARP (con->tty_erase_char) && c == XCHAR (con->tty_erase_char)) 1020 CHARP (con->tty_erase_char) && c == XCHAR (con->tty_erase_char))
1020 k = QKbackspace; 1021 k = QKbackspace;
1021 #endif /* defined(HAVE_TTY) && !defined(CYGWIN) */ 1022 #endif /* defined(HAVE_TTY) && !defined(__CYGWIN32__) */
1022 else if (c == 127) 1023 else if (c == 127)
1023 k = QKdelete; 1024 k = QKdelete;
1024 else if (c == ' ') 1025 else if (c == ' ')
1025 k = QKspace; 1026 k = QKspace;
1026 1027
1029 event->channel = make_console (con); 1030 event->channel = make_console (con);
1030 event->event.key.keysym = (!NILP (k) ? k : make_char (c)); 1031 event->event.key.keysym = (!NILP (k) ? k : make_char (c));
1031 event->event.key.modifiers = m; 1032 event->event.key.modifiers = m;
1032 } 1033 }
1033 1034
1035
1034 /* This variable controls what character name -> character code mapping 1036 /* This variable controls what character name -> character code mapping
1035 we are using. Window-system-specific code sets this to some symbol, 1037 we are using. Window-system-specific code sets this to some symbol,
1036 and we use that symbol as the plist key to convert keysyms into 8-bit 1038 and we use that symbol as the plist key to convert keysyms into 8-bit
1037 codes. In this way one can have several character sets predefined and 1039 codes. In this way one can have several character sets predefined and
1038 switch them by changing this. 1040 switch them by changing this.
1039
1040 #### This is utterly bogus and should be removed.
1041 */ 1041 */
1042 Lisp_Object Vcharacter_set_property; 1042 Lisp_Object Vcharacter_set_property;
1043 1043
1044 Emchar 1044 Emchar
1045 event_to_character (Lisp_Event *event, 1045 event_to_character (struct Lisp_Event *event,
1046 int allow_extra_modifiers, 1046 int allow_extra_modifiers,
1047 int allow_meta, 1047 int allow_meta,
1048 int allow_non_ascii) 1048 int allow_non_ascii)
1049 { 1049 {
1050 Emchar c = 0; 1050 Emchar c = 0;
1051 Lisp_Object code; 1051 Lisp_Object code;
1052 1052
1053 if (event->event_type != key_press_event) 1053 if (event->event_type != key_press_event)
1054 { 1054 {
1055 assert (event->event_type != dead_event); 1055 if (event->event_type == dead_event) abort ();
1056 return -1; 1056 return -1;
1057 } 1057 }
1058 if (!allow_extra_modifiers && 1058 if (!allow_extra_modifiers &&
1059 event->event.key.modifiers & (XEMACS_MOD_SUPER|XEMACS_MOD_HYPER|XEMACS_MOD_ALT)) 1059 event->event.key.modifiers & (MOD_SUPER|MOD_HYPER|MOD_ALT))
1060 return -1; 1060 return -1;
1061 if (CHAR_OR_CHAR_INTP (event->event.key.keysym)) 1061 if (CHAR_OR_CHAR_INTP (event->event.key.keysym))
1062 c = XCHAR_OR_CHAR_INT (event->event.key.keysym); 1062 c = XCHAR_OR_CHAR_INT (event->event.key.keysym);
1063 else if (!SYMBOLP (event->event.key.keysym)) 1063 else if (!SYMBOLP (event->event.key.keysym))
1064 abort (); 1064 abort ();
1073 Qascii_character, Qnil))) 1073 Qascii_character, Qnil)))
1074 c = XCHAR_OR_CHAR_INT (code); 1074 c = XCHAR_OR_CHAR_INT (code);
1075 else 1075 else
1076 return -1; 1076 return -1;
1077 1077
1078 if (event->event.key.modifiers & XEMACS_MOD_CONTROL) 1078 if (event->event.key.modifiers & MOD_CONTROL)
1079 { 1079 {
1080 if (c >= 'a' && c <= 'z') 1080 if (c >= 'a' && c <= 'z')
1081 c -= ('a' - 'A'); 1081 c -= ('a' - 'A');
1082 else 1082 else
1083 /* reject Control-Shift- keys */ 1083 /* reject Control-Shift- keys */
1091 else 1091 else
1092 /* reject keys that can't take Control- modifiers */ 1092 /* reject keys that can't take Control- modifiers */
1093 if (! allow_extra_modifiers) return -1; 1093 if (! allow_extra_modifiers) return -1;
1094 } 1094 }
1095 1095
1096 if (event->event.key.modifiers & XEMACS_MOD_META) 1096 if (event->event.key.modifiers & MOD_META)
1097 { 1097 {
1098 if (! allow_meta) return -1; 1098 if (! allow_meta) return -1;
1099 if (c & 0200) return -1; /* don't allow M-oslash (overlap) */ 1099 if (c & 0200) return -1; /* don't allow M-oslash (overlap) */
1100 #ifdef MULE 1100 #ifdef MULE
1101 if (c >= 256) return -1; 1101 if (c >= 256) return -1;
1217 1217
1218 return head; 1218 return head;
1219 } 1219 }
1220 1220
1221 void 1221 void
1222 format_event_object (char *buf, Lisp_Event *event, int brief) 1222 format_event_object (char *buf, struct Lisp_Event *event, int brief)
1223 { 1223 {
1224 int mouse_p = 0; 1224 int mouse_p = 0;
1225 int mod = 0; 1225 int mod = 0;
1226 Lisp_Object key; 1226 Lisp_Object key;
1227 1227
1231 { 1231 {
1232 mod = event->event.key.modifiers; 1232 mod = event->event.key.modifiers;
1233 key = event->event.key.keysym; 1233 key = event->event.key.keysym;
1234 /* Hack. */ 1234 /* Hack. */
1235 if (! brief && CHARP (key) && 1235 if (! brief && CHARP (key) &&
1236 mod & (XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER)) 1236 mod & (MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER))
1237 { 1237 {
1238 int k = XCHAR (key); 1238 int k = XCHAR (key);
1239 if (k >= 'a' && k <= 'z') 1239 if (k >= 'a' && k <= 'z')
1240 key = make_char (k - ('a' - 'A')); 1240 key = make_char (k - ('a' - 'A'));
1241 else if (k >= 'A' && k <= 'Z') 1241 else if (k >= 'A' && k <= 'Z')
1242 mod |= XEMACS_MOD_SHIFT; 1242 mod |= MOD_SHIFT;
1243 } 1243 }
1244 break; 1244 break;
1245 } 1245 }
1246 case button_release_event: 1246 case button_release_event:
1247 mouse_p++; 1247 mouse_p++;
1253 key = make_char (event->event.button.button + '0'); 1253 key = make_char (event->event.button.button + '0');
1254 break; 1254 break;
1255 } 1255 }
1256 case magic_event: 1256 case magic_event:
1257 { 1257 {
1258 const char *name = NULL; 1258 CONST char *name = NULL;
1259 1259
1260 #ifdef HAVE_X_WINDOWS 1260 #ifdef HAVE_X_WINDOWS
1261 { 1261 {
1262 Lisp_Object console = CDFW_CONSOLE (EVENT_CHANNEL (event)); 1262 Lisp_Object console = CDFW_CONSOLE (EVENT_CHANNEL (event));
1263 if (CONSOLE_X_P (XCONSOLE (console))) 1263 if (CONSOLE_X_P (XCONSOLE (console)))
1279 default: 1279 default:
1280 abort (); 1280 abort ();
1281 } 1281 }
1282 #define modprint1(x) do { strcpy (buf, (x)); buf += sizeof (x)-1; } while (0) 1282 #define modprint1(x) do { strcpy (buf, (x)); buf += sizeof (x)-1; } while (0)
1283 #define modprint(x,y) do { if (brief) modprint1 (y); else modprint1 (x); } while (0) 1283 #define modprint(x,y) do { if (brief) modprint1 (y); else modprint1 (x); } while (0)
1284 if (mod & XEMACS_MOD_CONTROL) modprint ("control-", "C-"); 1284 if (mod & MOD_CONTROL) modprint ("control-", "C-");
1285 if (mod & XEMACS_MOD_META) modprint ("meta-", "M-"); 1285 if (mod & MOD_META) modprint ("meta-", "M-");
1286 if (mod & XEMACS_MOD_SUPER) modprint ("super-", "S-"); 1286 if (mod & MOD_SUPER) modprint ("super-", "S-");
1287 if (mod & XEMACS_MOD_HYPER) modprint ("hyper-", "H-"); 1287 if (mod & MOD_HYPER) modprint ("hyper-", "H-");
1288 if (mod & XEMACS_MOD_ALT) modprint ("alt-", "A-"); 1288 if (mod & MOD_ALT) modprint ("alt-", "A-");
1289 if (mod & XEMACS_MOD_SHIFT) modprint ("shift-", "Sh-"); 1289 if (mod & MOD_SHIFT) modprint ("shift-", "Sh-");
1290 if (mouse_p) 1290 if (mouse_p)
1291 { 1291 {
1292 modprint1 ("button"); 1292 modprint1 ("button");
1293 --mouse_p; 1293 --mouse_p;
1294 } 1294 }
1301 buf += set_charptr_emchar ((Bufbyte *) buf, XCHAR (key)); 1301 buf += set_charptr_emchar ((Bufbyte *) buf, XCHAR (key));
1302 *buf = 0; 1302 *buf = 0;
1303 } 1303 }
1304 else if (SYMBOLP (key)) 1304 else if (SYMBOLP (key))
1305 { 1305 {
1306 const char *str = 0; 1306 CONST char *str = 0;
1307 if (brief) 1307 if (brief)
1308 { 1308 {
1309 if (EQ (key, QKlinefeed)) str = "LFD"; 1309 if (EQ (key, QKlinefeed)) str = "LFD";
1310 else if (EQ (key, QKtab)) str = "TAB"; 1310 else if (EQ (key, QKtab)) str = "TAB";
1311 else if (EQ (key, QKreturn)) str = "RET"; 1311 else if (EQ (key, QKreturn)) str = "RET";
1320 memcpy (buf, str, i+1); 1320 memcpy (buf, str, i+1);
1321 str += i; 1321 str += i;
1322 } 1322 }
1323 else 1323 else
1324 { 1324 {
1325 Lisp_String *name = XSYMBOL (key)->name; 1325 struct Lisp_String *name = XSYMBOL (key)->name;
1326 memcpy (buf, string_data (name), string_length (name) + 1); 1326 memcpy (buf, string_data (name), string_length (name) + 1);
1327 str += string_length (name); 1327 str += string_length (name);
1328 } 1328 }
1329 } 1329 }
1330 else 1330 else
1356 Return the event object's `next' event, or nil if it has none. 1356 Return the event object's `next' event, or nil if it has none.
1357 The `next-event' field is changed by calling `set-next-event'. 1357 The `next-event' field is changed by calling `set-next-event'.
1358 */ 1358 */
1359 (event)) 1359 (event))
1360 { 1360 {
1361 Lisp_Event *e; 1361 struct Lisp_Event *e;
1362 CHECK_LIVE_EVENT (event); 1362 CHECK_LIVE_EVENT (event);
1363 1363
1364 return XEVENT_NEXT (event); 1364 return XEVENT_NEXT (event);
1365 } 1365 }
1366 1366
1541 */ 1541 */
1542 (event)) 1542 (event))
1543 { 1543 {
1544 int mod = XINT (Fevent_modifier_bits (event)); 1544 int mod = XINT (Fevent_modifier_bits (event));
1545 Lisp_Object result = Qnil; 1545 Lisp_Object result = Qnil;
1546 if (mod & XEMACS_MOD_SHIFT) result = Fcons (Qshift, result); 1546 if (mod & MOD_SHIFT) result = Fcons (Qshift, result);
1547 if (mod & XEMACS_MOD_ALT) result = Fcons (Qalt, result); 1547 if (mod & MOD_ALT) result = Fcons (Qalt, result);
1548 if (mod & XEMACS_MOD_HYPER) result = Fcons (Qhyper, result); 1548 if (mod & MOD_HYPER) result = Fcons (Qhyper, result);
1549 if (mod & XEMACS_MOD_SUPER) result = Fcons (Qsuper, result); 1549 if (mod & MOD_SUPER) result = Fcons (Qsuper, result);
1550 if (mod & XEMACS_MOD_META) result = Fcons (Qmeta, result); 1550 if (mod & MOD_META) result = Fcons (Qmeta, result);
1551 if (mod & XEMACS_MOD_CONTROL) result = Fcons (Qcontrol, result); 1551 if (mod & MOD_CONTROL) result = Fcons (Qcontrol, result);
1552 return result; 1552 return result;
1553 } 1553 }
1554 1554
1555 static int 1555 static int
1556 event_x_y_pixel_internal (Lisp_Object event, int *x, int *y, int relative) 1556 event_x_y_pixel_internal (Lisp_Object event, int *x, int *y, int relative)
2096 This is in the form of a property list (alternating keyword/value pairs). 2096 This is in the form of a property list (alternating keyword/value pairs).
2097 */ 2097 */
2098 (event)) 2098 (event))
2099 { 2099 {
2100 Lisp_Object props = Qnil; 2100 Lisp_Object props = Qnil;
2101 Lisp_Event *e; 2101 struct Lisp_Event *e;
2102 struct gcpro gcpro1; 2102 struct gcpro gcpro1;
2103 2103
2104 CHECK_LIVE_EVENT (event); 2104 CHECK_LIVE_EVENT (event);
2105 e = XEVENT (event); 2105 e = XEVENT (event);
2106 GCPRO1 (props); 2106 GCPRO1 (props);
2175 /************************************************************************/ 2175 /************************************************************************/
2176 2176
2177 void 2177 void
2178 syms_of_events (void) 2178 syms_of_events (void)
2179 { 2179 {
2180 INIT_LRECORD_IMPLEMENTATION (event);
2181
2182 DEFSUBR (Fcharacter_to_event); 2180 DEFSUBR (Fcharacter_to_event);
2183 DEFSUBR (Fevent_to_character); 2181 DEFSUBR (Fevent_to_character);
2184 2182
2185 DEFSUBR (Fmake_event); 2183 DEFSUBR (Fmake_event);
2186 DEFSUBR (Fdeallocate_event); 2184 DEFSUBR (Fdeallocate_event);
2229 defsymbol (&Qkey_press, "key-press"); 2227 defsymbol (&Qkey_press, "key-press");
2230 defsymbol (&Qbutton_press, "button-press"); 2228 defsymbol (&Qbutton_press, "button-press");
2231 defsymbol (&Qbutton_release, "button-release"); 2229 defsymbol (&Qbutton_release, "button-release");
2232 defsymbol (&Qmisc_user, "misc-user"); 2230 defsymbol (&Qmisc_user, "misc-user");
2233 defsymbol (&Qascii_character, "ascii-character"); 2231 defsymbol (&Qascii_character, "ascii-character");
2234
2235 defsymbol (&QKbackspace, "backspace");
2236 defsymbol (&QKtab, "tab");
2237 defsymbol (&QKlinefeed, "linefeed");
2238 defsymbol (&QKreturn, "return");
2239 defsymbol (&QKescape, "escape");
2240 defsymbol (&QKspace, "space");
2241 defsymbol (&QKdelete, "delete");
2242 }
2243
2244
2245 void
2246 reinit_vars_of_events (void)
2247 {
2248 Vevent_resource = Qnil;
2249 } 2232 }
2250 2233
2251 void 2234 void
2252 vars_of_events (void) 2235 vars_of_events (void)
2253 { 2236 {
2254 reinit_vars_of_events ();
2255
2256 DEFVAR_LISP ("character-set-property", &Vcharacter_set_property /* 2237 DEFVAR_LISP ("character-set-property", &Vcharacter_set_property /*
2257 A symbol used to look up the 8-bit character of a keysym. 2238 A symbol used to look up the 8-bit character of a keysym.
2258 To convert a keysym symbol to an 8-bit code, as when that key is 2239 To convert a keysym symbol to an 8-bit code, as when that key is
2259 bound to self-insert-command, we will look up the property that this 2240 bound to self-insert-command, we will look up the property that this
2260 variable names on the property list of the keysym-symbol. The window- 2241 variable names on the property list of the keysym-symbol. The window-
2261 system-specific code will set up appropriate properties and set this 2242 system-specific code will set up appropriate properties and set this
2262 variable. 2243 variable.
2263 */ ); 2244 */ );
2264 Vcharacter_set_property = Qnil; 2245 Vcharacter_set_property = Qnil;
2265 } 2246
2247 Vevent_resource = Qnil;
2248
2249 QKbackspace = KEYSYM ("backspace");
2250 QKtab = KEYSYM ("tab");
2251 QKlinefeed = KEYSYM ("linefeed");
2252 QKreturn = KEYSYM ("return");
2253 QKescape = KEYSYM ("escape");
2254 QKspace = KEYSYM ("space");
2255 QKdelete = KEYSYM ("delete");
2256
2257 staticpro (&QKbackspace);
2258 staticpro (&QKtab);
2259 staticpro (&QKlinefeed);
2260 staticpro (&QKreturn);
2261 staticpro (&QKescape);
2262 staticpro (&QKspace);
2263 staticpro (&QKdelete);
2264 }