xemacs-beta: src/events.c comparison

comparison src/events.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	ac2d302a0011
children	131b0175ea99

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 event-properties) to allow creation of any type of event.
 This is useful, for example, in Lisp code that might want
 to determine if, for a given button-down event, what the
 binding for the corresponding button-up event is. */
-DEFUN ("make-event", Fmake_event, Smake_event, 0, 0, 0 /*
+DEFUN ("make-event", Fmake_event, 0, 0, 0, /*
 Create a new empty event.
 WARNING, the event object returned may be a reused one; see the function
 `deallocate-event'.
-*/ )
+*/
-()
+())
 {
 Lisp_Object event;
 if (!NILP (Vevent_resource))
 {
 }
 zero_event (XEVENT (event));
 return event;
 }
-DEFUN ("deallocate-event", Fdeallocate_event, Sdeallocate_event, 1, 1, 0 /*
+DEFUN ("deallocate-event", Fdeallocate_event, 1, 1, 0, /*
 Allow the given event structure to be reused.
 You MUST NOT use this event object after calling this function with it.
 You will lose.  It is not necessary to call this function, as event
 objects are garbage-collected like all other objects; however, it may
 be more efficient to explicitly deallocate events when you are sure
 that it is safe to do so.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_EVENT (event);
 if (XEVENT_TYPE (event) == dead_event)
 error ("this event is already deallocated!");
 Vevent_resource = event;
 #endif
 return Qnil;
 }
-DEFUN ("copy-event", Fcopy_event, Scopy_event, 1, 2, 0 /*
+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
 the function `deallocate-event'.
-*/ )
+*/
-(event1, event2)
+(event1, event2))
-Lisp_Object event1, event2;
 {
 CHECK_LIVE_EVENT (event1);
 if (NILP (event2))
 event2 = Fmake_event ();
 else CHECK_LIVE_EVENT (event2);
 unsigned int m = 0;
 if (event->event_type == dead_event)
 error ("character-to-event called with a deallocated event!");
 c &= 255;
 if (c > 127 && c <= 255)
 {
 int meta_flag = 1;
 if (use_console_meta_flag && CONSOLE_TTY_P (con))
 	meta_flag = TTY_FLAGS (con).meta_key;
 c |= 0200;
 }
 return c;
 }
+DEFUN ("event-to-character", Fevent_to_character, 1, 4, 0, /*
-DEFUN ("event-to-character", Fevent_to_character, Sevent_to_character,
-1, 4, 0 /*
 Return the closest ASCII approximation to the given event object.
 If the event isn't a keypress, this returns nil.
 If the ALLOW-EXTRA-MODIFIERS argument is non-nil, then this is lenient in
 its translation; it will ignore modifier keys other than control and meta,
 and will ignore the shift modifier on those characters which have no
 present in the prevailing character set (see the `character-set-property'
 variable) will be returned as their code in that character set, instead of
 the return value being restricted to ASCII.
 Note that specifying both ALLOW-META and ALLOW-NON-ASCII is ambiguous, as
 both use the high bit; `M-x' and `oslash' will be indistinguishable.
-*/ )
+*/
-(event, allow_extra_modifiers, allow_meta, allow_non_ascii)
+(event, allow_extra_modifiers, allow_meta, allow_non_ascii))
-Lisp_Object event, allow_extra_modifiers, allow_meta, allow_non_ascii;
 {
 Emchar c;
 CHECK_LIVE_EVENT (event);
 c = event_to_character (XEVENT (event),
 			  !NILP (allow_extra_modifiers),
 			  !NILP (allow_meta),
 			  !NILP (allow_non_ascii));
 return (c < 0 ? Qnil : make_char (c));
 }
-DEFUN ("character-to-event", Fcharacter_to_event, Scharacter_to_event,
+DEFUN ("character-to-event", Fcharacter_to_event, 1, 4, 0, /*
-1, 4, 0 /*
 Converts a keystroke specifier into an event structure, replete with
 bucky bits.  The keystroke is the first argument, and the event to fill
 in is the second.  This function contains knowledge about what the codes
 ``mean'' -- for example, the number 9 is converted to the character ``Tab'',
 not the distinct character ``Control-I''.
 in a list containing the character.
 Beware that character-to-event and event-to-character are not strictly
 inverse functions, since events contain much more information than the
 ASCII character set can encode.
-*/ )
+*/
-(ch, event, console, use_console_meta_flag)
+(ch, event, console, use_console_meta_flag))
-Lisp_Object ch, event, console, use_console_meta_flag;
 {
 struct console *con = decode_console (console);
 if (NILP (event))
 event = Fmake_event ();
 else
 abort ();
 if (mouse_p)
 strncpy (buf, "up", 4);
 }
-DEFUN ("eventp", Feventp, Seventp, 1, 1, 0 /*
+DEFUN ("eventp", Feventp, 1, 1, 0, /*
 True if OBJECT is an event object.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return ((EVENTP (object)) ? Qt : Qnil);
 }
-DEFUN ("event-live-p", Fevent_live_p, Sevent_live_p, 1, 1, 0 /*
+DEFUN ("event-live-p", Fevent_live_p, 1, 1, 0, /*
 True if OBJECT is an event object that has not been deallocated.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 return ((EVENTP (object) && XEVENT (object)->event_type != dead_event)
 	  ? Qt : Qnil);
 }
 return (next_event);
 }
 #endif /* 0 */
-DEFUN ("event-type", Fevent_type, Sevent_type, 1, 1, 0 /*
+DEFUN ("event-type", Fevent_type, 1, 1, 0, /*
 Return the type of EVENT.
 This will be a symbol; one of
 key-press	A key was pressed.
 button-press	A mouse button was pressed.
 motion		The mouse moved.
 process		Input is available from a subprocess.
 timeout		A timeout has expired.
 eval		This causes a specified action to occur when dispatched.
 magic		Some window-system-specific event has occurred.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_LIVE_EVENT (event);
 switch (XEVENT (event)->event_type)
 {
 case key_press_event:
 abort ();
 return Qnil;
 }
 }
-DEFUN ("event-timestamp", Fevent_timestamp, Sevent_timestamp, 1, 1, 0 /*
+DEFUN ("event-timestamp", Fevent_timestamp, 1, 1, 0, /*
 Return the timestamp of the given event object.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_LIVE_EVENT (event);
 /* This junk is so that timestamps don't get to be negative, but contain
 as many bits as this particular emacs will allow.
 */
 { CHECK_LIVE_EVENT (e);							\
 if (XEVENT(e)->event_type != (t1) && XEVENT(e)->event_type != (t2))	\
 e = wrong_type_argument ((sym),(e));				\
 }
-DEFUN ("event-key", Fevent_key, Sevent_key, 1, 1, 0 /*
+DEFUN ("event-key", Fevent_key, 1, 1, 0, /*
 Return the Keysym of the given key-press event.
 This will be the ASCII code of a printing character, or a symbol.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_EVENT_TYPE (event, key_press_event, Qkey_press_event_p);
 return (XEVENT (event)->event.key.keysym);
 }
-DEFUN ("event-button", Fevent_button, Sevent_button, 1, 1, 0 /*
+DEFUN ("event-button", Fevent_button, 1, 1, 0, /*
 Return the button-number of the given mouse-button-press event.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_EVENT_TYPE2 (event, button_press_event, button_release_event,
 		     Qbutton_event_p);
 #ifdef HAVE_WINDOW_SYSTEM
 return make_int (XEVENT (event)->event.button.button);
 #else /* !HAVE_WINDOW_SYSTEM */
 return Qzero;
 #endif /* !HAVE_WINDOW_SYSTEM */
 }
-DEFUN ("event-modifier-bits", Fevent_modifier_bits, Sevent_modifier_bits,
+DEFUN ("event-modifier-bits", Fevent_modifier_bits, 1, 1, 0, /*
-1, 1, 0 /*
 Return a number representing the modifier keys which were down
 when the given mouse or keyboard event was produced.  See also the function
 event-modifiers.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 again:
 CHECK_LIVE_EVENT (event);
 if (XEVENT (event)->event_type == key_press_event)
 return make_int (XEVENT (event)->event.key.modifiers);
 event = wrong_type_argument (intern ("key-or-mouse-event-p"), event);
 goto again;
 }
 }
-DEFUN ("event-modifiers", Fevent_modifiers, Sevent_modifiers, 1, 1, 0 /*
+DEFUN ("event-modifiers", Fevent_modifiers, 1, 1, 0, /*
 Return a list of symbols, the names of the modifier keys
 which were down when the given mouse or keyboard event was produced.
 See also the function event-modifier-bits.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 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);
 }
 return 1;
 }
-DEFUN ("event-window-x-pixel", Fevent_window_x_pixel, Sevent_window_x_pixel,
+DEFUN ("event-window-x-pixel", Fevent_window_x_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the X position in pixels of the given mouse event.
 The value returned is relative to the window the event occurred in.
 This will signal an error if the event is not a mouse-motion, button-press,
 or button-release event.  See also `event-x-pixel'.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int x, y;
 CHECK_LIVE_EVENT (event);
 return wrong_type_argument (Qmouse_event_p, event);
 else
 return make_int (x);
 }
-DEFUN ("event-window-y-pixel", Fevent_window_y_pixel, Sevent_window_y_pixel,
+DEFUN ("event-window-y-pixel", Fevent_window_y_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the Y position in pixels of the given mouse event.
 The value returned is relative to the window the event occurred in.
 This will signal an error if the event is not a mouse-motion, button-press,
 or button-release event.  See also `event-y-pixel'.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int x, y;
 CHECK_LIVE_EVENT (event);
 return wrong_type_argument (Qmouse_event_p, event);
 else
 return make_int (y);
 }
-DEFUN ("event-x-pixel", Fevent_x_pixel, Sevent_x_pixel,
+DEFUN ("event-x-pixel", Fevent_x_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the X position in pixels of the given mouse event.
 The value returned is relative to the frame the event occurred in.
 This will signal an error if the event is not a mouse-motion, button-press,
 or button-release event.  See also `event-window-x-pixel'.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int x, y;
 CHECK_LIVE_EVENT (event);
 return wrong_type_argument (Qmouse_event_p, event);
 else
 return make_int (x);
 }
-DEFUN ("event-y-pixel", Fevent_y_pixel, Sevent_y_pixel,
+DEFUN ("event-y-pixel", Fevent_y_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the Y position in pixels of the given mouse event.
 The value returned is relative to the frame the event occurred in.
 This will signal an error if the event is not a mouse-motion, button-press,
 or button-release event.  See also `event-window-y-pixel'.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int x, y;
 CHECK_LIVE_EVENT (event);
 *obj2 = ret_obj2;
 return result;
 }
-DEFUN ("event-over-text-area-p", Fevent_over_text_area_p,
+DEFUN ("event-over-text-area-p", Fevent_over_text_area_p, 1, 1, 0, /*
-Sevent_over_text_area_p, 1, 1, 0 /*
 Return whether the given mouse event occurred over the text area of a window.
 The modeline is not considered to be part of the text area.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int result = event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 if (result == OVER_TEXT || result == OVER_NOTHING)
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("event-over-modeline-p", Fevent_over_modeline_p, Sevent_over_modeline_p,
+DEFUN ("event-over-modeline-p", Fevent_over_modeline_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return whether the given mouse event occurred over the modeline of a window.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int result = event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 if (result == OVER_MODELINE)
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("event-over-border-p", Fevent_over_border_p, Sevent_over_border_p,
+DEFUN ("event-over-border-p", Fevent_over_border_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return whether the given mouse event occurred over an internal border.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int result = event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 if (result == OVER_BORDER)
 return Qt;
 else
 return Qnil;
 }
-DEFUN ("event-over-toolbar-p", Fevent_over_toolbar_p, Sevent_over_toolbar_p,
+DEFUN ("event-over-toolbar-p", Fevent_over_toolbar_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return whether the given mouse event occurred over a toolbar.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int result = event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 if (result == OVER_TOOLBAR)
 return Qt;
 console = Vselected_console;
 return XCONSOLE (console);
 }
-DEFUN ("event-channel", Fevent_channel, Sevent_channel, 1, 1, 0 /*
+DEFUN ("event-channel", Fevent_channel, 1, 1, 0, /*
 Return the channel that the given event occurred on.
 This will be a frame, device, console, or nil for some types
 of events (e.g. eval events).
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_LIVE_EVENT (event);
 return EVENT_CHANNEL (XEVENT (event));
 }
-DEFUN ("event-window", Fevent_window, Sevent_window, 1, 1, 0 /*
+DEFUN ("event-window", Fevent_window, 1, 1, 0, /*
 Return the window of the given mouse event.
 This may be nil if the event occurred in the border or over a toolbar.
 The modeline is considered to be in the window it represents.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 struct window *w;
 Lisp_Object window;
 event_pixel_translation (event, 0, 0, 0, 0, &w, 0, 0, 0, 0, 0);
 XSETWINDOW (window, w);
 return window;
 }
 }
-DEFUN ("event-point", Fevent_point, Sevent_point, 1, 1, 0 /*
+DEFUN ("event-point", Fevent_point, 1, 1, 0, /*
 Return the character position of the given mouse event.
 If the event did not occur over a window, or did not occur over text,
 then this returns nil.  Otherwise, it returns an index into the buffer
 visible in the event's window.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Bufpos bufp;
 struct window *w;
 event_pixel_translation (event, 0, 0, 0, 0, &w, &bufp, 0, 0, 0, 0);
 return Qnil;
 else
 return make_int (bufp);
 }
-DEFUN ("event-closest-point", Fevent_closest_point, Sevent_closest_point,
+DEFUN ("event-closest-point", Fevent_closest_point, 1, 1, 0, /*
-1, 1, 0 /*
 Return the character position of the given mouse event.
 If the event did not occur over a window or over text, return the
 closest point to the location of the event.  If the Y pixel position
 overlaps a window and the X pixel position is to the left of that
 window, the closest point is the beginning of the line containing the
 Y position.  If the Y pixel position overlaps a window and the X pixel
 position is to the right of that window, the closest point is the end
 of the line containing the Y position.  If the Y pixel position is
 above a window, return 0.  If it is below a window, return the value
 of (window-end).
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Bufpos bufp;
 event_pixel_translation (event, 0, 0, 0, 0, 0, 0, &bufp, 0, 0, 0);
 return Qnil;
 else
 return make_int (bufp);
 }
-DEFUN ("event-x", Fevent_x, Sevent_x, 1, 1, 0 /*
+DEFUN ("event-x", Fevent_x, 1, 1, 0, /*
 Return the X position of the given mouse event in characters.
 This is relative to the window the event occurred over.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int char_x;
 event_pixel_translation (event, &char_x, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 return make_int (char_x);
 }
-DEFUN ("event-y", Fevent_y, Sevent_y, 1, 1, 0 /*
+DEFUN ("event-y", Fevent_y, 1, 1, 0, /*
 Return the Y position of the given mouse event in characters.
 This is relative to the window the event occurred over.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 int char_y;
 event_pixel_translation (event, 0, &char_y, 0, 0, 0, 0, 0, 0, 0, 0);
 return make_int (char_y);
 }
-DEFUN ("event-modeline-position", Fevent_modeline_position,
+DEFUN ("event-modeline-position", Fevent_modeline_position, 1, 1, 0, /*
-Sevent_modeline_position, 1, 1, 0 /*
 Return the character position in the modeline that EVENT occurred over.
 EVENT should be a mouse event.  If EVENT did not occur over a modeline,
 nil is returned.  You can determine the actual character that the
 event occurred over by looking in `generated-modeline-string' at the
 returned character position.  Note that `generated-modeline-string'
 is buffer-local, and you must use EVENT's buffer when retrieving
 `generated-modeline-string' in order to get accurate results.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Charcount mbufp;
 event_pixel_translation (event, 0, 0, 0, 0, 0, 0, 0, &mbufp, 0, 0);
 return Qnil;
 else
 return make_int (mbufp);
 }
-DEFUN ("event-glyph", Fevent_glyph, Sevent_glyph,
+DEFUN ("event-glyph", Fevent_glyph, 1, 1, 0, /*
-1, 1, 0 /*
 Return the glyph that the given mouse event occurred over, or nil.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Lisp_Object glyph;
 struct window *w;
 event_pixel_translation (event, 0, 0, 0, 0, &w, 0, 0, 0, &glyph, 0);
 return glyph;
 else
 return Qnil;
 }
-DEFUN ("event-glyph-extent", Fevent_glyph_extent, Sevent_glyph_extent,
+DEFUN ("event-glyph-extent", Fevent_glyph_extent, 1, 1, 0, /*
-1, 1, 0 /*
 Return the extent of the glyph that the given mouse event occurred over.
 If the event did not occur over a glyph, nil is returned.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Lisp_Object extent;
 struct window *w;
 event_pixel_translation (event, 0, 0, 0, 0, &w, 0, 0, 0, 0, &extent);
 return extent;
 else
 return Qnil;
 }
-DEFUN ("event-glyph-x-pixel", Fevent_glyph_x_pixel, Sevent_glyph_x_pixel,
+DEFUN ("event-glyph-x-pixel", Fevent_glyph_x_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the X pixel position of EVENT relative to the glyph it occurred over.
 EVENT should be a mouse event.  If the event did not occur over a glyph,
 nil is returned.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Lisp_Object extent;
 struct window *w;
 int obj_x;
 return make_int (obj_x);
 else
 return Qnil;
 }
-DEFUN ("event-glyph-y-pixel", Fevent_glyph_y_pixel, Sevent_glyph_y_pixel,
+DEFUN ("event-glyph-y-pixel", Fevent_glyph_y_pixel, 1, 1, 0, /*
-1, 1, 0 /*
 Return the Y pixel position of EVENT relative to the glyph it occurred over.
 EVENT should be a mouse event.  If the event did not occur over a glyph,
 nil is returned.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Lisp_Object extent;
 struct window *w;
 int obj_y;
 return make_int (obj_y);
 else
 return Qnil;
 }
-DEFUN ("event-toolbar-button", Fevent_toolbar_button, Sevent_toolbar_button,
+DEFUN ("event-toolbar-button", Fevent_toolbar_button, 1, 1, 0, /*
-1, 1, 0 /*
 Return the toolbar button that the given mouse event occurred over.
 If the event did not occur over a toolbar, nil is returned.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 #ifdef HAVE_TOOLBARS
 Lisp_Object button;
 int result;
 else
 #endif
 return Qnil;
 }
-DEFUN ("event-process", Fevent_process, Sevent_process, 1, 1, 0 /*
+DEFUN ("event-process", Fevent_process, 1, 1, 0, /*
 Return the process of the given process-output event.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_EVENT_TYPE (event, process_event, Qprocess_event_p);
 return (XEVENT (event)->event.process.process);
 }
-DEFUN ("event-function", Fevent_function, Sevent_function, 1, 1, 0 /*
+DEFUN ("event-function", Fevent_function, 1, 1, 0, /*
 Return the callback function of EVENT.
 EVENT should be a timeout, misc-user, or eval event.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 CHECK_LIVE_EVENT (event);
 switch (XEVENT (event)->event_type)
 {
 case timeout_event:
 default:
 return wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
 }
 }
-DEFUN ("event-object", Fevent_object, Sevent_object, 1, 1, 0 /*
+DEFUN ("event-object", Fevent_object, 1, 1, 0, /*
 Return the callback function argument of EVENT.
 EVENT should be a timeout, misc-user, or eval event.
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 again:
 CHECK_LIVE_EVENT (event);
 switch (XEVENT (event)->event_type)
 {
 event = wrong_type_argument (intern ("timeout-or-eval-event-p"), event);
 goto again;
 }
 }
-DEFUN ("event-properties", Fevent_properties, Sevent_properties, 1, 1, 0 /*
+DEFUN ("event-properties", Fevent_properties, 1, 1, 0, /*
 Return a list of all of the properties of EVENT.
 This is in the form of a property list (alternating keyword/value pairs).
-*/ )
+*/
-(event)
+(event))
-Lisp_Object event;
 {
 Lisp_Object props = Qnil;
 struct Lisp_Event *e;
 struct gcpro gcpro1;
 /************************************************************************/
 void
 syms_of_events (void)
 {
-defsubr (&Scharacter_to_event);
+DEFSUBR (Fcharacter_to_event);
-defsubr (&Sevent_to_character);
+DEFSUBR (Fevent_to_character);
-defsubr (&Smake_event);
+DEFSUBR (Fmake_event);
-defsubr (&Sdeallocate_event);
+DEFSUBR (Fdeallocate_event);
-defsubr (&Scopy_event);
+DEFSUBR (Fcopy_event);
-defsubr (&Seventp);
+DEFSUBR (Feventp);
-defsubr (&Sevent_live_p);
+DEFSUBR (Fevent_live_p);
-defsubr (&Sevent_type);
+DEFSUBR (Fevent_type);
-defsubr (&Sevent_properties);
+DEFSUBR (Fevent_properties);
-defsubr (&Sevent_timestamp);
+DEFSUBR (Fevent_timestamp);
-defsubr (&Sevent_key);
+DEFSUBR (Fevent_key);
-defsubr (&Sevent_button);
+DEFSUBR (Fevent_button);
-defsubr (&Sevent_modifier_bits);
+DEFSUBR (Fevent_modifier_bits);
-defsubr (&Sevent_modifiers);
+DEFSUBR (Fevent_modifiers);
-defsubr (&Sevent_x_pixel);
+DEFSUBR (Fevent_x_pixel);
-defsubr (&Sevent_y_pixel);
+DEFSUBR (Fevent_y_pixel);
-defsubr (&Sevent_window_x_pixel);
+DEFSUBR (Fevent_window_x_pixel);
-defsubr (&Sevent_window_y_pixel);
+DEFSUBR (Fevent_window_y_pixel);
-defsubr (&Sevent_over_text_area_p);
+DEFSUBR (Fevent_over_text_area_p);
-defsubr (&Sevent_over_modeline_p);
+DEFSUBR (Fevent_over_modeline_p);
-defsubr (&Sevent_over_border_p);
+DEFSUBR (Fevent_over_border_p);
-defsubr (&Sevent_over_toolbar_p);
+DEFSUBR (Fevent_over_toolbar_p);
-defsubr (&Sevent_channel);
+DEFSUBR (Fevent_channel);
-defsubr (&Sevent_window);
+DEFSUBR (Fevent_window);
-defsubr (&Sevent_point);
+DEFSUBR (Fevent_point);
-defsubr (&Sevent_closest_point);
+DEFSUBR (Fevent_closest_point);
-defsubr (&Sevent_x);
+DEFSUBR (Fevent_x);
-defsubr (&Sevent_y);
+DEFSUBR (Fevent_y);
-defsubr (&Sevent_modeline_position);
+DEFSUBR (Fevent_modeline_position);
-defsubr (&Sevent_glyph);
+DEFSUBR (Fevent_glyph);
-defsubr (&Sevent_glyph_extent);
+DEFSUBR (Fevent_glyph_extent);
-defsubr (&Sevent_glyph_x_pixel);
+DEFSUBR (Fevent_glyph_x_pixel);
-defsubr (&Sevent_glyph_y_pixel);
+DEFSUBR (Fevent_glyph_y_pixel);
-defsubr (&Sevent_toolbar_button);
+DEFSUBR (Fevent_toolbar_button);
-defsubr (&Sevent_process);
+DEFSUBR (Fevent_process);
-defsubr (&Sevent_function);
+DEFSUBR (Fevent_function);
-defsubr (&Sevent_object);
+DEFSUBR (Fevent_object);
 defsymbol (&Qeventp, "eventp");
 defsymbol (&Qevent_live_p, "event-live-p");
 defsymbol (&Qkey_press_event_p, "key-press-event-p");
 defsymbol (&Qbutton_event_p, "button-event-p");

Mercurial > hg > xemacs-beta

comparison src/events.c @ 20:859a2309aef8 r19-15b93