X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fevents.c;h=325be1e0425ccfd06bd01997775603e23d51cddc;hb=2cbece6401b2279497293e6dc54cda607f49db2f;hp=6fe8e6e7e55fc92e6f26820d20e7b7a8dfdc2476;hpb=77dcef404dc78635f6ffa8f71a803d2bc7cc8921;p=chise%2Fxemacs-chise.git- diff --git a/src/events.c b/src/events.c index 6fe8e6e..325be1e 100644 --- a/src/events.c +++ b/src/events.c @@ -37,17 +37,6 @@ Boston, MA 02111-1307, USA. */ #include "keymap.h" /* for key_desc_list_to_event() */ #include "redisplay.h" #include "window.h" - -#ifdef WINDOWSNT -/* Hmm, under unix we want X modifiers, under NT we want X modifiers if - we are running X and Windows modifiers otherwise. - gak. This is a kludge until we support multiple native GUIs! -*/ -#undef MOD_ALT -#undef MOD_CONTROL -#undef MOD_SHIFT -#endif - #include "events-mod.h" /* Where old events go when they are explicitly deallocated. @@ -81,51 +70,51 @@ static void deinitialize_event (Lisp_Object ev) { int i; - struct Lisp_Event *event = XEVENT (ev); + Lisp_Event *event = XEVENT (ev); - for (i = 0; i < (int) (sizeof (struct Lisp_Event) / sizeof (int)); i++) + for (i = 0; i < (int) (sizeof (Lisp_Event) / sizeof (int)); i++) ((int *) event) [i] = 0xdeadbeef; event->event_type = dead_event; event->channel = Qnil; - set_lheader_implementation (&(event->lheader), lrecord_event); + set_lheader_implementation (&event->lheader, &lrecord_event); XSET_EVENT_NEXT (ev, Qnil); } /* Set everything to zero or nil so that it's predictable. */ void -zero_event (struct Lisp_Event *e) +zero_event (Lisp_Event *e) { xzero (*e); - set_lheader_implementation (&(e->lheader), lrecord_event); + set_lheader_implementation (&e->lheader, &lrecord_event); e->event_type = empty_event; e->next = Qnil; e->channel = Qnil; } static Lisp_Object -mark_event (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_event (Lisp_Object obj) { - struct Lisp_Event *event = XEVENT (obj); + Lisp_Event *event = XEVENT (obj); switch (event->event_type) { case key_press_event: - markobj (event->event.key.keysym); + mark_object (event->event.key.keysym); break; case process_event: - markobj (event->event.process.process); + mark_object (event->event.process.process); break; case timeout_event: - markobj (event->event.timeout.function); - markobj (event->event.timeout.object); + mark_object (event->event.timeout.function); + mark_object (event->event.timeout.object); break; case eval_event: case misc_user_event: - markobj (event->event.eval.function); - markobj (event->event.eval.object); + mark_object (event->event.eval.function); + mark_object (event->event.eval.object); break; case magic_eval_event: - markobj (event->event.magic_eval.object); + mark_object (event->event.magic_eval.object); break; case button_press_event: case button_release_event: @@ -137,12 +126,12 @@ mark_event (Lisp_Object obj, void (*markobj) (Lisp_Object)) default: abort (); } - markobj (event->channel); + mark_object (event->channel); return event->next; } static void -print_event_1 (CONST char *str, Lisp_Object obj, Lisp_Object printcharfun) +print_event_1 (const char *str, Lisp_Object obj, Lisp_Object printcharfun) { char buf[255]; write_c_string (str, printcharfun); @@ -179,7 +168,7 @@ print_event (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) assert (INTP (Vx)); Vy = Fevent_y_pixel (obj); assert (INTP (Vy)); - sprintf (buf, "#event_type != e2->event_type) return 0; if (!EQ (e1->channel, e2->channel)) return 0; @@ -293,8 +282,9 @@ event_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) if (CONSOLE_MSWINDOWS_P (con)) return (!memcmp(&e1->event.magic.underlying_mswindows_event, &e2->event.magic.underlying_mswindows_event, - sizeof(union magic_data))); + sizeof (union magic_data))); #endif + abort (); return 1; /* not reached */ } @@ -307,7 +297,7 @@ event_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) static unsigned long event_hash (Lisp_Object obj, int depth) { - struct Lisp_Event *e = XEVENT (obj); + Lisp_Event *e = XEVENT (obj); unsigned long hash; hash = HASH2 (e->event_type, LISP_HASH (e->channel)); @@ -360,6 +350,8 @@ event_hash (Lisp_Object obj, int depth) if (CONSOLE_MSWINDOWS_P (con)) return HASH2 (hash, e->event.magic.underlying_mswindows_event); #endif + abort (); + return 0; } case empty_event: @@ -375,7 +367,7 @@ event_hash (Lisp_Object obj, int depth) DEFINE_BASIC_LRECORD_IMPLEMENTATION ("event", event, mark_event, print_event, 0, event_equal, - event_hash, struct Lisp_Event); + event_hash, 0, Lisp_Event); DEFUN ("make-event", Fmake_event, 0, 2, 0, /* @@ -428,7 +420,7 @@ WARNING: the event object returned may be a reused one; see the function { Lisp_Object tail, keyword, value; Lisp_Object event = Qnil; - struct Lisp_Event *e; + Lisp_Event *e; EMACS_INT coord_x = 0, coord_y = 0; struct gcpro gcpro1; @@ -548,13 +540,13 @@ WARNING: the event object returned may be a reused one; see the function EXTERNAL_LIST_LOOP_2 (sym, value) { - if (EQ (sym, Qcontrol)) modifiers |= MOD_CONTROL; - else if (EQ (sym, Qmeta)) modifiers |= MOD_META; - else if (EQ (sym, Qsuper)) modifiers |= MOD_SUPER; - else if (EQ (sym, Qhyper)) modifiers |= MOD_HYPER; - else if (EQ (sym, Qalt)) modifiers |= MOD_ALT; - else if (EQ (sym, Qsymbol)) modifiers |= MOD_ALT; - else if (EQ (sym, Qshift)) modifiers |= MOD_SHIFT; + if (EQ (sym, Qcontrol)) modifiers |= XEMACS_MOD_CONTROL; + else if (EQ (sym, Qmeta)) modifiers |= XEMACS_MOD_META; + else if (EQ (sym, Qsuper)) modifiers |= XEMACS_MOD_SUPER; + else if (EQ (sym, Qhyper)) modifiers |= XEMACS_MOD_HYPER; + else if (EQ (sym, Qalt)) modifiers |= XEMACS_MOD_ALT; + else if (EQ (sym, Qsymbol)) modifiers |= XEMACS_MOD_ALT; + else if (EQ (sym, Qshift)) modifiers |= XEMACS_MOD_SHIFT; else signal_simple_error ("Invalid key modifier", sym); } @@ -763,7 +755,7 @@ DEFUN ("copy-event", Fcopy_event, 1, 2, 0, /* Make a copy of the given event object. If a second argument is given, the first event is copied into the second and the second is returned. If the second argument is not supplied (or -is nil) then a new event will be made as with `allocate-event.' See also +is nil) then a new event will be made as with `make-event'. See also the function `deallocate-event'. */ (event1, event2)) @@ -771,19 +763,26 @@ the function `deallocate-event'. CHECK_LIVE_EVENT (event1); if (NILP (event2)) event2 = Fmake_event (Qnil, Qnil); - else CHECK_LIVE_EVENT (event2); - if (EQ (event1, event2)) - return signal_simple_continuable_error_2 - ("copy-event called with `eq' events", event1, event2); + else + { + CHECK_LIVE_EVENT (event2); + if (EQ (event1, event2)) + return signal_simple_continuable_error_2 + ("copy-event called with `eq' events", event1, event2); + } assert (XEVENT_TYPE (event1) <= last_event_type); assert (XEVENT_TYPE (event2) <= last_event_type); { - Lisp_Object save_next = XEVENT_NEXT (event2); + Lisp_Event *ev2 = XEVENT (event2); + Lisp_Event *ev1 = XEVENT (event1); + + ev2->event_type = ev1->event_type; + ev2->channel = ev1->channel; + ev2->timestamp = ev1->timestamp; + ev2->event = ev1->event; - *XEVENT (event2) = *XEVENT (event1); - XSET_EVENT_NEXT (event2, save_next); return event2; } } @@ -963,11 +962,11 @@ command_event_p (Lisp_Object event) void -character_to_event (Emchar c, struct Lisp_Event *event, struct console *con, +character_to_event (Emchar c, Lisp_Event *event, struct console *con, int use_console_meta_flag, int do_backspace_mapping) { Lisp_Object k = Qnil; - unsigned int m = 0; + int m = 0; if (event->event_type == dead_event) error ("character-to-event called with a deallocated event!"); @@ -986,21 +985,21 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con, break; case 1: /* top bit is meta */ c -= 128; - m = MOD_META; + m = XEMACS_MOD_META; break; default: /* this is a real character */ break; } } - if (c < ' ') c += '@', m |= MOD_CONTROL; - if (m & MOD_CONTROL) + if (c < ' ') c += '@', m |= XEMACS_MOD_CONTROL; + if (m & XEMACS_MOD_CONTROL) { switch (c) { - case 'I': k = QKtab; m &= ~MOD_CONTROL; break; - case 'J': k = QKlinefeed; m &= ~MOD_CONTROL; break; - case 'M': k = QKreturn; m &= ~MOD_CONTROL; break; - case '[': k = QKescape; m &= ~MOD_CONTROL; break; + case 'I': k = QKtab; m &= ~XEMACS_MOD_CONTROL; break; + case 'J': k = QKlinefeed; m &= ~XEMACS_MOD_CONTROL; break; + case 'M': k = QKreturn; m &= ~XEMACS_MOD_CONTROL; break; + case '[': k = QKescape; m &= ~XEMACS_MOD_CONTROL; break; default: #if defined(HAVE_TTY) if (do_backspace_mapping && @@ -1008,7 +1007,7 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con, c - '@' == XCHAR (con->tty_erase_char)) { k = QKbackspace; - m &= ~MOD_CONTROL; + m &= ~XEMACS_MOD_CONTROL; } #endif /* defined(HAVE_TTY) && !defined(__CYGWIN32__) */ break; @@ -1032,17 +1031,18 @@ character_to_event (Emchar c, struct Lisp_Event *event, struct console *con, event->event.key.modifiers = m; } - /* This variable controls what character name -> character code mapping we are using. Window-system-specific code sets this to some symbol, and we use that symbol as the plist key to convert keysyms into 8-bit codes. In this way one can have several character sets predefined and switch them by changing this. + + #### This is utterly bogus and should be removed. */ Lisp_Object Vcharacter_set_property; Emchar -event_to_character (struct Lisp_Event *event, +event_to_character (Lisp_Event *event, int allow_extra_modifiers, int allow_meta, int allow_non_ascii) @@ -1052,11 +1052,11 @@ event_to_character (struct Lisp_Event *event, if (event->event_type != key_press_event) { - if (event->event_type == dead_event) abort (); + assert (event->event_type != dead_event); return -1; } if (!allow_extra_modifiers && - event->event.key.modifiers & (MOD_SUPER|MOD_HYPER|MOD_ALT)) + event->event.key.modifiers & (XEMACS_MOD_SUPER|XEMACS_MOD_HYPER|XEMACS_MOD_ALT)) return -1; if (CHAR_OR_CHAR_INTP (event->event.key.keysym)) c = XCHAR_OR_CHAR_INT (event->event.key.keysym); @@ -1075,7 +1075,7 @@ event_to_character (struct Lisp_Event *event, else return -1; - if (event->event.key.modifiers & MOD_CONTROL) + if (event->event.key.modifiers & XEMACS_MOD_CONTROL) { if (c >= 'a' && c <= 'z') c -= ('a' - 'A'); @@ -1093,7 +1093,7 @@ event_to_character (struct Lisp_Event *event, if (! allow_extra_modifiers) return -1; } - if (event->event.key.modifiers & MOD_META) + if (event->event.key.modifiers & XEMACS_MOD_META) { if (! allow_meta) return -1; if (c & 0200) return -1; /* don't allow M-oslash (overlap) */ @@ -1219,7 +1219,7 @@ key_sequence_to_event_chain (Lisp_Object seq) } void -format_event_object (char *buf, struct Lisp_Event *event, int brief) +format_event_object (char *buf, Lisp_Event *event, int brief) { int mouse_p = 0; int mod = 0; @@ -1233,13 +1233,13 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief) key = event->event.key.keysym; /* Hack. */ if (! brief && CHARP (key) && - mod & (MOD_CONTROL | MOD_META | MOD_SUPER | MOD_HYPER)) + mod & (XEMACS_MOD_CONTROL | XEMACS_MOD_META | XEMACS_MOD_SUPER | XEMACS_MOD_HYPER)) { int k = XCHAR (key); if (k >= 'a' && k <= 'z') key = make_char (k - ('a' - 'A')); else if (k >= 'A' && k <= 'Z') - mod |= MOD_SHIFT; + mod |= XEMACS_MOD_SHIFT; } break; } @@ -1255,7 +1255,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief) } case magic_event: { - CONST char *name = NULL; + const char *name = NULL; #ifdef HAVE_X_WINDOWS { @@ -1281,12 +1281,12 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief) } #define modprint1(x) do { strcpy (buf, (x)); buf += sizeof (x)-1; } while (0) #define modprint(x,y) do { if (brief) modprint1 (y); else modprint1 (x); } while (0) - if (mod & MOD_CONTROL) modprint ("control-", "C-"); - if (mod & MOD_META) modprint ("meta-", "M-"); - if (mod & MOD_SUPER) modprint ("super-", "S-"); - if (mod & MOD_HYPER) modprint ("hyper-", "H-"); - if (mod & MOD_ALT) modprint ("alt-", "A-"); - if (mod & MOD_SHIFT) modprint ("shift-", "Sh-"); + if (mod & XEMACS_MOD_CONTROL) modprint ("control-", "C-"); + if (mod & XEMACS_MOD_META) modprint ("meta-", "M-"); + if (mod & XEMACS_MOD_SUPER) modprint ("super-", "S-"); + if (mod & XEMACS_MOD_HYPER) modprint ("hyper-", "H-"); + if (mod & XEMACS_MOD_ALT) modprint ("alt-", "A-"); + if (mod & XEMACS_MOD_SHIFT) modprint ("shift-", "Sh-"); if (mouse_p) { modprint1 ("button"); @@ -1303,7 +1303,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief) } else if (SYMBOLP (key)) { - CONST char *str = 0; + const char *str = 0; if (brief) { if (EQ (key, QKlinefeed)) str = "LFD"; @@ -1322,7 +1322,7 @@ format_event_object (char *buf, struct Lisp_Event *event, int brief) } else { - struct Lisp_String *name = XSYMBOL (key)->name; + Lisp_String *name = XSYMBOL (key)->name; memcpy (buf, string_data (name), string_length (name) + 1); str += string_length (name); } @@ -1358,7 +1358,7 @@ The `next-event' field is changed by calling `set-next-event'. */ (event)) { - struct Lisp_Event *e; + Lisp_Event *e; CHECK_LIVE_EVENT (event); return XEVENT_NEXT (event); @@ -1455,22 +1455,28 @@ Return the timestamp of the event object EVENT. #define CHECK_EVENT_TYPE(e,t1,sym) do { \ CHECK_LIVE_EVENT (e); \ if (XEVENT(e)->event_type != (t1)) \ - e = wrong_type_argument ((sym),(e)); \ + e = wrong_type_argument (sym,e); \ } while (0) -#define CHECK_EVENT_TYPE2(e,t1,t2,sym) do { \ - CHECK_LIVE_EVENT (e); \ - if (XEVENT(e)->event_type != (t1) && \ - XEVENT(e)->event_type != (t2)) \ - e = wrong_type_argument ((sym),(e)); \ +#define CHECK_EVENT_TYPE2(e,t1,t2,sym) do { \ + CHECK_LIVE_EVENT (e); \ + { \ + emacs_event_type CET_type = XEVENT (e)->event_type; \ + if (CET_type != (t1) && \ + CET_type != (t2)) \ + e = wrong_type_argument (sym,e); \ + } \ } while (0) -#define CHECK_EVENT_TYPE3(e,t1,t2,t3,sym) do { \ - CHECK_LIVE_EVENT (e); \ - if (XEVENT(e)->event_type != (t1) && \ - XEVENT(e)->event_type != (t2) && \ - XEVENT(e)->event_type != (t3)) \ - e = wrong_type_argument ((sym),(e)); \ +#define CHECK_EVENT_TYPE3(e,t1,t2,t3,sym) do { \ + CHECK_LIVE_EVENT (e); \ + { \ + emacs_event_type CET_type = XEVENT (e)->event_type; \ + if (CET_type != (t1) && \ + CET_type != (t2) && \ + CET_type != (t3)) \ + e = wrong_type_argument (sym,e); \ + } \ } while (0) DEFUN ("event-key", Fevent_key, 1, 1, 0, /* @@ -1537,12 +1543,12 @@ See also the function event-modifier-bits. { int mod = XINT (Fevent_modifier_bits (event)); Lisp_Object result = Qnil; - if (mod & MOD_SHIFT) result = Fcons (Qshift, result); - if (mod & MOD_ALT) result = Fcons (Qalt, result); - if (mod & MOD_HYPER) result = Fcons (Qhyper, result); - if (mod & MOD_SUPER) result = Fcons (Qsuper, result); - if (mod & MOD_META) result = Fcons (Qmeta, result); - if (mod & MOD_CONTROL) result = Fcons (Qcontrol, result); + if (mod & XEMACS_MOD_SHIFT) result = Fcons (Qshift, result); + if (mod & XEMACS_MOD_ALT) result = Fcons (Qalt, result); + if (mod & XEMACS_MOD_HYPER) result = Fcons (Qhyper, result); + if (mod & XEMACS_MOD_SUPER) result = Fcons (Qsuper, result); + if (mod & XEMACS_MOD_META) result = Fcons (Qmeta, result); + if (mod & XEMACS_MOD_CONTROL) result = Fcons (Qcontrol, result); return result; } @@ -2092,7 +2098,7 @@ This is in the form of a property list (alternating keyword/value pairs). (event)) { Lisp_Object props = Qnil; - struct Lisp_Event *e; + Lisp_Event *e; struct gcpro gcpro1; CHECK_LIVE_EVENT (event); @@ -2171,6 +2177,8 @@ This is in the form of a property list (alternating keyword/value pairs). void syms_of_events (void) { + INIT_LRECORD_IMPLEMENTATION (event); + DEFSUBR (Fcharacter_to_event); DEFSUBR (Fevent_to_character); @@ -2223,11 +2231,28 @@ syms_of_events (void) defsymbol (&Qbutton_release, "button-release"); defsymbol (&Qmisc_user, "misc-user"); defsymbol (&Qascii_character, "ascii-character"); + + defsymbol (&QKbackspace, "backspace"); + defsymbol (&QKtab, "tab"); + defsymbol (&QKlinefeed, "linefeed"); + defsymbol (&QKreturn, "return"); + defsymbol (&QKescape, "escape"); + defsymbol (&QKspace, "space"); + defsymbol (&QKdelete, "delete"); +} + + +void +reinit_vars_of_events (void) +{ + Vevent_resource = Qnil; } void vars_of_events (void) { + reinit_vars_of_events (); + DEFVAR_LISP ("character-set-property", &Vcharacter_set_property /* A symbol used to look up the 8-bit character of a keysym. To convert a keysym symbol to an 8-bit code, as when that key is @@ -2237,22 +2262,4 @@ system-specific code will set up appropriate properties and set this variable. */ ); Vcharacter_set_property = Qnil; - - Vevent_resource = Qnil; - - QKbackspace = KEYSYM ("backspace"); - QKtab = KEYSYM ("tab"); - QKlinefeed = KEYSYM ("linefeed"); - QKreturn = KEYSYM ("return"); - QKescape = KEYSYM ("escape"); - QKspace = KEYSYM ("space"); - QKdelete = KEYSYM ("delete"); - - staticpro (&QKbackspace); - staticpro (&QKtab); - staticpro (&QKlinefeed); - staticpro (&QKreturn); - staticpro (&QKescape); - staticpro (&QKspace); - staticpro (&QKdelete); }