/* Keyboard and mouse input; editor command loop.
- Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 2001
+ Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 01, 02
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include "dispextern.h"
#include "syntax.h"
#include "intervals.h"
+#include "keymap.h"
#include "blockinput.h"
#include "puresize.h"
#include "systime.h"
#include "w32term.h"
#endif /* HAVE_NTGUI */
-#ifdef macintosh
+#ifdef MAC_OS
#include "macterm.h"
#endif
-/* Include systime.h after xterm.h to avoid double inclusion of time.h. */
-#include "systime.h"
-
#ifndef USE_CRT_DLL
extern int errno;
#endif
#ifdef HAVE_WINDOW_SYSTEM
/* Make all keyboard buffers much bigger when using X windows. */
-#ifdef macintosh
-/* But not too big (local data > 32K error) if on macintosh. */
+#ifdef MAC_OS8
+/* But not too big (local data > 32K error) if on Mac OS Classic. */
#define KBD_BUFFER_SIZE 512
#else
#define KBD_BUFFER_SIZE 4096
int raw_keybuf_count;
#define GROW_RAW_KEYBUF \
-if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
+ if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
{ \
int newsize = 2 * XVECTOR (raw_keybuf)->size; \
Lisp_Object new; \
exists, and echo_message_buffer is eq to the current message
buffer, we know that the message comes from echo_kboard. */
-static struct kboard *echo_kboard;
+struct kboard *echo_kboard;
/* The buffer used for echoing. Set in echo_now, reset in
cancel_echoing. */
int command_loop_level;
/* Total number of times command_loop has read a key sequence. */
-int num_input_keys;
+EMACS_INT num_input_keys;
/* Last input character read as a command. */
Lisp_Object last_command_char;
Lisp_Object Vunread_post_input_method_events;
/* If not -1, an event to be read as subsequent command input. */
-int unread_command_char;
+EMACS_INT unread_command_char;
/* If not Qnil, this is a switch-frame event which we decided to put
off until the end of a key sequence. This should be read as the
Lisp_Object unread_switch_frame;
/* A mask of extra modifier bits to put into every keyboard char. */
-int extra_keyboard_modifiers;
+EMACS_INT extra_keyboard_modifiers;
/* Char to use as prefix when a meta character is typed in.
This is bound on entry to minibuffer in case ESC is changed there. */
int num_input_events;
/* Total number of times read_char has returned, outside of macros. */
-int num_nonmacro_input_events;
+EMACS_INT num_nonmacro_input_events;
/* Auto-save automatically when this many characters have been typed
since the last time. */
-static int auto_save_interval;
+static EMACS_INT auto_save_interval;
/* Value of num_nonmacro_input_events as of last auto save. */
/* This is like Vthis_command, except that commands never set it. */
Lisp_Object real_this_command;
+/* If the lookup of the command returns a binding, the original
+ command is stored in this-original-command. It is nil otherwise. */
+Lisp_Object Vthis_original_command;
+
/* The value of point when the last command was executed. */
int last_point_position;
Lisp_Object Qpost_command_idle_hook, Vpost_command_idle_hook;
/* Delay time in microseconds before running post-command-idle-hook. */
-int post_command_idle_delay;
+EMACS_INT post_command_idle_delay;
/* List of deferred actions to be performed at a later time.
The precise format isn't relevant here; we just check whether it is nil. */
queue. That way, they'll be dequeued as dead frames or windows,
but still valid Lisp objects.
- If kbd_buffer[i].kind != no_event, then
+ If kbd_buffer[i].kind != NO_EVENT, then
AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
/* Pointer to next available character in kbd_buffer.
If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
- This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the the
+ This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
next available char is in kbd_buffer[0]. */
static struct input_event *kbd_fetch_ptr;
Lisp_Object Qdelete_frame;
Lisp_Object Qiconify_frame;
Lisp_Object Qmake_frame_visible;
+Lisp_Object Qselect_window;
Lisp_Object Qhelp_echo;
/* Symbols to denote kinds of events. */
Lisp_Object Qlanguage_change;
#endif
Lisp_Object Qdrag_n_drop;
+Lisp_Object Qsave_session;
+
/* Lisp_Object Qmouse_movement; - also an event header */
/* Properties of event headers. */
Lisp_Object Qvertical_line;
Lisp_Object Qvertical_scroll_bar;
Lisp_Object Qmenu_bar;
+extern Lisp_Object Qleft_margin, Qright_margin;
Lisp_Object recursive_edit_unwind (), command_loop ();
Lisp_Object Fthis_command_keys ();
/* After a command is executed, if point is moved into a region that
has specific properties (e.g. composition, display), we adjust
point to the boundary of the region. But, if a command sets this
- valiable to non-nil, we suppress this point adjustment. This
+ variable to non-nil, we suppress this point adjustment. This
variable is set to nil before reading a command. */
Lisp_Object Vdisable_point_adjustment;
static EMACS_TIME timer_idleness_start_time;
+/* After Emacs stops being idle, this saves the last value
+ of timer_idleness_start_time from when it was idle. */
+
+static EMACS_TIME timer_last_idleness_start_time;
+
\f
/* Global variable declarations. */
static int read_avail_input P_ ((int));
static void get_input_pending P_ ((int *, int));
+static void get_filtered_input_pending P_ ((int *, int, int));
static int readable_events P_ ((int));
+static int readable_filtered_events P_ ((int, int));
static Lisp_Object read_char_x_menu_prompt P_ ((int, Lisp_Object *,
Lisp_Object, int *));
static Lisp_Object read_char_x_menu_prompt ();
static void restore_getcjmp P_ ((jmp_buf));
static Lisp_Object apply_modifiers P_ ((int, Lisp_Object));
static void clear_event P_ ((struct input_event *));
+static void any_kboard_state P_ ((void));
/* Nonzero means don't try to suspend even if the operating system seems
to support it. */
static int cannot_suspend;
-#define min(a,b) ((a)<(b)?(a):(b))
-#define max(a,b) ((a)>(b)?(a):(b))
-
/* Install the string STR as the beginning of the string of echoing,
so that it serves as a prompt for the next character.
Also start echoing. */
echo_prompt (str)
Lisp_Object str;
{
- int nbytes = STRING_BYTES (XSTRING (str));
- int multibyte_p = STRING_MULTIBYTE (str);
-
- if (nbytes > ECHOBUFSIZE - 4)
- {
- if (multibyte_p)
- {
- /* Have to find the last character that fit's into the
- echo buffer. */
- unsigned char *p = XSTRING (str)->data;
- unsigned char *pend = p + ECHOBUFSIZE - 4;
- int char_len;
-
- do
- {
- PARSE_MULTIBYTE_SEQ (p, pend - p, char_len);
- p += char_len;
- }
- while (p < pend);
-
- nbytes = p - XSTRING (str)->data - char_len;
- }
- else
- nbytes = ECHOBUFSIZE - 4;
- }
-
- nbytes = copy_text (XSTRING (str)->data, current_kboard->echobuf, nbytes,
- STRING_MULTIBYTE (str), 1);
- current_kboard->echoptr = current_kboard->echobuf + nbytes;
- *current_kboard->echoptr = '\0';
- current_kboard->echo_after_prompt = nbytes;
-
+ current_kboard->echo_string = str;
+ current_kboard->echo_after_prompt = SCHARS (str);
echo_now ();
}
{
if (current_kboard->immediate_echo)
{
- char *ptr = current_kboard->echoptr;
-
- if (ptr != current_kboard->echobuf)
- *ptr++ = ' ';
+ int size = KEY_DESCRIPTION_SIZE + 100;
+ char *buffer = (char *) alloca (size);
+ char *ptr = buffer;
+ Lisp_Object echo_string;
+ echo_string = current_kboard->echo_string;
+
/* If someone has passed us a composite event, use its head symbol. */
c = EVENT_HEAD (c);
if (INTEGERP (c))
{
- int ch = XINT (c);
-
- if (ptr - current_kboard->echobuf
- > ECHOBUFSIZE - KEY_DESCRIPTION_SIZE)
- return;
-
- ptr = push_key_description (ch, ptr, 1);
+ ptr = push_key_description (XINT (c), ptr, 1);
}
else if (SYMBOLP (c))
{
- struct Lisp_String *name = XSYMBOL (c)->name;
- if ((ptr - current_kboard->echobuf) + STRING_BYTES (name) + 4
- > ECHOBUFSIZE)
- return;
- ptr += copy_text (name->data, ptr, STRING_BYTES (name),
+ struct Lisp_String *name = XSTRING (SYMBOL_NAME (c));
+ int nbytes = STRING_BYTES (name);
+
+ if (size - (ptr - buffer) < nbytes)
+ {
+ int offset = ptr - buffer;
+ size = max (2 * size, size + nbytes);
+ buffer = (char *) alloca (size);
+ ptr = buffer + offset;
+ }
+
+ ptr += copy_text (name->data, ptr, nbytes,
name->size_byte >= 0, 1);
}
- if (current_kboard->echoptr == current_kboard->echobuf
+ if ((NILP (echo_string) || SCHARS (echo_string) == 0)
&& help_char_p (c))
{
- strcpy (ptr, " (Type ? for further options)");
- ptr += strlen (ptr);
+ const char *text = " (Type ? for further options)";
+ int len = strlen (text);
+
+ if (size - (ptr - buffer) < len)
+ {
+ int offset = ptr - buffer;
+ size += len;
+ buffer = (char *) alloca (size);
+ ptr = buffer + offset;
+ }
+
+ bcopy (text, ptr, len);
+ ptr += len;
+ }
+
+ /* Replace a dash from echo_dash with a space, otherwise
+ add a space at the end as a separator between keys. */
+ if (STRINGP (echo_string)
+ && SCHARS (echo_string) > 0)
+ {
+ Lisp_Object last_char, idx;
+
+ idx = make_number (SCHARS (echo_string) - 1);
+ last_char = Faref (echo_string, idx);
+
+ if (XINT (last_char) == '-')
+ Faset (echo_string, idx, make_number (' '));
+ else
+ echo_string = concat2 (echo_string, build_string (" "));
}
- *ptr = 0;
- current_kboard->echoptr = ptr;
+ current_kboard->echo_string
+ = concat2 (echo_string, make_string (buffer, ptr - buffer));
echo_now ();
}
void
echo_dash ()
{
+ /* Do nothing if not echoing at all. */
+ if (NILP (current_kboard->echo_string))
+ return;
+
if (!current_kboard->immediate_echo
- && current_kboard->echoptr == current_kboard->echobuf)
+ && SCHARS (current_kboard->echo_string) == 0)
return;
+
/* Do nothing if we just printed a prompt. */
if (current_kboard->echo_after_prompt
- == current_kboard->echoptr - current_kboard->echobuf)
- return;
- /* Do nothing if not echoing at all. */
- if (current_kboard->echoptr == 0)
+ == SCHARS (current_kboard->echo_string))
return;
-
+
/* Put a dash at the end of the buffer temporarily,
but make it go away when the next character is added. */
- current_kboard->echoptr[0] = '-';
- current_kboard->echoptr[1] = 0;
-
+ current_kboard->echo_string = concat2 (current_kboard->echo_string,
+ build_string ("-"));
echo_now ();
}
}
echoing = 1;
- message2_nolog (current_kboard->echobuf, strlen (current_kboard->echobuf),
- 1);
+ message3_nolog (current_kboard->echo_string,
+ SBYTES (current_kboard->echo_string),
+ SMBP (current_kboard->echo_string));
echoing = 0;
/* Record in what buffer we echoed, and from which kboard. */
cancel_echoing ()
{
current_kboard->immediate_echo = 0;
- current_kboard->echoptr = current_kboard->echobuf;
current_kboard->echo_after_prompt = -1;
+ current_kboard->echo_string = Qnil;
ok_to_echo_at_next_pause = NULL;
echo_kboard = NULL;
echo_message_buffer = Qnil;
static int
echo_length ()
{
- return current_kboard->echoptr - current_kboard->echobuf;
+ return (STRINGP (current_kboard->echo_string)
+ ? SCHARS (current_kboard->echo_string)
+ : 0);
}
/* Truncate the current echo message to its first LEN chars.
switches frames while entering a key sequence. */
static void
-echo_truncate (len)
- int len;
+echo_truncate (nchars)
+ int nchars;
{
- current_kboard->echobuf[len] = '\0';
- current_kboard->echoptr = current_kboard->echobuf + len;
- truncate_echo_area (len);
+ if (STRINGP (current_kboard->echo_string))
+ current_kboard->echo_string
+ = Fsubstring (current_kboard->echo_string,
+ make_number (0), make_number (nchars));
+ truncate_echo_area (nchars);
}
\f
#ifdef HAVE_X_WINDOWS
/* The command loop has started an hourglass timer, so we have to
cancel it here, otherwise it will fire because the recursive edit
- can take some time. */
- if (display_hourglass_p)
+ can take some time. Do not check for display_hourglass_p here,
+ because it could already be nil. */
cancel_hourglass ();
#endif
}
\f
DEFUN ("recursive-edit", Frecursive_edit, Srecursive_edit, 0, 0, "",
- "Invoke the editor command loop recursively.\n\
-To get out of the recursive edit, a command can do `(throw 'exit nil)';\n\
-that tells this function to return.\n\
-Alternately, `(throw 'exit t)' makes this function signal an error.\n\
-This function is called by the editor initialization to begin editing.")
- ()
+ doc: /* Invoke the editor command loop recursively.
+To get out of the recursive edit, a command can do `(throw 'exit nil)';
+that tells this function to return.
+Alternately, `(throw 'exit t)' makes this function signal an error.
+This function is called by the editor initialization to begin editing. */)
+ ()
{
int count = specpdl_ptr - specpdl;
+ Lisp_Object buffer;
command_loop_level++;
update_mode_lines = 1;
+ if (command_loop_level
+ && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
+ buffer = Fcurrent_buffer ();
+ else
+ buffer = Qnil;
+
+ /* If we leave recursive_edit_1 below with a `throw' for instance,
+ like it is done in the splash screen display, we have to
+ make sure that we restore single_kboard as command_loop_1
+ would have done if it were left normally. */
record_unwind_protect (recursive_edit_unwind,
- (command_loop_level
- && current_buffer != XBUFFER (XWINDOW (selected_window)->buffer))
- ? Fcurrent_buffer ()
- : Qnil);
+ Fcons (buffer, single_kboard ? Qt : Qnil));
+
recursive_edit_1 ();
return unbind_to (count, Qnil);
}
Lisp_Object
-recursive_edit_unwind (buffer)
- Lisp_Object buffer;
+recursive_edit_unwind (info)
+ Lisp_Object info;
{
- if (!NILP (buffer))
- Fset_buffer (buffer);
-
+ if (BUFFERP (XCAR (info)))
+ Fset_buffer (XCAR (info));
+
+ if (NILP (XCDR (info)))
+ any_kboard_state ();
+ else
+ single_kboard_state ();
+
command_loop_level--;
update_mode_lines = 1;
return Qnil;
}
+
\f
static void
any_kboard_state ()
/* Here we catch errors in execution of commands within the
editing loop, and reenter the editing loop.
When there is an error, cmd_error runs and returns a non-nil
- value to us. A value of nil means that cmd_loop_1 itself
+ value to us. A value of nil means that command_loop_1 itself
returned due to end of file (or end of kbd macro). */
Lisp_Object
}
DEFUN ("top-level", Ftop_level, Stop_level, 0, 0, "",
- "Exit all recursive editing levels.")
- ()
+ doc: /* Exit all recursive editing levels. */)
+ ()
{
#ifdef HAVE_X_WINDOWS
if (display_hourglass_p)
}
DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
- "Exit from the innermost recursive edit or minibuffer.")
- ()
+ doc: /* Exit from the innermost recursive edit or minibuffer. */)
+ ()
{
if (command_loop_level > 0 || minibuf_level > 0)
Fthrow (Qexit, Qnil);
}
DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0, 0, "",
- "Abort the command that requested this recursive edit or minibuffer input.")
- ()
+ doc: /* Abort the command that requested this recursive edit or minibuffer input. */)
+ ()
{
if (command_loop_level > 0 || minibuf_level > 0)
Fthrow (Qexit, Qt);
/* This is the actual command reading loop,
sans error-handling encapsulation. */
-EXFUN (Fcommand_execute, 4);
static int read_key_sequence P_ ((Lisp_Object *, int, Lisp_Object,
int, int, int));
void safe_run_hooks P_ ((Lisp_Object));
reset it before we execute the command. */
Vdeactivate_mark = Qnil;
+ /* Remap command through active keymaps */
+ Vthis_original_command = cmd;
+ if (SYMBOLP (cmd))
+ {
+ Lisp_Object cmd1;
+ if (cmd1 = Fremap_command (cmd), !NILP (cmd1))
+ cmd = cmd1;
+ }
+
/* Execute the command. */
Vthis_command = cmd;
/* Here for a command that isn't executed directly */
#ifdef HAVE_X_WINDOWS
- if (display_hourglass_p)
+ if (display_hourglass_p
+ && NILP (Vexecuting_macro))
start_hourglass ();
#endif
Fcommand_execute (Vthis_command, Qnil, Qnil, Qnil);
#ifdef HAVE_X_WINDOWS
- if (display_hourglass_p)
+ /* Do not check display_hourglass_p here, because
+ Fcommand_execute could change it, but we should cancel
+ hourglass cursor anyway.
+ But don't cancel the hourglass within a macro
+ just because a command in the macro finishes. */
+ if (NILP (Vexecuting_macro))
cancel_hourglass ();
#endif
}
{
if (!NILP (Vdeactivate_mark) && !NILP (Vtransient_mark_mode))
{
- current_buffer->mark_active = Qnil;
- call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
+ /* We could also call `deactivate'mark'. */
+ if (EQ (Vtransient_mark_mode, Qlambda))
+ Vtransient_mark_mode = Qnil;
+ else
+ {
+ current_buffer->mark_active = Qnil;
+ call1 (Vrun_hooks, intern ("deactivate-mark-hook"));
+ }
}
else if (current_buffer != prev_buffer || MODIFF != prev_modiff)
call1 (Vrun_hooks, intern ("activate-mark-hook"));
/* Number of seconds between polling for input. This is a Lisp
variable that can be bound. */
-int polling_period;
+EMACS_INT polling_period;
/* Nonzero means polling for input is temporarily suppressed. */
the `display' property). POS is the position in that string under
the mouse.
- OK_TO_IVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
+ OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
echo overwrites a keystroke echo currently displayed in the echo
area.
all, or it's from echoing from a different kboard than the
current one. */
- if (/* There currently something in the echo area */
+ if (/* There currently is something in the echo area. */
!NILP (echo_area_buffer[0])
&& (/* And it's either not from echoing. */
!EQ (echo_area_buffer[0], echo_message_buffer)
KBOARD *kb = FRAME_KBOARD (XFRAME (selected_frame));
if (kb != current_kboard)
{
- Lisp_Object *tailp = &kb->kbd_queue;
+ Lisp_Object link = kb->kbd_queue;
/* We shouldn't get here if we were in single-kboard mode! */
if (single_kboard)
abort ();
- while (CONSP (*tailp))
- tailp = &XCDR (*tailp);
- if (!NILP (*tailp))
- abort ();
- *tailp = Fcons (c, Qnil);
+ if (CONSP (link))
+ {
+ while (CONSP (XCDR (link)))
+ link = XCDR (link);
+ if (!NILP (XCDR (link)))
+ abort ();
+ }
+ if (!CONSP (link))
+ kb->kbd_queue = Fcons (c, Qnil);
+ else
+ XSETCDR (link, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
current_kboard = kb;
/* This is going to exit from read_char
#ifdef MULTI_KBOARD
if (! NILP (c) && (kb != current_kboard))
{
- Lisp_Object *tailp = &kb->kbd_queue;
- while (CONSP (*tailp))
- tailp = &XCDR (*tailp);
- if (!NILP (*tailp))
- abort ();
- *tailp = Fcons (c, Qnil);
+ Lisp_Object link = kb->kbd_queue;
+ if (CONSP (link))
+ {
+ while (CONSP (XCDR (link)))
+ link = XCDR (link);
+ if (!NILP (XCDR (link)))
+ abort ();
+ }
+ if (!CONSP (link))
+ kb->kbd_queue = Fcons (c, Qnil);
+ else
+ XSETCDR (link, Fcons (c, Qnil));
kb->kbd_queue_has_data = 1;
c = Qnil;
if (single_kboard)
last_input_char = c;
Fcommand_execute (tem, Qnil, Fvector (1, &last_input_char), Qt);
+ if (CONSP (c) && EQ (XCAR (c), Qselect_window))
+ /* We stopped being idle for this event; undo that. This
+ prevents automatic window selection (under
+ mouse_autoselect_window from acting as a real input event, for
+ example banishing the mouse under mouse-avoidance-mode. */
+ timer_idleness_start_time = last_idle_start;
+
/* Resume allowing input from any kboard, if that was true before. */
if (!was_locked)
any_kboard_state ();
if (EQ (posn, Qmenu_bar) || EQ (posn, Qtool_bar))
{
/* Change menu-bar to (menu-bar) as the event "position". */
- POSN_BUFFER_POSN (EVENT_START (c)) = Fcons (posn, Qnil);
+ POSN_BUFFER_SET_POSN (EVENT_START (c), Fcons (posn, Qnil));
also_record = c;
Vunread_command_events = Fcons (c, Vunread_command_events);
/* Now wipe the echo area, except for help events which do their
own stuff with the echo area. */
- if (!CONSP (c) || !(EQ (Qhelp_echo, XCAR (c))))
+ if (!CONSP (c)
+ || (!(EQ (Qhelp_echo, XCAR (c)))
+ && !(EQ (Qswitch_frame, XCAR (c)))))
{
if (!NILP (echo_area_buffer[0]))
safe_run_hooks (Qecho_area_clear_hook);
if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
{
/* (help-echo FRAME HELP WINDOW OBJECT POS). */
- Lisp_Object help, object, position, window;
- help = Fnth (make_number (2), c);
- window = Fnth (make_number (3), c);
- object = Fnth (make_number (4), c);
- position = Fnth (make_number (5), c);
+ Lisp_Object help, object, position, window, tem;
+
+ tem = Fcdr (XCDR (c));
+ help = Fcar (tem);
+ tem = Fcdr (tem);
+ window = Fcar (tem);
+ tem = Fcdr (tem);
+ object = Fcar (tem);
+ tem = Fcdr (tem);
+ position = Fcar (tem);
+
show_help_echo (help, window, object, position, 0);
/* We stopped being idle for this event; undo that. */
record_char (c)
Lisp_Object c;
{
- /* Don't record `help-echo' in recent_keys unless it shows some help
- message, and a different help than the previoiusly recorded
- event. */
- if (CONSP (c) && EQ (XCAR (c), Qhelp_echo))
+ int recorded = 0;
+
+ if (CONSP (c) && (EQ (XCAR (c), Qhelp_echo) || EQ (XCAR (c), Qmouse_movement)))
{
- Lisp_Object help;
+ /* To avoid filling recent_keys with help-echo and mouse-movement
+ events, we filter out repeated help-echo events, only store the
+ first and last in a series of mouse-movement events, and don't
+ store repeated help-echo events which are only separated by
+ mouse-movement events. */
- help = Fnth (make_number (2), c);
- if (STRINGP (help))
+ Lisp_Object ev1, ev2, ev3;
+ int ix1, ix2, ix3;
+
+ if ((ix1 = recent_keys_index - 1) < 0)
+ ix1 = NUM_RECENT_KEYS - 1;
+ ev1 = AREF (recent_keys, ix1);
+
+ if ((ix2 = ix1 - 1) < 0)
+ ix2 = NUM_RECENT_KEYS - 1;
+ ev2 = AREF (recent_keys, ix2);
+
+ if ((ix3 = ix2 - 1) < 0)
+ ix3 = NUM_RECENT_KEYS - 1;
+ ev3 = AREF (recent_keys, ix3);
+
+ if (EQ (XCAR (c), Qhelp_echo))
{
- int last_idx;
- Lisp_Object last_c, last_help;
-
- last_idx = recent_keys_index - 1;
- if (last_idx < 0)
- last_idx = NUM_RECENT_KEYS - 1;
- last_c = AREF (recent_keys, last_idx);
-
- if (!CONSP (last_c)
- || !EQ (XCAR (last_c), Qhelp_echo)
- || (last_help = Fnth (make_number (2), last_c),
- !EQ (last_help, help)))
+ /* Don't record `help-echo' in recent_keys unless it shows some help
+ message, and a different help than the previously recorded
+ event. */
+ Lisp_Object help, last_help;
+
+ help = Fcar_safe (Fcdr_safe (XCDR (c)));
+ if (!STRINGP (help))
+ recorded = 1;
+ else if (CONSP (ev1) && EQ (XCAR (ev1), Qhelp_echo)
+ && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev1))), EQ (last_help, help)))
+ recorded = 1;
+ else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
+ && CONSP (ev2) && EQ (XCAR (ev2), Qhelp_echo)
+ && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev2))), EQ (last_help, help)))
+ recorded = -1;
+ else if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
+ && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
+ && CONSP (ev3) && EQ (XCAR (ev3), Qhelp_echo)
+ && (last_help = Fcar_safe (Fcdr_safe (XCDR (ev3))), EQ (last_help, help)))
+ recorded = -2;
+ }
+ else if (EQ (XCAR (c), Qmouse_movement))
+ {
+ /* Only record one pair of `mouse-movement' on a window in recent_keys.
+ So additional mouse movement events replace the last element. */
+ Lisp_Object last_window, window;
+
+ window = Fcar_safe (Fcar_safe (XCDR (c)));
+ if (CONSP (ev1) && EQ (XCAR (ev1), Qmouse_movement)
+ && (last_window = Fcar_safe (Fcar_safe (XCDR (ev1))), EQ (last_window, window))
+ && CONSP (ev2) && EQ (XCAR (ev2), Qmouse_movement)
+ && (last_window = Fcar_safe (Fcar_safe (XCDR (ev2))), EQ (last_window, window)))
{
- total_keys++;
- ASET (recent_keys, recent_keys_index, c);
- if (++recent_keys_index >= NUM_RECENT_KEYS)
- recent_keys_index = 0;
+ ASET (recent_keys, ix1, c);
+ recorded = 1;
}
}
}
else
+ store_kbd_macro_char (c);
+
+ if (!recorded)
{
total_keys++;
ASET (recent_keys, recent_keys_index, c);
if (++recent_keys_index >= NUM_RECENT_KEYS)
recent_keys_index = 0;
}
+ else if (recorded < 0)
+ {
+ /* We need to remove one or two events from recent_keys.
+ To do this, we simply put nil at those events and move the
+ recent_keys_index backwards over those events. Usually,
+ users will never see those nil events, as they will be
+ overwritten by the command keys entered to see recent_keys
+ (e.g. C-h l). */
+
+ while (recorded++ < 0 && total_keys > 0)
+ {
+ if (total_keys < NUM_RECENT_KEYS)
+ total_keys--;
+ if (--recent_keys_index < 0)
+ recent_keys_index = NUM_RECENT_KEYS - 1;
+ ASET (recent_keys, recent_keys_index, Qnil);
+ }
+ }
+
+ num_nonmacro_input_events++;
/* Write c to the dribble file. If c is a lispy event, write
the event's symbol to the dribble file, in <brackets>. Bleaugh.
if (SYMBOLP (dribblee))
{
putc ('<', dribble);
- fwrite (XSYMBOL (dribblee)->name->data, sizeof (char),
- STRING_BYTES (XSYMBOL (dribblee)->name),
+ fwrite (XSTRING (SYMBOL_NAME (dribblee))->data, sizeof (char),
+ STRING_BYTES (XSTRING (SYMBOL_NAME (dribblee))),
dribble);
putc ('>', dribble);
}
fflush (dribble);
}
-
- if (!CONSP (c) || !EQ (Qhelp_echo, XCAR (c)))
- store_kbd_macro_char (c);
-
- num_nonmacro_input_events++;
}
Lisp_Object
}
DEFUN ("track-mouse", Ftrack_mouse, Strack_mouse, 0, UNEVALLED, 0,
- "Evaluate BODY with mouse movement events enabled.\n\
-Within a `track-mouse' form, mouse motion generates input events that\n\
-you can read with `read-event'.\n\
-Normally, mouse motion is ignored.")
- (args)
+ doc: /* Evaluate BODY with mouse movement events enabled.
+Within a `track-mouse' form, mouse motion generates input events that
+you can read with `read-event'.
+Normally, mouse motion is ignored.
+usage: (track-mouse BODY ...) */)
+ (args)
Lisp_Object args;
{
int count = specpdl_ptr - specpdl;
/* Return true iff there are any events in the queue that read-char
would return. If this returns false, a read-char would block. */
static int
-readable_events (do_timers_now)
+readable_filtered_events (do_timers_now, filter_events)
int do_timers_now;
+ int filter_events;
{
if (do_timers_now)
timer_check (do_timers_now);
+ /* If the buffer contains only FOCUS_IN_EVENT events,
+ and FILTER_EVENTS is nonzero, report it as empty. */
if (kbd_fetch_ptr != kbd_store_ptr)
- return 1;
+ {
+ int have_live_event = 1;
+
+ if (filter_events)
+ {
+ struct input_event *event;
+
+ event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
+ ? kbd_fetch_ptr
+ : kbd_buffer);
+
+ while (have_live_event && event->kind == FOCUS_IN_EVENT)
+ {
+ event++;
+ if (event == kbd_buffer + KBD_BUFFER_SIZE)
+ event = kbd_buffer;
+ if (event == kbd_store_ptr)
+ have_live_event = 0;
+ }
+ }
+ if (have_live_event) return 1;
+ }
+
#ifdef HAVE_MOUSE
if (!NILP (do_mouse_tracking) && some_mouse_moved ())
return 1;
return 0;
}
+/* Return true iff there are any events in the queue that read-char
+ would return. If this returns false, a read-char would block. */
+static int
+readable_events (do_timers_now)
+ int do_timers_now;
+{
+ return readable_filtered_events (do_timers_now, 0);
+}
+
/* Set this for debugging, to have a way to get out */
int stop_character;
kbd_buffer_store_event (event)
register struct input_event *event;
{
- if (event->kind == no_event)
+ if (event->kind == NO_EVENT)
abort ();
- if (event->kind == ascii_keystroke)
+ if (event->kind == ASCII_KEYSTROKE_EVENT)
{
register int c = event->code & 0377;
if (c == quit_char)
{
- extern SIGTYPE interrupt_signal ();
+ static SIGTYPE interrupt_signal P_ ((int));
#ifdef MULTI_KBOARD
KBOARD *kb;
struct input_event *sp;
if (event_to_kboard (sp) == kb)
{
- sp->kind = no_event;
+ sp->kind = NO_EVENT;
sp->frame_or_window = Qnil;
sp->arg = Qnil;
}
}
last_event_timestamp = event->timestamp;
- interrupt_signal ();
+ interrupt_signal (0 /* dummy */);
return;
}
return;
}
}
- /* Don't insert two buffer_switch_event's in a row.
+ /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
Just ignore the second one. */
- else if (event->kind == buffer_switch_event
+ else if (event->kind == BUFFER_SWITCH_EVENT
&& kbd_fetch_ptr != kbd_store_ptr
- && kbd_store_ptr->kind == buffer_switch_event)
+ && kbd_store_ptr->kind == BUFFER_SWITCH_EVENT)
return;
if (kbd_store_ptr - kbd_buffer == KBD_BUFFER_SIZE)
{
int idx;
-#if 0 /* The selection_request_event case looks bogus, and it's error
+#if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
prone to assign individual members for other events, in case
the input_event structure is changed. --2000-07-13, gerd. */
struct input_event *sp = kbd_store_ptr;
sp->kind = event->kind;
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
/* We must not use the ordinary copying code for this case,
since `part' is an enum and copying it might not copy enough
Lisp_Object help, frame, object, window;
int pos;
{
- int nevents_stored = 0;
-
- if (size >= 2)
+ if (size >= 1)
{
bufp->kind = HELP_EVENT;
bufp->frame_or_window = frame;
bufp->arg = object;
- bufp->x = make_number (pos);
- bufp->code = 0;
-
- ++bufp;
- bufp->kind = HELP_EVENT;
- bufp->frame_or_window = WINDOWP (window) ? window : frame;
- bufp->arg = help;
- bufp->code = 1;
- nevents_stored = 2;
+ bufp->x = WINDOWP (window) ? window : frame;
+ bufp->y = help;
+ bufp->code = pos;
+ return 1;
}
-
- return nevents_stored;
+ return 0;
}
event.kind = HELP_EVENT;
event.frame_or_window = frame;
event.arg = Qnil;
- event.x = make_number (0);
+ event.x = Qnil;
+ event.y = help;
event.code = 0;
kbd_buffer_store_event (&event);
-
- event.kind = HELP_EVENT;
- event.frame_or_window = frame;
- event.arg = help;
- event.x = make_number (0);
- event.code = 1;
- kbd_buffer_store_event (&event);
}
\f
/* Discard any mouse events in the event buffer by setting them to
- no_event. */
+ NO_EVENT. */
void
discard_mouse_events ()
{
if (sp == kbd_buffer + KBD_BUFFER_SIZE)
sp = kbd_buffer;
- if (sp->kind == mouse_click
+ if (sp->kind == MOUSE_CLICK_EVENT
#ifdef WINDOWSNT
- || sp->kind == w32_scroll_bar_click
+ || sp->kind == W32_SCROLL_BAR_CLICK_EVENT
#endif
- || sp->kind == scroll_bar_click)
+ || sp->kind == SCROLL_BAR_CLICK_EVENT)
{
- sp->kind = no_event;
+ sp->kind = NO_EVENT;
}
}
}
/* Return non-zero if there are any real events waiting in the event
- buffer, not counting `no_event's.
+ buffer, not counting `NO_EVENT's.
- If DISCARD is non-zero, discard no_event events at the front of
+ If DISCARD is non-zero, discard NO_EVENT events at the front of
the input queue, possibly leaving the input queue empty if there
are no real input events. */
struct input_event *sp;
for (sp = kbd_fetch_ptr;
- sp != kbd_store_ptr && sp->kind == no_event;
+ sp != kbd_store_ptr && sp->kind == NO_EVENT;
++sp)
{
if (sp == kbd_buffer + KBD_BUFFER_SIZE)
if (discard)
kbd_fetch_ptr = sp;
- return sp != kbd_store_ptr && sp->kind != no_event;
+ return sp != kbd_store_ptr && sp->kind != NO_EVENT;
}
\f
int idx = 2 * (event - kbd_buffer);
ASET (kbd_buffer_gcpro, idx, Qnil);
ASET (kbd_buffer_gcpro, idx + 1, Qnil);
- event->kind = no_event;
+ event->kind = NO_EVENT;
}
/* These two kinds of events get special handling
and don't actually appear to the command loop.
We return nil for them. */
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
#endif
}
- else if (event->kind == selection_clear_event)
+ else if (event->kind == SELECTION_CLEAR_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
abort ();
#endif
}
-#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (macintosh)
- else if (event->kind == delete_window_event)
+#if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
+ else if (event->kind == DELETE_WINDOW_EVENT)
{
/* Make an event (delete-frame (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
}
#endif
#if defined (HAVE_X11) || defined (HAVE_NTGUI)
- else if (event->kind == iconify_event)
+ else if (event->kind == ICONIFY_EVENT)
{
/* Make an event (iconify-frame (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
obj = Fcons (Qiconify_frame, Fcons (obj, Qnil));
kbd_fetch_ptr = event + 1;
}
- else if (event->kind == deiconify_event)
+ else if (event->kind == DEICONIFY_EVENT)
{
/* Make an event (make-frame-visible (FRAME)). */
obj = Fcons (event->frame_or_window, Qnil);
kbd_fetch_ptr = event + 1;
}
#endif
- else if (event->kind == buffer_switch_event)
+ else if (event->kind == BUFFER_SWITCH_EVENT)
{
/* The value doesn't matter here; only the type is tested. */
XSETBUFFER (obj, current_buffer);
kbd_fetch_ptr = event + 1;
}
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
- else if (event->kind == menu_bar_activate_event)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
+ else if (event->kind == MENU_BAR_ACTIVATE_EVENT)
{
kbd_fetch_ptr = event + 1;
input_pending = readable_events (0);
}
#endif
#ifdef WINDOWSNT
- else if (event->kind == language_change_event)
+ else if (event->kind == LANGUAGE_CHANGE_EVENT)
{
/* Make an event (language-change (FRAME CHARSET LCID)). */
obj = Fcons (event->modifiers, Qnil);
- obj = Fcons (event->code, Qnil);
+ obj = Fcons (event->code, obj);
obj = Fcons (event->frame_or_window, obj);
obj = Fcons (Qlanguage_change, Fcons (obj, Qnil));
kbd_fetch_ptr = event + 1;
}
#endif
+ else if (event->kind == SAVE_SESSION_EVENT)
+ {
+ obj = Fcons (Qsave_session, Qnil);
+ kbd_fetch_ptr = event + 1;
+ }
/* Just discard these, by returning nil.
With MULTI_KBOARD, these events are used as placeholders
when we need to randomly delete events from the queue.
(They shouldn't otherwise be found in the buffer,
but on some machines it appears they do show up
even without MULTI_KBOARD.) */
- /* On Windows NT/9X, no_event is used to delete extraneous
+ /* On Windows NT/9X, NO_EVENT is used to delete extraneous
mouse events during a popup-menu call. */
- else if (event->kind == no_event)
+ else if (event->kind == NO_EVENT)
kbd_fetch_ptr = event + 1;
else if (event->kind == HELP_EVENT)
{
- /* There are always two HELP_EVENTs in the input queue. */
Lisp_Object object, position, help, frame, window;
- xassert (event->code == 0);
frame = event->frame_or_window;
object = event->arg;
- position = event->x;
+ position = make_number (event->code);
+ window = event->x;
+ help = event->y;
clear_event (event);
kbd_fetch_ptr = event + 1;
- event = ((kbd_fetch_ptr < kbd_buffer + KBD_BUFFER_SIZE)
- ? kbd_fetch_ptr
- : kbd_buffer);
- xassert (event->code == 1);
- help = event->arg;
- window = event->frame_or_window;
if (!WINDOWP (window))
window = Qnil;
obj = Fcons (Qhelp_echo,
list5 (frame, help, window, object, position));
- clear_event (event);
- kbd_fetch_ptr = event + 1;
}
else if (event->kind == FOCUS_IN_EVENT)
{
&& !EQ (frame, selected_frame))
obj = make_lispy_switch_frame (frame);
internal_last_event_frame = frame;
+ kbd_fetch_ptr = event + 1;
+ }
+ else if (event->kind == SELECT_WINDOW_EVENT)
+ {
+ /* Make an event (select-window (WINDOW)). */
+ obj = Fcons (event->frame_or_window, Qnil);
+ obj = Fcons (Qselect_window, Fcons (obj, Qnil));
+
kbd_fetch_ptr = event + 1;
}
else
/* These two kinds of events get special handling
and don't actually appear to the command loop. */
- if (event->kind == selection_request_event)
+ if (event->kind == SELECTION_REQUEST_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
#endif
}
- else if (event->kind == selection_clear_event)
+ else if (event->kind == SELECTION_CLEAR_EVENT)
{
#ifdef HAVE_X11
struct input_event copy;
EMACS_GET_TIME (timer_idleness_start_time);
+ timer_last_idleness_start_time = timer_idleness_start_time;
+
/* Mark all idle-time timers as once again candidates for running. */
for (timers = Vtimer_idle_list; CONSP (timers); timers = XCDR (timers))
{
/* Maximum number of pixels the mouse may be moved between clicks
to make a double-click. */
-int double_click_fuzz;
+EMACS_INT double_click_fuzz;
/* The number of clicks in this multiple-click. */
switch (SWITCH_ENUM_CAST (event->kind))
{
/* A simple keystroke. */
- case ascii_keystroke:
+ case ASCII_KEYSTROKE_EVENT:
{
Lisp_Object lispy_c;
int c = event->code & 0377;
return lispy_c;
}
- case multibyte_char_keystroke:
+ case MULTIBYTE_CHAR_KEYSTROKE_EVENT:
{
Lisp_Object lispy_c;
/* A function key. The symbol may need to have modifier prefixes
tacked onto it. */
- case non_ascii_keystroke:
+ case NON_ASCII_KEYSTROKE_EVENT:
button_down_time = 0;
for (i = 0; i < sizeof (lispy_accent_codes) / sizeof (int); i++)
(sizeof (lispy_accent_keys)
/ sizeof (lispy_accent_keys[0])));
- /* Handle system-specific keysyms. */
- if (event->code & (1 << 28))
- {
- /* We need to use an alist rather than a vector as the cache
- since we can't make a vector long enuf. */
- if (NILP (current_kboard->system_key_syms))
- current_kboard->system_key_syms = Fcons (Qnil, Qnil);
- return modify_event_symbol (event->code,
- event->modifiers,
- Qfunction_key,
- current_kboard->Vsystem_key_alist,
- 0, ¤t_kboard->system_key_syms,
- (unsigned)-1);
- }
-
#ifdef XK_kana_A
if (event->code >= 0x400 && event->code < 0x500)
return modify_event_symbol (event->code - 0x400,
iso_lispy_function_keys, &func_key_syms,
(sizeof (iso_lispy_function_keys)
/ sizeof (iso_lispy_function_keys[0])));
- else
#endif
- return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
- event->modifiers,
- Qfunction_key, Qnil,
- lispy_function_keys, &func_key_syms,
- (sizeof (lispy_function_keys)
- / sizeof (lispy_function_keys[0])));
+
+ /* Handle system-specific or unknown keysyms. */
+ if (event->code & (1 << 28)
+ || event->code - FUNCTION_KEY_OFFSET < 0
+ || (event->code - FUNCTION_KEY_OFFSET
+ >= sizeof lispy_function_keys / sizeof *lispy_function_keys)
+ || !lispy_function_keys[event->code - FUNCTION_KEY_OFFSET])
+ {
+ /* We need to use an alist rather than a vector as the cache
+ since we can't make a vector long enuf. */
+ if (NILP (current_kboard->system_key_syms))
+ current_kboard->system_key_syms = Fcons (Qnil, Qnil);
+ return modify_event_symbol (event->code,
+ event->modifiers,
+ Qfunction_key,
+ current_kboard->Vsystem_key_alist,
+ 0, ¤t_kboard->system_key_syms,
+ (unsigned) -1);
+ }
+
+ return modify_event_symbol (event->code - FUNCTION_KEY_OFFSET,
+ event->modifiers,
+ Qfunction_key, Qnil,
+ lispy_function_keys, &func_key_syms,
+ (sizeof (lispy_function_keys)
+ / sizeof (lispy_function_keys[0])));
#ifdef HAVE_MOUSE
/* A mouse click. Figure out where it is, decide whether it's
a press, click or drag, and build the appropriate structure. */
- case mouse_click:
+ case MOUSE_CLICK_EVENT:
#ifndef USE_TOOLKIT_SCROLL_BARS
- case scroll_bar_click:
+ case SCROLL_BAR_CLICK_EVENT:
#endif
{
int button = event->code;
position = Qnil;
/* Build the position as appropriate for this mouse click. */
- if (event->kind == mouse_click)
+ if (event->kind == MOUSE_CLICK_EVENT)
{
int part;
struct frame *f = XFRAME (event->frame_or_window);
}
else if (part == 2)
posn = Qvertical_line;
+ else if (part == 6 || part == 7)
+ {
+ int charpos;
+ Lisp_Object object = marginal_area_string (w, wx, wy, part,
+ &charpos);
+ posn = (part == 6) ? Qleft_margin : Qright_margin;
+ if (STRINGP (object))
+ string_info = Fcons (object, make_number (charpos));
+ }
else
{
Lisp_Object object;
else
#endif
{
- /* The third element of every position should be the (x,y)
- pair. */
Lisp_Object down;
+ EMACS_INT xdiff = double_click_fuzz, ydiff = double_click_fuzz;
- down = Fnth (make_number (2), start_pos);
- if (EQ (event->x, XCAR (down)) && EQ (event->y, XCDR (down)))
- /* Mouse hasn't moved. */
+ /* The third element of every position
+ should be the (x,y) pair. */
+ down = Fcar (Fcdr (Fcdr (start_pos)));
+ if (CONSP (down)
+ && INTEGERP (XCAR (down)) && INTEGERP (XCDR (down)))
+ {
+ xdiff = XFASTINT (event->x) - XFASTINT (XCAR (down));
+ ydiff = XFASTINT (event->y) - XFASTINT (XCDR (down));
+ }
+
+ if (xdiff < double_click_fuzz && xdiff > - double_click_fuzz
+ && ydiff < double_click_fuzz
+ && ydiff > - double_click_fuzz)
+ /* Mouse hasn't moved (much). */
event->modifiers |= click_modifier;
else
{
- Lisp_Object window1, window2, posn1, posn2;
-
- /* Avoid generating a drag event if the mouse
- hasn't actually moved off the buffer position. */
- window1 = Fnth (make_number (0), position);
- posn1 = Fnth (make_number (1), position);
- window2 = Fnth (make_number (0), start_pos);
- posn2 = Fnth (make_number (1), start_pos);
-
- if (EQ (window1, window2) && EQ (posn1, posn2))
- event->modifiers |= click_modifier;
- else
- {
- button_down_time = 0;
- event->modifiers |= drag_modifier;
- }
+ button_down_time = 0;
+ event->modifiers |= drag_modifier;
}
/* Don't check is_double; treat this as multiple
index of type `enum scroll_bar_part' which we can use as an
index in scroll_bar_parts to get the appropriate symbol. */
- case scroll_bar_click:
+ case SCROLL_BAR_CLICK_EVENT:
{
Lisp_Object position, head, window, portion_whole, part;
#endif /* USE_TOOLKIT_SCROLL_BARS */
#ifdef WINDOWSNT
- case w32_scroll_bar_click:
+ case W32_SCROLL_BAR_CLICK_EVENT:
{
int button = event->code;
int is_double;
Qnil));
}
}
- case mouse_wheel:
+ case MOUSE_WHEEL_EVENT:
{
int part;
FRAME_PTR f = XFRAME (event->frame_or_window);
&mouse_wheel_syms, 1);
return Fcons (head,
Fcons (position,
- Fcons (make_number (event->code),
- Qnil)));
+ /* Insert 1 here so event-click-count works. */
+ Fcons (make_number (1),
+ Fcons (make_number (event->code),
+ Qnil))));
}
}
#endif /* WINDOWSNT */
- case drag_n_drop:
+ case DRAG_N_DROP_EVENT:
{
int part;
FRAME_PTR f;
}
#endif /* HAVE_MOUSE */
-#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
+#if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS)
case MENU_BAR_EVENT:
if (EQ (event->arg, event->frame_or_window))
/* This is the prefix key. We translate this to
case TOOL_BAR_EVENT:
if (EQ (event->arg, event->frame_or_window))
/* This is the prefix key. We translate this to
- `(tool_bar)' because the code in keyboard.c for menu
+ `(tool_bar)' because the code in keyboard.c for tool bar
events, which we use, relies on this. */
return Fcons (Qtool_bar, Qnil);
else if (SYMBOLP (event->arg))
/* A user signal. */
return *lispy_user_signals[event->code];
+ case SAVE_SESSION_EVENT:
+ return Qsave_session;
+
/* The 'kind' field of the event is something we don't recognize. */
default:
abort ();
int i;
int modifiers;
- CHECK_SYMBOL (symbol, 1);
+ CHECK_SYMBOL (symbol);
modifiers = 0;
- name = XSYMBOL (symbol)->name;
+ name = XSTRING (SYMBOL_NAME (symbol));
for (i = 0; i+2 <= STRING_BYTES (name); )
{
Lisp_Object unmodified;
Lisp_Object mask;
- unmodified = Fintern (make_string (XSYMBOL (symbol)->name->data + end,
- STRING_BYTES (XSYMBOL (symbol)->name) - end),
+ unmodified = Fintern (make_string (XSTRING (SYMBOL_NAME (symbol))->data + end,
+ STRING_BYTES (XSTRING (SYMBOL_NAME (symbol))) - end),
Qnil);
- if (modifiers & ~(((EMACS_INT)1 << VALBITS) - 1))
+ if (modifiers & ~VALMASK)
abort ();
XSETFASTINT (mask, modifiers);
elements = Fcons (unmodified, Fcons (mask, Qnil));
Lisp_Object cache, index, entry, new_symbol;
/* Mask out upper bits. We don't know where this value's been. */
- modifiers &= ((EMACS_INT)1 << VALBITS) - 1;
+ modifiers &= VALMASK;
/* The click modifier never figures into cache indices. */
cache = Fget (base, Qmodifier_cache);
{
/* We have to create the symbol ourselves. */
new_symbol = apply_modifiers_uncached (modifiers,
- XSYMBOL (base)->name->data,
- XSYMBOL (base)->name->size,
- STRING_BYTES (XSYMBOL (base)->name));
+ XSTRING (SYMBOL_NAME (base))->data,
+ XSTRING (SYMBOL_NAME (base))->size,
+ STRING_BYTES (XSTRING (SYMBOL_NAME (base))));
/* Add the new symbol to the base's cache. */
entry = Fcons (index, new_symbol);
event type as a number or a symbol. */
DEFUN ("event-convert-list", Fevent_convert_list, Sevent_convert_list, 1, 1, 0,
- "Convert the event description list EVENT-DESC to an event type.\n\
-EVENT-DESC should contain one base event type (a character or symbol)\n\
-and zero or more modifier names (control, meta, hyper, super, shift, alt,\n\
-drag, down, double or triple). The base must be last.\n\
-The return value is an event type (a character or symbol) which\n\
-has the same base event type and all the specified modifiers.")
- (event_desc)
+ doc: /* Convert the event description list EVENT-DESC to an event type.
+EVENT-DESC should contain one base event type (a character or symbol)
+and zero or more modifier names (control, meta, hyper, super, shift, alt,
+drag, down, double or triple). The base must be last.
+The return value is an event type (a character or symbol) which
+has the same base event type and all the specified modifiers. */)
+ (event_desc)
Lisp_Object event_desc;
{
Lisp_Object base;
}
/* Let the symbol A refer to the character A. */
- if (SYMBOLP (base) && XSYMBOL (base)->name->size == 1)
- XSETINT (base, XSYMBOL (base)->name->data[0]);
+ if (SYMBOLP (base) && XSTRING (SYMBOL_NAME (base))->size == 1)
+ XSETINT (base, XSTRING (SYMBOL_NAME (base))->data[0]);
if (INTEGERP (base))
{
parse_solitary_modifier (symbol)
Lisp_Object symbol;
{
- struct Lisp_String *name = XSYMBOL (symbol)->name;
+ struct Lisp_String *name = XSTRING (SYMBOL_NAME (symbol));
switch (name->data[0])
{
but works even if FIONREAD does not exist.
(In fact, this may actually read some input.)
- If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
+ If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
+ If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
static void
-get_input_pending (addr, do_timers_now)
+get_filtered_input_pending (addr, do_timers_now, filter_events)
int *addr;
int do_timers_now;
+ int filter_events;
{
/* First of all, have we already counted some input? */
- *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
+ *addr = (!NILP (Vquit_flag)
+ || readable_filtered_events (do_timers_now, filter_events));
/* If input is being read as it arrives, and we have none, there is none. */
if (*addr > 0 || (interrupt_input && ! interrupts_deferred))
/* Try to read some input and see how much we get. */
gobble_input (0);
- *addr = !NILP (Vquit_flag) || readable_events (do_timers_now);
+ *addr = (!NILP (Vquit_flag)
+ || readable_filtered_events (do_timers_now, filter_events));
+}
+
+/* Store into *addr a value nonzero if terminal input chars are available.
+ Serves the purpose of ioctl (0, FIONREAD, addr)
+ but works even if FIONREAD does not exist.
+ (In fact, this may actually read some input.)
+
+ If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
+
+static void
+get_input_pending (addr, do_timers_now)
+ int *addr;
+ int do_timers_now;
+{
+ get_filtered_input_pending (addr, do_timers_now, 0);
}
/* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
#endif
}
-/* Put a buffer_switch_event in the buffer
+/* Put a BUFFER_SWITCH_EVENT in the buffer
so that read_key_sequence will notice the new current buffer. */
void
struct input_event event;
Lisp_Object tem;
- event.kind = buffer_switch_event;
+ event.kind = BUFFER_SWITCH_EVENT;
event.frame_or_window = Qnil;
event.arg = Qnil;
#endif /* no FIONREAD */
for (i = 0; i < nread; i++)
{
- buf[i].kind = ascii_keystroke;
+ buf[i].kind = ASCII_KEYSTROKE_EVENT;
buf[i].modifiers = 0;
if (meta_key == 1 && (cbuf[i] & 0x80))
buf[i].modifiers = meta_modifier;
kbd_buffer_store_event (&buf[i]);
/* Don't look at input that follows a C-g too closely.
This reduces lossage due to autorepeat on C-g. */
- if (buf[i].kind == ascii_keystroke
+ if (buf[i].kind == ASCII_KEYSTROKE_EVENT
&& buf[i].code == quit_char)
break;
}
\f
-/* Return the prompt-string of a sparse keymap.
- This is the first element which is a string.
- Return nil if there is none. */
-
-Lisp_Object
-map_prompt (map)
- Lisp_Object map;
-{
- while (CONSP (map))
- {
- register Lisp_Object tem;
- tem = Fcar (map);
- if (STRINGP (tem))
- return tem;
- map = Fcdr (map);
- }
- return Qnil;
-}
-
static void menu_bar_item P_ ((Lisp_Object, Lisp_Object));
static void menu_bar_one_keymap P_ ((Lisp_Object));
}
else
{
- /* No, so use major and minor mode keymaps and keymap property. */
- int extra_maps = 2;
- Lisp_Object map = get_local_map (PT, current_buffer, Qkeymap);
- if (!NILP (map))
- extra_maps = 3;
- nmaps = current_minor_maps (NULL, &tmaps);
- maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
- * sizeof (maps[0]));
- bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
- if (!NILP (map))
- maps[nmaps++] = map;
+ /* No, so use major and minor mode keymaps and keymap property.
+ Note that menu-bar bindings in the local-map and keymap
+ properties may not work reliable, as they are only
+ recognized when the menu-bar (or mode-line) is updated,
+ which does not normally happen after every command. */
+ Lisp_Object tem;
+ int nminor;
+ nminor = current_minor_maps (NULL, &tmaps);
+ maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
+ nmaps = 0;
+ if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
+ maps[nmaps++] = tem;
+ bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+ nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
maps[nmaps++] = current_global_map;
AREF (item_properties, ITEM_PROPERTY_DEF) = def;
}
- /* If we got no definition, this item is just unselectable text which
- is OK in a submenu but not in the menubar. */
- if (NILP (def))
- return (inmenubar ? 0 : 1);
-
/* Enable or disable selection of item. */
tem = AREF (item_properties, ITEM_PROPERTY_ENABLE);
if (!EQ (tem, Qt))
AREF (item_properties, ITEM_PROPERTY_ENABLE) = tem;
}
+ /* If we got no definition, this item is just unselectable text which
+ is OK in a submenu but not in the menubar. */
+ if (NILP (def))
+ return (inmenubar ? 0 : 1);
+
/* See if this is a separate pane or a submenu. */
def = AREF (item_properties, ITEM_PROPERTY_DEF);
tem = get_keymap (def, 0, 1);
{
/* We have to create a cachelist. */
CHECK_IMPURE (start);
- XCDR (start) = Fcons (Fcons (Qnil, Qnil), XCDR (start));
+ XSETCDR (start, Fcons (Fcons (Qnil, Qnil), XCDR (start)));
cachelist = XCAR (XCDR (start));
newcache = 1;
tem = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
if (!NILP (keyhint))
{
- XCAR (cachelist) = XCAR (keyhint);
+ XSETCAR (cachelist, XCAR (keyhint));
newcache = 0;
}
else if (STRINGP (tem))
{
- XCDR (cachelist) = Fsubstitute_command_keys (tem);
- XCAR (cachelist) = Qt;
+ XSETCDR (cachelist, Fsubstitute_command_keys (tem));
+ XSETCAR (cachelist, Qt);
}
}
Lisp_Object prefix;
if (!NILP (tem))
- tem = Fkey_binding (tem, Qnil);
+ tem = Fkey_binding (tem, Qnil, Qnil);
prefix = AREF (item_properties, ITEM_PROPERTY_KEYEQ);
if (CONSP (prefix))
&& SYMBOLP (XSYMBOL (def)->function)
&& ! NILP (Fget (def, Qmenu_alias)))
def = XSYMBOL (def)->function;
- tem = Fwhere_is_internal (def, Qnil, Qt, Qnil);
- XCAR (cachelist) = tem;
+ tem = Fwhere_is_internal (def, Qnil, Qt, Qnil, Qt);
+ XSETCAR (cachelist, tem);
if (NILP (tem))
{
- XCDR (cachelist) = Qnil;
+ XSETCDR (cachelist, Qnil);
chkcache = 0;
}
}
if (STRINGP (XCDR (prefix)))
tem = concat2 (tem, XCDR (prefix));
}
- XCDR (cachelist) = tem;
+ XSETCDR (cachelist, tem);
}
}
if (newcache && !NILP (tem))
{
tem = concat3 (build_string (" ("), tem, build_string (")"));
- XCDR (cachelist) = tem;
+ XSETCDR (cachelist, tem);
}
/* If we only want to precompute equivalent key bindings, stop here. */
***********************************************************************/
/* A vector holding tool bar items while they are parsed in function
- tool_bar_items runs Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
+ tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
in the vector. */
static Lisp_Object tool_bar_items_vector;
int nmaps, i;
Lisp_Object oquit;
Lisp_Object *tmaps;
- extern Lisp_Object Voverriding_local_map_menu_flag;
- extern Lisp_Object Voverriding_local_map;
*nitems = 0;
}
else
{
- /* No, so use major and minor mode keymaps and keymap property. */
- int extra_maps = 2;
- Lisp_Object map = get_local_map (PT, current_buffer, Qkeymap);
- if (!NILP (map))
- extra_maps = 3;
- nmaps = current_minor_maps (NULL, &tmaps);
- maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
- * sizeof (maps[0]));
- bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
- if (!NILP (map))
- maps[nmaps++] = map;
+ /* No, so use major and minor mode keymaps and keymap property.
+ Note that tool-bar bindings in the local-map and keymap
+ properties may not work reliable, as they are only
+ recognized when the tool-bar (or mode-line) is updated,
+ which does not normally happen after every command. */
+ Lisp_Object tem;
+ int nminor;
+ nminor = current_minor_maps (NULL, &tmaps);
+ maps = (Lisp_Object *) alloca ((nminor + 3) * sizeof (maps[0]));
+ nmaps = 0;
+ if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
+ maps[nmaps++] = tem;
+ bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
+ nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
Lisp_Object filter = Qnil;
Lisp_Object caption;
- extern Lisp_Object QCenable, QCvisible, QChelp, QCfilter;
- extern Lisp_Object QCbutton, QCtoggle, QCradio;
int i;
/* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
&& (CONSP (value)
|| (VECTORP (value) && XVECTOR (value)->size == 4)))
/* Value is either a single image specification or a vector
- of 4 such specifications for the different buttion states. */
+ of 4 such specifications for the different button states. */
PROP (TOOL_BAR_ITEM_IMAGES) = value;
}
/* Get the menu name from the first map that has one (a prompt string). */
for (mapno = 0; mapno < nmaps; mapno++)
{
- name = map_prompt (maps[mapno]);
+ name = Fkeymap_prompt (maps[mapno]);
if (!NILP (name))
break;
}
/* If we don't have any menus, just read a character normally. */
- if (mapno >= nmaps)
+ if (!STRINGP (name))
return Qnil;
#ifdef HAVE_MENUS
record_menu_key (XCAR (tem));
if (SYMBOLP (XCAR (tem))
|| INTEGERP (XCAR (tem)))
- XCAR (tem) = Fcons (XCAR (tem), Qdisabled);
+ XSETCAR (tem, Fcons (XCAR (tem), Qdisabled));
}
/* If we got more than one event, put all but the first
char *menu;
vector = Qnil;
+ name = Qnil;
if (! menu_prompting)
return Qnil;
/* Get the menu name from the first map that has one (a prompt string). */
for (mapno = 0; mapno < nmaps; mapno++)
{
- name = map_prompt (maps[mapno]);
+ name = Fkeymap_prompt (maps[mapno]);
if (!NILP (name))
break;
}
/* If we don't have any menus, just read a character normally. */
- if (mapno >= nmaps)
+ if (!STRINGP (name))
return Qnil;
/* Prompt string always starts with map's prompt, and a space. */
if (! char_matches)
desc = Fsingle_key_description (event, Qnil);
+#if 0 /* It is redundant to list the equivalent key bindings because
+ the prefix is what the user has already typed. */
tem
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_KEYEQ];
if (!NILP (tem))
/* Insert equivalent keybinding. */
s = concat2 (s, tem);
-
+#endif
tem
= XVECTOR (item_properties)->contents[ITEM_PROPERTY_TYPE];
if (EQ (tem, QCradio) || EQ (tem, QCtoggle))
this key sequence. In other words, the lowest i such that
defs[i] is non-nil. */
volatile int first_binding;
+ /* Index of the first key that has no binding.
+ It is useless to try fkey_start larger than that. */
+ volatile int first_unbound;
/* If t < mock_input, then KEYBUF[t] should be read as the next
input key.
struct buffer *starting_buffer;
- /* Nonzero if we seem to have got the beginning of a binding
- in function_key_map. */
- volatile int function_key_possible = 0;
- volatile int key_translation_possible = 0;
-
/* List of events for which a fake prefix key has been generated. */
volatile Lisp_Object fake_prefixed_keys = Qnil;
- /* Save the status of key translation before each step,
- so that we can restore this after downcasing. */
- Lisp_Object prev_fkey_map;
- int prev_fkey_start;
- int prev_fkey_end;
-
- Lisp_Object prev_keytran_map;
- int prev_keytran_start;
- int prev_keytran_end;
-
#if defined (GOBBLE_FIRST_EVENT)
int junk;
#endif
replay_sequence:
starting_buffer = current_buffer;
- function_key_possible = 0;
- key_translation_possible = 0;
+ first_unbound = bufsize + 1;
/* Build our list of keymaps.
If we recognize a function key and replace its escape sequence in
keybuf with its symbol, or if the sequence starts with a mouse
click and we need to switch buffers, we jump back here to rebuild
the initial keymaps from the current buffer. */
- {
- Lisp_Object *maps;
+ nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map)
- || !NILP (Voverriding_local_map))
- {
- if (3 > nmaps_allocated)
- {
- submaps = (Lisp_Object *) alloca (3 * sizeof (submaps[0]));
- defs = (Lisp_Object *) alloca (3 * sizeof (defs[0]));
- nmaps_allocated = 3;
- }
- nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
- if (!NILP (Voverriding_local_map))
- submaps[nmaps++] = Voverriding_local_map;
- }
- else
- {
- int extra_maps = 2;
- nmaps = current_minor_maps (0, &maps);
- if (!NILP (orig_keymap))
- extra_maps = 3;
- if (nmaps + extra_maps > nmaps_allocated)
- {
- submaps = (Lisp_Object *) alloca ((nmaps+extra_maps)
- * sizeof (submaps[0]));
- defs = (Lisp_Object *) alloca ((nmaps+extra_maps)
- * sizeof (defs[0]));
- nmaps_allocated = nmaps + extra_maps;
- }
- bcopy (maps, (void *) submaps, nmaps * sizeof (submaps[0]));
- if (!NILP (orig_keymap))
- submaps[nmaps++] = orig_keymap;
- submaps[nmaps++] = orig_local_map;
- }
- submaps[nmaps++] = current_global_map;
- }
+ if (!NILP (current_kboard->Voverriding_terminal_local_map)
+ || !NILP (Voverriding_local_map))
+ {
+ if (3 > nmaps_allocated)
+ {
+ submaps = (Lisp_Object *) alloca (3 * sizeof (submaps[0]));
+ defs = (Lisp_Object *) alloca (3 * sizeof (defs[0]));
+ nmaps_allocated = 3;
+ }
+ if (!NILP (current_kboard->Voverriding_terminal_local_map))
+ submaps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
+ if (!NILP (Voverriding_local_map))
+ submaps[nmaps++] = Voverriding_local_map;
+ }
+ else
+ {
+ int nminor;
+ int total;
+ Lisp_Object *maps;
+
+ nminor = current_minor_maps (0, &maps);
+ total = nminor + (!NILP (orig_keymap) ? 3 : 2);
+
+ if (total > nmaps_allocated)
+ {
+ submaps = (Lisp_Object *) alloca (total * sizeof (submaps[0]));
+ defs = (Lisp_Object *) alloca (total * sizeof (defs[0]));
+ nmaps_allocated = total;
+ }
+
+ if (!NILP (orig_keymap))
+ submaps[nmaps++] = orig_keymap;
+
+ bcopy (maps, (void *) (submaps + nmaps),
+ nminor * sizeof (submaps[0]));
+
+ nmaps += nminor;
+
+ submaps[nmaps++] = orig_local_map;
+ }
+ submaps[nmaps++] = current_global_map;
/* Find an accurate initial value for first_binding. */
for (first_binding = 0; first_binding < nmaps; first_binding++)
we may be looking at a function key's escape sequence, keep on
reading. */
while ((first_binding < nmaps && ! NILP (submaps[first_binding]))
- || (first_binding >= nmaps
- && fkey_start < t
- /* mock input is never part of a function key's sequence. */
- && mock_input <= fkey_start)
- || (first_binding >= nmaps
- && keytran_start < t && key_translation_possible)
+ || (first_binding >= nmaps && fkey_start < t)
+ || (first_binding >= nmaps && keytran_start < t)
/* Don't return in the middle of a possible function key sequence,
if the only bindings we found were via case conversion.
Thus, if ESC O a has a function-key-map translation
just one key. */
volatile int echo_local_start, keys_local_start, local_first_binding;
+ /* key-translation-map is applied *after* function-key-map. */
+ eassert (keytran_end <= fkey_start);
+
+ if (first_unbound < fkey_start && first_unbound < keytran_start)
+ { /* The prefix upto first_unbound has no binding and has
+ no translation left to do either, so we know it's unbound.
+ If we don't stop now, we risk staying here indefinitely
+ (if the user keeps entering fkey or keytran prefixes
+ like C-c ESC ESC ESC ESC ...) */
+ int i;
+ for (i = first_unbound + 1; i < t; i++)
+ keybuf[i - first_unbound - 1] = keybuf[i];
+ mock_input = t - first_unbound - 1;
+ fkey_end = fkey_start -= first_unbound + 1;
+ fkey_map = Vfunction_key_map;
+ keytran_end = keytran_start -= first_unbound + 1;
+ keytran_map = Vkey_translation_map;
+ goto replay_sequence;
+ }
+
if (t >= bufsize)
error ("Key sequence too long");
keymap may have changed, so replay the sequence. */
if (BUFFERP (key))
{
+ EMACS_TIME initial_idleness_start_time
+ = timer_last_idleness_start_time;
+
+ /* Resume idle state, using the same start-time as before. */
+ timer_start_idle ();
+ timer_idleness_start_time = initial_idleness_start_time;
+
mock_input = t;
/* Reset the current buffer from the selected window
in case something changed the former and not the latter.
/* Zap the position in key, so we know that we've
expanded it, and don't try to do so again. */
- POSN_BUFFER_POSN (EVENT_START (key))
- = Fcons (posn, Qnil);
+ POSN_BUFFER_SET_POSN (EVENT_START (key),
+ Fcons (posn, Qnil));
mock_input = t + 2;
goto replay_sequence;
+ first_binding);
/* If KEY wasn't bound, we'll try some fallbacks. */
- if (first_binding >= nmaps)
+ if (first_binding < nmaps)
+ /* This is needed for the following scenario:
+ event 0: a down-event that gets dropped by calling replay_key.
+ event 1: some normal prefix like C-h.
+ After event 0, first_unbound is 0, after event 1 fkey_start
+ and keytran_start are both 1, so when we see that C-h is bound,
+ we need to update first_unbound. */
+ first_unbound = max (t + 1, first_unbound);
+ else
{
Lisp_Object head;
+
+ /* Remember the position to put an upper bound on fkey_start. */
+ first_unbound = min (t, first_unbound);
head = EVENT_HEAD (key);
if (help_char_p (head) && t > 0)
generate mouse events, so it's okay to zero
mock_input in that case too.
+ FIXME: The above paragraph seems just plain
+ wrong, if you consider things like
+ xterm-mouse-mode. -stef
+
Isn't this just the most wonderful code ever? */
if (t == last_real_key_start)
{
/* Record what part of this_command_keys is the current key sequence. */
this_single_command_key_start = this_command_key_count - t;
- prev_fkey_map = fkey_map;
- prev_fkey_start = fkey_start;
- prev_fkey_end = fkey_end;
-
- prev_keytran_map = keytran_map;
- prev_keytran_start = keytran_start;
- prev_keytran_end = keytran_end;
-
- /* If the sequence is unbound, see if we can hang a function key
- off the end of it. We only want to scan real keyboard input
- for function key sequences, so if mock_input says that we're
- re-reading old events, don't examine it. */
- if (first_binding >= nmaps
- && t >= mock_input)
+ if (first_binding < nmaps && NILP (submaps[first_binding]))
+ /* There is a binding and it's not a prefix.
+ There is thus no function-key in this sequence.
+ Moving fkey.start is important in this case to allow keytran.start
+ to go over the sequence before we return (since we keep the
+ invariant that keytran.end <= fkey.start). */
+ {
+ if (fkey_start < t)
+ (fkey_start = fkey_end = t, fkey_map = Vfunction_key_map);
+ }
+ else
+ /* If the sequence is unbound, see if we can hang a function key
+ off the end of it. */
{
Lisp_Object fkey_next;
/* Continue scan from fkey_end until we find a bound suffix.
- If we fail, increment fkey_start
- and start fkey_end from there. */
+ If we fail, increment fkey_start and start over from there. */
while (fkey_end < t)
{
Lisp_Object key;
key = keybuf[fkey_end++];
- fkey_next
- = access_keymap (fkey_map, key, 1, 0, 1);
+ fkey_next = access_keymap (fkey_map, key, 1, 0, 1);
/* Handle symbol with autoload definition. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
array, then call the function with no args and use
its value instead. */
if (SYMBOLP (fkey_next) && ! NILP (Ffboundp (fkey_next))
- && fkey_end == t)
+ /* If there's a binding (i.e. first_binding >= nmaps)
+ we don't want to apply this function-key-mapping. */
+ && fkey_end == t && first_binding >= nmaps)
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
error ("Function in key-translation-map returns invalid key sequence");
}
- function_key_possible = ! NILP (fkey_next);
-
/* If keybuf[fkey_start..fkey_end] is bound in the
function key map and it's a suffix of the current
sequence (i.e. fkey_end == t), replace it with
the binding and restart with fkey_start at the end. */
if ((VECTORP (fkey_next) || STRINGP (fkey_next))
- && fkey_end == t)
+ /* If there's a binding (i.e. first_binding >= nmaps)
+ we don't want to apply this function-key-mapping. */
+ && fkey_end == t && first_binding >= nmaps)
{
int len = XFASTINT (Flength (fkey_next));
{
fkey_end = ++fkey_start;
fkey_map = Vfunction_key_map;
- function_key_possible = 0;
}
}
}
Lisp_Object keytran_next;
/* Scan from keytran_end until we find a bound suffix. */
- while (keytran_end < t)
+ while (keytran_end < fkey_start)
{
Lisp_Object key;
/* If the key translation map gives a function, not an
array, then call the function with one arg and use
its value instead. */
- if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next))
- && keytran_end == t)
+ if (SYMBOLP (keytran_next) && ! NILP (Ffboundp (keytran_next)))
{
struct gcpro gcpro1, gcpro2, gcpro3;
Lisp_Object tem;
error ("Function in key-translation-map returns invalid key sequence");
}
- key_translation_possible = ! NILP (keytran_next);
-
/* If keybuf[keytran_start..keytran_end] is bound in the
key translation map and it's a suffix of the current
sequence (i.e. keytran_end == t), replace it with
the binding and restart with keytran_start at the end. */
- if ((VECTORP (keytran_next) || STRINGP (keytran_next))
- && keytran_end == t)
+ if ((VECTORP (keytran_next) || STRINGP (keytran_next)))
{
int len = XFASTINT (Flength (keytran_next));
+ int i, diff = len - (keytran_end - keytran_start);
- t = keytran_start + len;
- if (t >= bufsize)
+ mock_input = max (t, mock_input);
+ if (mock_input + diff >= bufsize)
error ("Key sequence too long");
- if (VECTORP (keytran_next))
- bcopy (XVECTOR (keytran_next)->contents,
- keybuf + keytran_start,
- (t - keytran_start) * sizeof (keybuf[0]));
- else if (STRINGP (keytran_next))
- {
- int i;
-
- for (i = 0; i < len; i++)
- XSETFASTINT (keybuf[keytran_start + i],
- XSTRING (keytran_next)->data[i]);
- }
-
- mock_input = t;
- keytran_start = keytran_end = t;
+ /* Shift the keys that are after keytran_end. */
+ if (diff < 0)
+ for (i = keytran_end; i < mock_input; i++)
+ keybuf[i + diff] = keybuf[i];
+ else if (diff > 0)
+ for (i = mock_input - 1; i >= keytran_end; i--)
+ keybuf[i + diff] = keybuf[i];
+ /* Replace the keys between keytran_start and keytran_end
+ with those from keytran_next. */
+ for (i = 0; i < len; i++)
+ keybuf[keytran_start + i]
+ = Faref (keytran_next, make_number (i));
+
+ mock_input += diff;
+ keytran_start = keytran_end += diff;
keytran_map = Vkey_translation_map;
- /* Don't pass the results of key-translation-map
- through function-key-map. */
- fkey_start = fkey_end = t;
- fkey_map = Vfunction_key_map;
+ /* Adjust the function-key-map counters. */
+ fkey_start += diff;
+ fkey_end += diff;
goto replay_sequence;
}
{
keytran_end = ++keytran_start;
keytran_map = Vkey_translation_map;
- key_translation_possible = 0;
}
}
}
and cannot be part of a function key or translation,
and is an upper case letter
use the corresponding lower-case letter instead. */
- if (first_binding == nmaps && ! function_key_possible
- && ! key_translation_possible
+ if (first_binding >= nmaps
+ && fkey_start >= t && keytran_start >= t
&& INTEGERP (key)
&& ((((XINT (key) & 0x3ffff)
< XCHAR_TABLE (current_buffer->downcase_table)->size)
the lower-case char is defined in the keymaps, because they
might get translated through function-key-map. */
keybuf[t - 1] = new_key;
- mock_input = t;
-
- fkey_map = prev_fkey_map;
- fkey_start = prev_fkey_start;
- fkey_end = prev_fkey_end;
-
- keytran_map = prev_keytran_map;
- keytran_start = prev_keytran_start;
- keytran_end = prev_keytran_end;
+ mock_input = max (t, mock_input);
goto replay_sequence;
}
and cannot be part of a function key or translation,
and is a shifted function key,
use the corresponding unshifted function key instead. */
- if (first_binding == nmaps && ! function_key_possible
- && ! key_translation_possible
+ if (first_binding >= nmaps
+ && fkey_start >= t && keytran_start >= t
&& SYMBOLP (key))
{
Lisp_Object breakdown;
XCAR (breakdown));
keybuf[t - 1] = new_key;
- mock_input = t;
-
- fkey_map = prev_fkey_map;
- fkey_start = prev_fkey_start;
- fkey_end = prev_fkey_end;
-
- keytran_map = prev_keytran_map;
- keytran_start = prev_keytran_start;
- keytran_end = prev_keytran_end;
+ mock_input = max (t, mock_input);
goto replay_sequence;
}
return t;
}
-#if 0 /* This doc string is too long for some compilers.
- This commented-out definition serves for DOC. */
-DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 4, 0,
- "Read a sequence of keystrokes and return as a string or vector.\n\
-The sequence is sufficient to specify a non-prefix command in the\n\
-current local and global maps.\n\
-\n\
-First arg PROMPT is a prompt string. If nil, do not prompt specially.\n\
-Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos\n\
-as a continuation of the previous key.\n\
-\n\
-The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not\n\
-convert the last event to lower case. (Normally any upper case event\n\
-is converted to lower case if the original event is undefined and the lower\n\
-case equivalent is defined.) A non-nil value is appropriate for reading\n\
-a key sequence to be defined.\n\
-\n\
-A C-g typed while in this function is treated like any other character,\n\
-and `quit-flag' is not set.\n\
-\n\
-If the key sequence starts with a mouse click, then the sequence is read\n\
-using the keymaps of the buffer of the window clicked in, not the buffer\n\
-of the selected window as normal.\n\
-""\n\
-`read-key-sequence' drops unbound button-down events, since you normally\n\
-only care about the click or drag events which follow them. If a drag\n\
-or multi-click event is unbound, but the corresponding click event would\n\
-be bound, `read-key-sequence' turns the event into a click event at the\n\
-drag's starting position. This means that you don't have to distinguish\n\
-between click and drag, double, or triple events unless you want to.\n\
-\n\
-`read-key-sequence' prefixes mouse events on mode lines, the vertical\n\
-lines separating windows, and scroll bars with imaginary keys\n\
-`mode-line', `vertical-line', and `vertical-scroll-bar'.\n\
-\n\
-Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this\n\
-function will process a switch-frame event if the user switches frames\n\
-before typing anything. If the user switches frames in the middle of a\n\
-key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME\n\
-is nil, then the event will be put off until after the current key sequence.\n\
-\n\
-`read-key-sequence' checks `function-key-map' for function key\n\
-sequences, where they wouldn't conflict with ordinary bindings. See\n\
-`function-key-map' for more details.\n\
-\n\
-The optional fifth argument COMMAND-LOOP, if non-nil, means\n\
-that this key sequence is being read by something that will\n\
-read commands one after another. It should be nil if the caller\n\
-will read just one key sequence.")
- (prompt, continue_echo, dont_downcase_last, can_return_switch_frame, command-loop)
-#endif
-
DEFUN ("read-key-sequence", Fread_key_sequence, Sread_key_sequence, 1, 5, 0,
- 0)
+ doc: /* Read a sequence of keystrokes and return as a string or vector.
+The sequence is sufficient to specify a non-prefix command in the
+current local and global maps.
+
+First arg PROMPT is a prompt string. If nil, do not prompt specially.
+Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
+as a continuation of the previous key.
+
+The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
+convert the last event to lower case. (Normally any upper case event
+is converted to lower case if the original event is undefined and the lower
+case equivalent is defined.) A non-nil value is appropriate for reading
+a key sequence to be defined.
+
+A C-g typed while in this function is treated like any other character,
+and `quit-flag' is not set.
+
+If the key sequence starts with a mouse click, then the sequence is read
+using the keymaps of the buffer of the window clicked in, not the buffer
+of the selected window as normal.
+
+`read-key-sequence' drops unbound button-down events, since you normally
+only care about the click or drag events which follow them. If a drag
+or multi-click event is unbound, but the corresponding click event would
+be bound, `read-key-sequence' turns the event into a click event at the
+drag's starting position. This means that you don't have to distinguish
+between click and drag, double, or triple events unless you want to.
+
+`read-key-sequence' prefixes mouse events on mode lines, the vertical
+lines separating windows, and scroll bars with imaginary keys
+`mode-line', `vertical-line', and `vertical-scroll-bar'.
+
+Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
+function will process a switch-frame event if the user switches frames
+before typing anything. If the user switches frames in the middle of a
+key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
+is nil, then the event will be put off until after the current key sequence.
+
+`read-key-sequence' checks `function-key-map' for function key
+sequences, where they wouldn't conflict with ordinary bindings. See
+`function-key-map' for more details.
+
+The optional fifth argument COMMAND-LOOP, if non-nil, means
+that this key sequence is being read by something that will
+read commands one after another. It should be nil if the caller
+will read just one key sequence. */)
(prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
command_loop)
Lisp_Object prompt, continue_echo, dont_downcase_last;
int count = specpdl_ptr - specpdl;
if (!NILP (prompt))
- CHECK_STRING (prompt, 0);
+ CHECK_STRING (prompt);
QUIT;
specbind (Qinput_method_exit_on_first_char,
! NILP (can_return_switch_frame), 0);
#if 0 /* The following is fine for code reading a key sequence and
- then proceeding with a lenghty compuation, but it's not good
+ then proceeding with a lenghty computation, but it's not good
for code reading keys in a loop, like an input method. */
#ifdef HAVE_X_WINDOWS
if (display_hourglass_p)
DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
Sread_key_sequence_vector, 1, 5, 0,
- "Like `read-key-sequence' but always return a vector.")
- (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
- command_loop)
+ doc: /* Like `read-key-sequence' but always return a vector. */)
+ (prompt, continue_echo, dont_downcase_last, can_return_switch_frame,
+ command_loop)
Lisp_Object prompt, continue_echo, dont_downcase_last;
Lisp_Object can_return_switch_frame, command_loop;
{
int count = specpdl_ptr - specpdl;
if (!NILP (prompt))
- CHECK_STRING (prompt, 0);
+ CHECK_STRING (prompt);
QUIT;
specbind (Qinput_method_exit_on_first_char,
}
\f
DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
- "Execute CMD as an editor command.\n\
-CMD must be a symbol that satisfies the `commandp' predicate.\n\
-Optional second arg RECORD-FLAG non-nil\n\
-means unconditionally put this command in `command-history'.\n\
-Otherwise, that is done only if an arg is read using the minibuffer.\n\
-The argument KEYS specifies the value to use instead of (this-command-keys)\n\
-when reading the arguments; if it is nil, (this-command-keys) is used.\n\
-The argument SPECIAL, if non-nil, means that this command is executing\n\
-a special event, so ignore the prefix argument and don't clear it.")
+ doc: /* Execute CMD as an editor command.
+CMD must be a symbol that satisfies the `commandp' predicate.
+Optional second arg RECORD-FLAG non-nil
+means unconditionally put this command in `command-history'.
+Otherwise, that is done only if an arg is read using the minibuffer.
+The argument KEYS specifies the value to use instead of (this-command-keys)
+when reading the arguments; if it is nil, (this-command-keys) is used.
+The argument SPECIAL, if non-nil, means that this command is executing
+a special event, so ignore the prefix argument and don't clear it. */)
(cmd, record_flag, keys, special)
Lisp_Object cmd, record_flag, keys, special;
{
{
tem = Fnthcdr (Vhistory_length, Vcommand_history);
if (CONSP (tem))
- XCDR (tem) = Qnil;
+ XSETCDR (tem, Qnil);
}
}
\f
DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
- 1, 1, "P",
- "Read function name, then read its arguments and call it.")
- (prefixarg)
+ 1, 1, "P",
+ doc: /* Read function name, then read its arguments and call it. */)
+ (prefixarg)
Lisp_Object prefixarg;
{
Lisp_Object function;
char buf[40];
- Lisp_Object saved_keys;
+ int saved_last_point_position;
+ Lisp_Object saved_keys, saved_last_point_position_buffer;
Lisp_Object bindings, value;
- struct gcpro gcpro1, gcpro2;
+ struct gcpro gcpro1, gcpro2, gcpro3;
saved_keys = Fvector (this_command_key_count,
XVECTOR (this_command_keys)->contents);
+ saved_last_point_position_buffer = last_point_position_buffer;
+ saved_last_point_position = last_point_position;
buf[0] = 0;
- GCPRO2 (saved_keys, prefixarg);
+ GCPRO3 (saved_keys, prefixarg, saved_last_point_position_buffer);
if (EQ (prefixarg, Qminus))
strcpy (buf, "- ");
add_command_key (make_number ('\015'));
}
+ last_point_position = saved_last_point_position;
+ last_point_position_buffer = saved_last_point_position_buffer;
+
UNGCPRO;
function = Fintern (function, Qnil);
&& NILP (Vexecuting_macro)
&& SYMBOLP (function))
bindings = Fwhere_is_internal (function, Voverriding_local_map,
- Qt, Qnil);
+ Qt, Qnil, Qnil);
else
bindings = Qnil;
binding = Fkey_description (bindings);
newmessage
- = (char *) alloca (XSYMBOL (function)->name->size
+ = (char *) alloca (XSTRING (SYMBOL_NAME (function))->size
+ STRING_BYTES (XSTRING (binding))
+ 100);
sprintf (newmessage, "You can run the command `%s' with %s",
- XSYMBOL (function)->name->data,
+ XSTRING (SYMBOL_NAME (function))->data,
XSTRING (binding)->data);
message2_nolog (newmessage,
strlen (newmessage),
RETURN_UNGCPRO (value);
}
-/* Find the set of keymaps now active.
- Store into *MAPS_P a vector holding the various maps
- and return the number of them. The vector was malloc'd
- and the caller should free it. */
-
-int
-current_active_maps (maps_p)
- Lisp_Object **maps_p;
-{
- Lisp_Object *tmaps, *maps;
- int nmaps;
-
- /* Should overriding-terminal-local-map and overriding-local-map apply? */
- if (!NILP (Voverriding_local_map_menu_flag))
- {
- /* Yes, use them (if non-nil) as well as the global map. */
- maps = (Lisp_Object *) xmalloc (3 * sizeof (maps[0]));
- nmaps = 0;
- if (!NILP (current_kboard->Voverriding_terminal_local_map))
- maps[nmaps++] = current_kboard->Voverriding_terminal_local_map;
- if (!NILP (Voverriding_local_map))
- maps[nmaps++] = Voverriding_local_map;
- }
- else
- {
- /* No, so use major and minor mode keymaps and keymap property. */
- int extra_maps = 2;
- Lisp_Object map = get_local_map (PT, current_buffer, Qkeymap);
- if (!NILP (map))
- extra_maps = 3;
- nmaps = current_minor_maps (NULL, &tmaps);
- maps = (Lisp_Object *) alloca ((nmaps + extra_maps)
- * sizeof (maps[0]));
- bcopy (tmaps, maps, nmaps * sizeof (maps[0]));
- if (!NILP (map))
- maps[nmaps++] = map;
- maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
- }
- maps[nmaps++] = current_global_map;
-
- *maps_p = maps;
- return nmaps;
-}
\f
/* Return nonzero if input events are pending. */
/* Return nonzero if there are pending requeued events.
This isn't used yet. The hope is to make wait_reading_process_input
- call it, and return return if it runs Lisp code that unreads something.
+ call it, and return if it runs Lisp code that unreads something.
The problem is, kbd_buffer_get_event needs to be fixed to know what
to do in that case. It isn't trivial. */
DEFUN ("input-pending-p", Finput_pending_p, Sinput_pending_p, 0, 0, 0,
- "T if command input is currently available with no waiting.\n\
-Actually, the value is nil only if we can be sure that no input is available.")
- ()
+ doc: /* Return t if command input is currently available with no wait.
+Actually, the value is nil only if we can be sure that no input is available;
+if there is a doubt, the value is t. */)
+ ()
{
if (!NILP (Vunread_command_events) || unread_command_char != -1)
return (Qt);
- get_input_pending (&input_pending, 1);
+ get_filtered_input_pending (&input_pending, 1, 1);
return input_pending > 0 ? Qt : Qnil;
}
DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
- "Return vector of last 100 events, not counting those from keyboard macros.")
- ()
+ doc: /* Return vector of last 100 events, not counting those from keyboard macros. */)
+ ()
{
Lisp_Object *keys = XVECTOR (recent_keys)->contents;
Lisp_Object val;
}
DEFUN ("this-command-keys", Fthis_command_keys, Sthis_command_keys, 0, 0, 0,
- "Return the key sequence that invoked this command.\n\
-The value is a string or a vector.")
- ()
+ doc: /* Return the key sequence that invoked this command.
+However, if the command has called `read-key-sequence', it returns
+the last key sequence that has been read.
+The value is a string or a vector. */)
+ ()
{
return make_event_array (this_command_key_count,
XVECTOR (this_command_keys)->contents);
}
DEFUN ("this-command-keys-vector", Fthis_command_keys_vector, Sthis_command_keys_vector, 0, 0, 0,
- "Return the key sequence that invoked this command, as a vector.")
- ()
+ doc: /* Return the key sequence that invoked this command, as a vector.
+However, if the command has called `read-key-sequence', it returns
+the last key sequence that has been read. */)
+ ()
{
return Fvector (this_command_key_count,
XVECTOR (this_command_keys)->contents);
DEFUN ("this-single-command-keys", Fthis_single_command_keys,
Sthis_single_command_keys, 0, 0, 0,
- "Return the key sequence that invoked this command.\n\
-Unlike `this-command-keys', this function's value\n\
-does not include prefix arguments.\n\
-The value is always a vector.")
- ()
+ doc: /* Return the key sequence that invoked this command.
+More generally, it returns the last key sequence read, either by
+the command loop or by `read-key-sequence'.
+Unlike `this-command-keys', this function's value
+does not include prefix arguments.
+The value is always a vector. */)
+ ()
{
return Fvector (this_command_key_count
- this_single_command_key_start,
DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys,
Sthis_single_command_raw_keys, 0, 0, 0,
- "Return the raw events that were read for this command.\n\
-Unlike `this-single-command-keys', this function's value\n\
-shows the events before all translations (except for input methods).\n\
-The value is always a vector.")
- ()
+ doc: /* Return the raw events that were read for this command.
+More generally, it returns the last key sequence read, either by
+the command loop or by `read-key-sequence'.
+Unlike `this-single-command-keys', this function's value
+shows the events before all translations (except for input methods).
+The value is always a vector. */)
+ ()
{
return Fvector (raw_keybuf_count,
(XVECTOR (raw_keybuf)->contents));
}
DEFUN ("reset-this-command-lengths", Freset_this_command_lengths,
- Sreset_this_command_lengths, 0, 0, 0,
- "Used for complicated reasons in `universal-argument-other-key'.\n\
-\n\
-`universal-argument-other-key' rereads the event just typed.\n\
-It then gets translated through `function-key-map'.\n\
-The translated event gets included in the echo area and in\n\
-the value of `this-command-keys' in addition to the raw original event.\n\
-That is not right.\n\
-\n\
-Calling this function directs the translated event to replace\n\
-the original event, so that only one version of the event actually\n\
-appears in the echo area and in the value of `this-command-keys.'.")
- ()
+ Sreset_this_command_lengths, 0, 0, 0,
+ doc: /* Used for complicated reasons in `universal-argument-other-key'.
+
+`universal-argument-other-key' rereads the event just typed.
+It then gets translated through `function-key-map'.
+The translated event gets included in the echo area and in
+the value of `this-command-keys' in addition to the raw original event.
+That is not right.
+
+Calling this function directs the translated event to replace
+the original event, so that only one version of the event actually
+appears in the echo area and in the value of `this-command-keys'. */)
+ ()
{
before_command_restore_flag = 1;
before_command_key_count_1 = before_command_key_count;
}
DEFUN ("clear-this-command-keys", Fclear_this_command_keys,
- Sclear_this_command_keys, 0, 0, 0,
- "Clear out the vector that `this-command-keys' returns.\n\
-Clear vector containing last 100 events.")
- ()
+ Sclear_this_command_keys, 0, 0, 0,
+ doc: /* Clear out the vector that `this-command-keys' returns.
+Also clear the record of the last 100 events. */)
+ ()
{
int i;
}
DEFUN ("recursion-depth", Frecursion_depth, Srecursion_depth, 0, 0, 0,
- "Return the current depth in recursive edits.")
- ()
+ doc: /* Return the current depth in recursive edits. */)
+ ()
{
Lisp_Object temp;
XSETFASTINT (temp, command_loop_level + minibuf_level);
}
DEFUN ("open-dribble-file", Fopen_dribble_file, Sopen_dribble_file, 1, 1,
- "FOpen dribble file: ",
- "Start writing all keyboard characters to a dribble file called FILE.\n\
-If FILE is nil, close any open dribble file.")
- (file)
+ "FOpen dribble file: ",
+ doc: /* Start writing all keyboard characters to a dribble file called FILE.
+If FILE is nil, close any open dribble file. */)
+ (file)
Lisp_Object file;
{
if (dribble)
}
DEFUN ("discard-input", Fdiscard_input, Sdiscard_input, 0, 0, 0,
- "Discard the contents of the terminal input buffer.\n\
-Also cancel any kbd macro being defined.")
- ()
+ doc: /* Discard the contents of the terminal input buffer.
+Also cancel any kbd macro being defined. */)
+ ()
{
current_kboard->defining_kbd_macro = Qnil;
update_mode_lines++;
}
\f
DEFUN ("suspend-emacs", Fsuspend_emacs, Ssuspend_emacs, 0, 1, "",
- "Stop Emacs and return to superior process. You can resume later.\n\
-If `cannot-suspend' is non-nil, or if the system doesn't support job\n\
-control, run a subshell instead.\n\n\
-If optional arg STUFFSTRING is non-nil, its characters are stuffed\n\
-to be read as terminal input by Emacs's parent, after suspension.\n\
-\n\
-Before suspending, run the normal hook `suspend-hook'.\n\
-After resumption run the normal hook `suspend-resume-hook'.\n\
-\n\
-Some operating systems cannot stop the Emacs process and resume it later.\n\
-On such systems, Emacs starts a subshell instead of suspending.")
- (stuffstring)
+ doc: /* Stop Emacs and return to superior process. You can resume later.
+If `cannot-suspend' is non-nil, or if the system doesn't support job
+control, run a subshell instead.
+
+If optional arg STUFFSTRING is non-nil, its characters are stuffed
+to be read as terminal input by Emacs's parent, after suspension.
+
+Before suspending, run the normal hook `suspend-hook'.
+After resumption run the normal hook `suspend-resume-hook'.
+
+Some operating systems cannot stop the Emacs process and resume it later.
+On such systems, Emacs starts a subshell instead of suspending. */)
+ (stuffstring)
Lisp_Object stuffstring;
{
int count = specpdl_ptr - specpdl;
struct gcpro gcpro1;
if (!NILP (stuffstring))
- CHECK_STRING (stuffstring, 0);
+ CHECK_STRING (stuffstring);
/* Run the functions in suspend-hook. */
if (!NILP (Vrun_hooks))
if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
kbd_fetch_ptr = kbd_buffer;
- if (kbd_fetch_ptr->kind == ascii_keystroke)
+ if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
stuff_char (kbd_fetch_ptr->code);
- kbd_fetch_ptr->kind = no_event;
+ kbd_fetch_ptr->kind = NO_EVENT;
idx = 2 * (kbd_fetch_ptr - kbd_buffer);
ASET (kbd_buffer_gcpro, idx, Qnil);
ASET (kbd_buffer_gcpro, idx + 1, Qnil);
input_available_clear_time = 0;
}
-/* This routine is called at interrupt level in response to C-G.
+/* This routine is called at interrupt level in response to C-g.
If interrupt_input, this is the handler for SIGINT. Otherwise, it
is called from kbd_buffer_store_event, in handling SIGIO or
}
\f
DEFUN ("set-input-mode", Fset_input_mode, Sset_input_mode, 3, 4, 0,
- "Set mode of reading keyboard input.\n\
-First arg INTERRUPT non-nil means use input interrupts;\n\
- nil means use CBREAK mode.\n\
-Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal\n\
- (no effect except in CBREAK mode).\n\
-Third arg META t means accept 8-bit input (for a Meta key).\n\
- META nil means ignore the top bit, on the assumption it is parity.\n\
- Otherwise, accept 8-bit input and don't use the top bit for Meta.\n\
-Optional fourth arg QUIT if non-nil specifies character to use for quitting.\n\
-See also `current-input-mode'.")
- (interrupt, flow, meta, quit)
+ doc: /* Set mode of reading keyboard input.
+First arg INTERRUPT non-nil means use input interrupts;
+ nil means use CBREAK mode.
+Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
+ (no effect except in CBREAK mode).
+Third arg META t means accept 8-bit input (for a Meta key).
+ META nil means ignore the top bit, on the assumption it is parity.
+ Otherwise, accept 8-bit input and don't use the top bit for Meta.
+Optional fourth arg QUIT if non-nil specifies character to use for quitting.
+See also `current-input-mode'. */)
+ (interrupt, flow, meta, quit)
Lisp_Object interrupt, flow, meta, quit;
{
if (!NILP (quit)
}
DEFUN ("current-input-mode", Fcurrent_input_mode, Scurrent_input_mode, 0, 0, 0,
- "Return information about the way Emacs currently reads keyboard input.\n\
-The value is a list of the form (INTERRUPT FLOW META QUIT), where\n\
- INTERRUPT is non-nil if Emacs is using interrupt-driven input; if\n\
- nil, Emacs is using CBREAK mode.\n\
- FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the\n\
- terminal; this does not apply if Emacs uses interrupt-driven input.\n\
- META is t if accepting 8-bit input with 8th bit as Meta flag.\n\
- META nil means ignoring the top bit, on the assumption it is parity.\n\
- META is neither t nor nil if accepting 8-bit input and using\n\
- all 8 bits as the character code.\n\
- QUIT is the character Emacs currently uses to quit.\n\
-The elements of this list correspond to the arguments of\n\
-`set-input-mode'.")
- ()
+ doc: /* Return information about the way Emacs currently reads keyboard input.
+The value is a list of the form (INTERRUPT FLOW META QUIT), where
+ INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
+ nil, Emacs is using CBREAK mode.
+ FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
+ terminal; this does not apply if Emacs uses interrupt-driven input.
+ META is t if accepting 8-bit input with 8th bit as Meta flag.
+ META nil means ignoring the top bit, on the assumption it is parity.
+ META is neither t nor nil if accepting 8-bit input and using
+ all 8 bits as the character code.
+ QUIT is the character Emacs currently uses to quit.
+The elements of this list correspond to the arguments of
+`set-input-mode'. */)
+ ()
{
Lisp_Object val[4];
kb->kbd_queue = Qnil;
kb->kbd_queue_has_data = 0;
kb->immediate_echo = 0;
- kb->echoptr = kb->echobuf;
+ kb->echo_string = Qnil;
kb->echo_after_prompt = -1;
kb->kbd_macro_buffer = 0;
kb->kbd_macro_bufsize = 0;
};
struct event_head head_table[] = {
- &Qmouse_movement, "mouse-movement", &Qmouse_movement,
- &Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement,
- &Qswitch_frame, "switch-frame", &Qswitch_frame,
- &Qdelete_frame, "delete-frame", &Qdelete_frame,
- &Qiconify_frame, "iconify-frame", &Qiconify_frame,
- &Qmake_frame_visible, "make-frame-visible", &Qmake_frame_visible,
+ {&Qmouse_movement, "mouse-movement", &Qmouse_movement},
+ {&Qscroll_bar_movement, "scroll-bar-movement", &Qmouse_movement},
+ {&Qswitch_frame, "switch-frame", &Qswitch_frame},
+ {&Qdelete_frame, "delete-frame", &Qdelete_frame},
+ {&Qiconify_frame, "iconify-frame", &Qiconify_frame},
+ {&Qmake_frame_visible, "make-frame-visible", &Qmake_frame_visible},
+ {&Qselect_window, "select-window", &Qselect_window}
};
void
Qdrag_n_drop = intern ("drag-n-drop");
staticpro (&Qdrag_n_drop);
+ Qsave_session = intern ("save-session");
+ staticpro(&Qsave_session);
+
Qusr1_signal = intern ("usr1-signal");
staticpro (&Qusr1_signal);
Qusr2_signal = intern ("usr2-signal");
defsubr (&Sexecute_extended_command);
DEFVAR_LISP ("last-command-char", &last_command_char,
- "Last input event that was part of a command.");
+ doc: /* Last input event that was part of a command. */);
DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char,
- "Last input event that was part of a command.");
+ doc: /* Last input event that was part of a command. */);
DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event,
- "Last input event in a command, except for mouse menu events.\n\
-Mouse menus give back keys that don't look like mouse events;\n\
-this variable holds the actual mouse event that led to the menu,\n\
-so that you can determine whether the command was run by mouse or not.");
+ doc: /* Last input event in a command, except for mouse menu events.
+Mouse menus give back keys that don't look like mouse events;
+this variable holds the actual mouse event that led to the menu,
+so that you can determine whether the command was run by mouse or not. */);
DEFVAR_LISP ("last-input-char", &last_input_char,
- "Last input event.");
+ doc: /* Last input event. */);
DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char,
- "Last input event.");
+ doc: /* Last input event. */);
DEFVAR_LISP ("unread-command-events", &Vunread_command_events,
- "List of events to be read as the command input.\n\
-These events are processed first, before actual keyboard input.");
+ doc: /* List of events to be read as the command input.
+These events are processed first, before actual keyboard input. */);
Vunread_command_events = Qnil;
DEFVAR_INT ("unread-command-char", &unread_command_char,
- "If not -1, an object to be read as next command input event.");
+ doc: /* If not -1, an object to be read as next command input event. */);
DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events,
- "List of events to be processed as input by input methods.\n\
-These events are processed after `unread-command-events', but\n\
-before actual keyboard input.");
+ doc: /* List of events to be processed as input by input methods.
+These events are processed after `unread-command-events', but
+before actual keyboard input. */);
Vunread_post_input_method_events = Qnil;
DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events,
- "List of events to be processed as input by input methods.\n\
-These events are processed after `unread-command-events', but\n\
-before actual keyboard input.");
+ doc: /* List of events to be processed as input by input methods.
+These events are processed after `unread-command-events', but
+before actual keyboard input. */);
Vunread_input_method_events = Qnil;
DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char,
- "Meta-prefix character code.\n\
-Meta-foo as command input turns into this character followed by foo.");
+ doc: /* Meta-prefix character code.
+Meta-foo as command input turns into this character followed by foo. */);
XSETINT (meta_prefix_char, 033);
DEFVAR_KBOARD ("last-command", Vlast_command,
- "The last command executed.\n\
-Normally a symbol with a function definition, but can be whatever was found\n\
-in the keymap, or whatever the variable `this-command' was set to by that\n\
-command.\n\
-\n\
-The value `mode-exit' is special; it means that the previous command\n\
-read an event that told it to exit, and it did so and unread that event.\n\
-In other words, the present command is the event that made the previous\n\
-command exit.\n\
-\n\
-The value `kill-region' is special; it means that the previous command\n\
-was a kill command.");
+ doc: /* The last command executed.
+Normally a symbol with a function definition, but can be whatever was found
+in the keymap, or whatever the variable `this-command' was set to by that
+command.
+
+The value `mode-exit' is special; it means that the previous command
+read an event that told it to exit, and it did so and unread that event.
+In other words, the present command is the event that made the previous
+command exit.
+
+The value `kill-region' is special; it means that the previous command
+was a kill command. */);
DEFVAR_KBOARD ("real-last-command", Vreal_last_command,
- "Same as `last-command', but never altered by Lisp code.");
+ doc: /* Same as `last-command', but never altered by Lisp code. */);
DEFVAR_LISP ("this-command", &Vthis_command,
- "The command now being executed.\n\
-The command can set this variable; whatever is put here\n\
-will be in `last-command' during the following command.");
+ doc: /* The command now being executed.
+The command can set this variable; whatever is put here
+will be in `last-command' during the following command. */);
Vthis_command = Qnil;
+ DEFVAR_LISP ("this-original-command", &Vthis_original_command,
+ doc: /* If non-nil, the original command bound to the current key sequence.
+The value of `this-command' is the result of looking up the original
+command in the active keymaps. */);
+ Vthis_original_command = Qnil;
+
DEFVAR_INT ("auto-save-interval", &auto_save_interval,
- "*Number of input events between auto-saves.\n\
-Zero means disable autosaving due to number of characters typed.");
+ doc: /* *Number of input events between auto-saves.
+Zero means disable autosaving due to number of characters typed. */);
auto_save_interval = 300;
DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout,
- "*Number of seconds idle time before auto-save.\n\
-Zero or nil means disable auto-saving due to idleness.\n\
-After auto-saving due to this many seconds of idle time,\n\
-Emacs also does a garbage collection if that seems to be warranted.");
+ doc: /* *Number of seconds idle time before auto-save.
+Zero or nil means disable auto-saving due to idleness.
+After auto-saving due to this many seconds of idle time,
+Emacs also does a garbage collection if that seems to be warranted. */);
XSETFASTINT (Vauto_save_timeout, 30);
DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes,
- "*Nonzero means echo unfinished commands after this many seconds of pause.\n\
-The value may be integer or floating point.");
+ doc: /* *Nonzero means echo unfinished commands after this many seconds of pause.
+The value may be integer or floating point. */);
Vecho_keystrokes = make_number (1);
DEFVAR_INT ("polling-period", &polling_period,
- "*Interval between polling for input during Lisp execution.\n\
-The reason for polling is to make C-g work to stop a running program.\n\
-Polling is needed only when using X windows and SIGIO does not work.\n\
-Polling is automatically disabled in all other cases.");
+ doc: /* *Interval between polling for input during Lisp execution.
+The reason for polling is to make C-g work to stop a running program.
+Polling is needed only when using X windows and SIGIO does not work.
+Polling is automatically disabled in all other cases. */);
polling_period = 2;
DEFVAR_LISP ("double-click-time", &Vdouble_click_time,
- "*Maximum time between mouse clicks to make a double-click.\n\
-Measured in milliseconds. nil means disable double-click recognition;\n\
-t means double-clicks have no time limit and are detected\n\
-by position only.");
+ doc: /* *Maximum time between mouse clicks to make a double-click.
+Measured in milliseconds. nil means disable double-click recognition;
+t means double-clicks have no time limit and are detected
+by position only. */);
Vdouble_click_time = make_number (500);
DEFVAR_INT ("double-click-fuzz", &double_click_fuzz,
- "*Maximum mouse movement between clicks to make a double-click.\n\
-On window-system frames, value is the number of pixels the mouse may have\n\
-moved horizontally or vertically between two clicks to make a double-click.\n\
-On non window-system frames, value is interpreted in units of 1/8 characters\n\
-instead of pixels.");
+ doc: /* *Maximum mouse movement between clicks to make a double-click.
+On window-system frames, value is the number of pixels the mouse may have
+moved horizontally or vertically between two clicks to make a double-click.
+On non window-system frames, value is interpreted in units of 1/8 characters
+instead of pixels.
+
+This variable is also the threshold for motion of the mouse
+to count as a drag. */);
double_click_fuzz = 3;
DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus,
- "*Non-nil means inhibit local map menu bar menus.");
+ doc: /* *Non-nil means inhibit local map menu bar menus. */);
inhibit_local_menu_bar_menus = 0;
DEFVAR_INT ("num-input-keys", &num_input_keys,
- "Number of complete key sequences read as input so far.\n\
-This includes key sequences read from keyboard macros.\n\
-The number is effectively the number of interactive command invocations.");
+ doc: /* Number of complete key sequences read as input so far.
+This includes key sequences read from keyboard macros.
+The number is effectively the number of interactive command invocations. */);
num_input_keys = 0;
DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events,
- "Number of input events read from the keyboard so far.\n\
-This does not include events generated by keyboard macros.");
+ doc: /* Number of input events read from the keyboard so far.
+This does not include events generated by keyboard macros. */);
num_nonmacro_input_events = 0;
DEFVAR_LISP ("last-event-frame", &Vlast_event_frame,
- "The frame in which the most recently read event occurred.\n\
-If the last event came from a keyboard macro, this is set to `macro'.");
+ doc: /* The frame in which the most recently read event occurred.
+If the last event came from a keyboard macro, this is set to `macro'. */);
Vlast_event_frame = Qnil;
/* This variable is set up in sysdep.c. */
DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char,
- "The ERASE character as set by the user with stty.");
+ doc: /* The ERASE character as set by the user with stty. */);
DEFVAR_LISP ("help-char", &Vhelp_char,
- "Character to recognize as meaning Help.\n\
-When it is read, do `(eval help-form)', and display result if it's a string.\n\
-If the value of `help-form' is nil, this char can be read normally.");
+ doc: /* Character to recognize as meaning Help.
+When it is read, do `(eval help-form)', and display result if it's a string.
+If the value of `help-form' is nil, this char can be read normally. */);
XSETINT (Vhelp_char, Ctl ('H'));
DEFVAR_LISP ("help-event-list", &Vhelp_event_list,
- "List of input events to recognize as meaning Help.\n\
-These work just like the value of `help-char' (see that).");
+ doc: /* List of input events to recognize as meaning Help.
+These work just like the value of `help-char' (see that). */);
Vhelp_event_list = Qnil;
DEFVAR_LISP ("help-form", &Vhelp_form,
- "Form to execute when character `help-char' is read.\n\
-If the form returns a string, that string is displayed.\n\
-If `help-form' is nil, the help char is not recognized.");
+ doc: /* Form to execute when character `help-char' is read.
+If the form returns a string, that string is displayed.
+If `help-form' is nil, the help char is not recognized. */);
Vhelp_form = Qnil;
DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command,
- "Command to run when `help-char' character follows a prefix key.\n\
-This command is used only when there is no actual binding\n\
-for that character after that prefix key.");
+ doc: /* Command to run when `help-char' character follows a prefix key.
+This command is used only when there is no actual binding
+for that character after that prefix key. */);
Vprefix_help_command = Qnil;
DEFVAR_LISP ("top-level", &Vtop_level,
- "Form to evaluate when Emacs starts up.\n\
-Useful to set before you dump a modified Emacs.");
+ doc: /* Form to evaluate when Emacs starts up.
+Useful to set before you dump a modified Emacs. */);
Vtop_level = Qnil;
DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table,
- "Translate table for keyboard input, or nil.\n\
-Each character is looked up in this string and the contents used instead.\n\
-The value may be a string, a vector, or a char-table.\n\
-If it is a string or vector of length N,\n\
-character codes N and up are untranslated.\n\
-In a vector or a char-table, an element which is nil means \"no translation\".");
+ doc: /* Translate table for keyboard input, or nil.
+Each character is looked up in this string and the contents used instead.
+The value may be a string, a vector, or a char-table.
+If it is a string or vector of length N,
+character codes N and up are untranslated.
+In a vector or a char-table, an element which is nil means "no translation". */);
Vkeyboard_translate_table = Qnil;
DEFVAR_BOOL ("cannot-suspend", &cannot_suspend,
- "Non-nil means to always spawn a subshell instead of suspending.\n\
-\(Even if the operating system has support for stopping a process.\)");
+ doc: /* Non-nil means to always spawn a subshell instead of suspending.
+\(Even if the operating system has support for stopping a process.\) */);
cannot_suspend = 0;
DEFVAR_BOOL ("menu-prompting", &menu_prompting,
- "Non-nil means prompt with menus when appropriate.\n\
-This is done when reading from a keymap that has a prompt string,\n\
-for elements that have prompt strings.\n\
-The menu is displayed on the screen\n\
-if X menus were enabled at configuration\n\
-time and the previous event was a mouse click prefix key.\n\
-Otherwise, menu prompting uses the echo area.");
+ doc: /* Non-nil means prompt with menus when appropriate.
+This is done when reading from a keymap that has a prompt string,
+for elements that have prompt strings.
+The menu is displayed on the screen
+if X menus were enabled at configuration
+time and the previous event was a mouse click prefix key.
+Otherwise, menu prompting uses the echo area. */);
menu_prompting = 1;
DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char,
- "Character to see next line of menu prompt.\n\
-Type this character while in a menu prompt to rotate around the lines of it.");
+ doc: /* Character to see next line of menu prompt.
+Type this character while in a menu prompt to rotate around the lines of it. */);
XSETINT (menu_prompt_more_char, ' ');
DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers,
- "A mask of additional modifier keys to use with every keyboard character.\n\
-Emacs applies the modifiers of the character stored here to each keyboard\n\
-character it reads. For example, after evaluating the expression\n\
- (setq extra-keyboard-modifiers ?\\C-x)\n\
-all input characters will have the control modifier applied to them.\n\
-\n\
-Note that the character ?\\C-@, equivalent to the integer zero, does\n\
-not count as a control character; rather, it counts as a character\n\
-with no modifiers; thus, setting `extra-keyboard-modifiers' to zero\n\
-cancels any modification.");
+ doc: /* A mask of additional modifier keys to use with every keyboard character.
+Emacs applies the modifiers of the character stored here to each keyboard
+character it reads. For example, after evaluating the expression
+ (setq extra-keyboard-modifiers ?\\C-x)
+all input characters will have the control modifier applied to them.
+
+Note that the character ?\\C-@, equivalent to the integer zero, does
+not count as a control character; rather, it counts as a character
+with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
+cancels any modification. */);
extra_keyboard_modifiers = 0;
DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark,
- "If an editing command sets this to t, deactivate the mark afterward.\n\
-The command loop sets this to nil before each command,\n\
-and tests the value when the command returns.\n\
-Buffer modification stores t in this variable.");
+ doc: /* If an editing command sets this to t, deactivate the mark afterward.
+The command loop sets this to nil before each command,
+and tests the value when the command returns.
+Buffer modification stores t in this variable. */);
Vdeactivate_mark = Qnil;
DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
- "Temporary storage of pre-command-hook or post-command-hook.");
+ doc: /* Temporary storage of pre-command-hook or post-command-hook. */);
Vcommand_hook_internal = Qnil;
DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook,
- "Normal hook run before each command is executed.\n\
-If an unhandled error happens in running this hook,\n\
-the hook value is set to nil, since otherwise the error\n\
-might happen repeatedly and make Emacs nonfunctional.");
+ doc: /* Normal hook run before each command is executed.
+If an unhandled error happens in running this hook,
+the hook value is set to nil, since otherwise the error
+might happen repeatedly and make Emacs nonfunctional. */);
Vpre_command_hook = Qnil;
DEFVAR_LISP ("post-command-hook", &Vpost_command_hook,
- "Normal hook run after each command is executed.\n\
-If an unhandled error happens in running this hook,\n\
-the hook value is set to nil, since otherwise the error\n\
-might happen repeatedly and make Emacs nonfunctional.");
+ doc: /* Normal hook run after each command is executed.
+If an unhandled error happens in running this hook,
+the hook value is set to nil, since otherwise the error
+might happen repeatedly and make Emacs nonfunctional. */);
Vpost_command_hook = Qnil;
DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook,
- "Normal hook run after each command is executed, if idle.\n\
-Errors running the hook are caught and ignored.\n\
-This feature is obsolete; use idle timers instead. See `etc/NEWS'.");
+ doc: /* Normal hook run after each command is executed, if idle.
+Errors running the hook are caught and ignored.
+This feature is obsolete; use idle timers instead. See `etc/NEWS'. */);
Vpost_command_idle_hook = Qnil;
DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay,
- "Delay time before running `post-command-idle-hook'.\n\
-This is measured in microseconds.");
+ doc: /* Delay time before running `post-command-idle-hook'.
+This is measured in microseconds. */);
post_command_idle_delay = 100000;
#if 0
DEFVAR_LISP ("echo-area-clear-hook", ...,
- "Normal hook run when clearing the echo area.");
+ doc: /* Normal hook run when clearing the echo area. */);
#endif
Qecho_area_clear_hook = intern ("echo-area-clear-hook");
- XSYMBOL (Qecho_area_clear_hook)->value = Qnil;
+ SET_SYMBOL_VALUE (Qecho_area_clear_hook, Qnil);
DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag,
- "t means menu bar, specified Lucid style, needs to be recomputed.");
+ doc: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
Vlucid_menu_bar_dirty_flag = Qnil;
DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items,
- "List of menu bar items to move to the end of the menu bar.\n\
-The elements of the list are event types that may have menu bar bindings.");
+ doc: /* List of menu bar items to move to the end of the menu bar.
+The elements of the list are event types that may have menu bar bindings. */);
Vmenu_bar_final_items = Qnil;
DEFVAR_KBOARD ("overriding-terminal-local-map",
Voverriding_terminal_local_map,
- "Per-terminal keymap that overrides all other local keymaps.\n\
-If this variable is non-nil, it is used as a keymap instead of the\n\
-buffer's local map, and the minor mode keymaps and text property keymaps.\n\
-This variable is intended to let commands such as `universal-argument'\n\
-set up a different keymap for reading the next command.");
+ doc: /* Per-terminal keymap that overrides all other local keymaps.
+If this variable is non-nil, it is used as a keymap instead of the
+buffer's local map, and the minor mode keymaps and text property keymaps.
+This variable is intended to let commands such as `universal-argument'
+set up a different keymap for reading the next command. */);
DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map,
- "Keymap that overrides all other local keymaps.\n\
-If this variable is non-nil, it is used as a keymap instead of the\n\
-buffer's local map, and the minor mode keymaps and text property keymaps.");
+ doc: /* Keymap that overrides all other local keymaps.
+If this variable is non-nil, it is used as a keymap instead of the
+buffer's local map, and the minor mode keymaps and text property keymaps. */);
Voverriding_local_map = Qnil;
DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag,
- "Non-nil means `overriding-local-map' applies to the menu bar.\n\
-Otherwise, the menu bar continues to reflect the buffer's local map\n\
-and the minor mode maps regardless of `overriding-local-map'.");
+ doc: /* Non-nil means `overriding-local-map' applies to the menu bar.
+Otherwise, the menu bar continues to reflect the buffer's local map
+and the minor mode maps regardless of `overriding-local-map'. */);
Voverriding_local_map_menu_flag = Qnil;
DEFVAR_LISP ("special-event-map", &Vspecial_event_map,
- "Keymap defining bindings for special events to execute at low level.");
+ doc: /* Keymap defining bindings for special events to execute at low level. */);
Vspecial_event_map = Fcons (intern ("keymap"), Qnil);
DEFVAR_LISP ("track-mouse", &do_mouse_tracking,
- "*Non-nil means generate motion events for mouse motion.");
+ doc: /* *Non-nil means generate motion events for mouse motion. */);
DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist,
- "Alist of system-specific X windows key symbols.\n\
-Each element should have the form (N . SYMBOL) where N is the\n\
-numeric keysym code (sans the \"system-specific\" bit 1<<28)\n\
-and SYMBOL is its name.");
+ doc: /* Alist of system-specific X windows key symbols.
+Each element should have the form (N . SYMBOL) where N is the
+numeric keysym code (sans the \"system-specific\" bit 1<<28)
+and SYMBOL is its name. */);
DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list,
- "List of deferred actions to be performed at a later time.\n\
-The precise format isn't relevant here; we just check whether it is nil.");
+ doc: /* List of deferred actions to be performed at a later time.
+The precise format isn't relevant here; we just check whether it is nil. */);
Vdeferred_action_list = Qnil;
DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function,
- "Function to call to handle deferred actions, after each command.\n\
-This function is called with no arguments after each command\n\
-whenever `deferred-action-list' is non-nil.");
+ doc: /* Function to call to handle deferred actions, after each command.
+This function is called with no arguments after each command
+whenever `deferred-action-list' is non-nil. */);
Vdeferred_action_function = Qnil;
DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings,
- "*Non-nil means show the equivalent key-binding when M-x command has one.\n\
-The value can be a length of time to show the message for.\n\
-If the value is non-nil and not a number, we wait 2 seconds.");
+ doc: /* *Non-nil means show the equivalent key-binding when M-x command has one.
+The value can be a length of time to show the message for.
+If the value is non-nil and not a number, we wait 2 seconds. */);
Vsuggest_key_bindings = Qt;
DEFVAR_LISP ("timer-list", &Vtimer_list,
- "List of active absolute time timers in order of increasing time");
+ doc: /* List of active absolute time timers in order of increasing time. */);
Vtimer_list = Qnil;
DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list,
- "List of active idle-time timers in order of increasing time");
+ doc: /* List of active idle-time timers in order of increasing time. */);
Vtimer_idle_list = Qnil;
DEFVAR_LISP ("input-method-function", &Vinput_method_function,
- "If non-nil, the function that implements the current input method.\n\
-It's called with one argument, a printing character that was just read.\n\
-\(That means a character with code 040...0176.)\n\
-Typically this function uses `read-event' to read additional events.\n\
-When it does so, it should first bind `input-method-function' to nil\n\
-so it will not be called recursively.\n\
-\n\
-The function should return a list of zero or more events\n\
-to be used as input. If it wants to put back some events\n\
-to be reconsidered, separately, by the input method,\n\
-it can add them to the beginning of `unread-command-events'.\n\
-\n\
-The input method function can find in `input-method-previous-method'\n\
-the previous echo area message.\n\
-\n\
-The input method function should refer to the variables\n\
-`input-method-use-echo-area' and `input-method-exit-on-first-char'\n\
-for guidance on what to do.");
+ doc: /* If non-nil, the function that implements the current input method.
+It's called with one argument, a printing character that was just read.
+\(That means a character with code 040...0176.)
+Typically this function uses `read-event' to read additional events.
+When it does so, it should first bind `input-method-function' to nil
+so it will not be called recursively.
+
+The function should return a list of zero or more events
+to be used as input. If it wants to put back some events
+to be reconsidered, separately, by the input method,
+it can add them to the beginning of `unread-command-events'.
+
+The input method function can find in `input-method-previous-method'
+the previous echo area message.
+
+The input method function should refer to the variables
+`input-method-use-echo-area' and `input-method-exit-on-first-char'
+for guidance on what to do. */);
Vinput_method_function = Qnil;
DEFVAR_LISP ("input-method-previous-message",
&Vinput_method_previous_message,
- "When `input-method-function' is called, hold the previous echo area message.\n\
-This variable exists because `read-event' clears the echo area\n\
-before running the input method. It is nil if there was no message.");
+ doc: /* When `input-method-function' is called, hold the previous echo area message.
+This variable exists because `read-event' clears the echo area
+before running the input method. It is nil if there was no message. */);
Vinput_method_previous_message = Qnil;
DEFVAR_LISP ("show-help-function", &Vshow_help_function,
- "If non-nil, the function that implements the display of help.\n\
-It's called with one argument, the help string to display.");
+ doc: /* If non-nil, the function that implements the display of help.
+It's called with one argument, the help string to display. */);
Vshow_help_function = Qnil;
DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment,
- "If non-nil, suppress point adjustment after executing a command.\n\
-\n\
-After a command is executed, if point is moved into a region that has\n\
-special properties (e.g. composition, display), we adjust point to\n\
-the boundary of the region. But, several special commands sets this\n\
-variable to non-nil, then we suppress the point adjustment.\n\
-\n\
-This variable is set to nil before reading a command, and is checked\n\
-just after executing the command");
+ doc: /* If non-nil, suppress point adjustment after executing a command.
+
+After a command is executed, if point is moved into a region that has
+special properties (e.g. composition, display), we adjust point to
+the boundary of the region. But, several special commands sets this
+variable to non-nil, then we suppress the point adjustment.
+
+This variable is set to nil before reading a command, and is checked
+just after executing the command. */);
Vdisable_point_adjustment = Qnil;
DEFVAR_LISP ("global-disable-point-adjustment",
&Vglobal_disable_point_adjustment,
- "*If non-nil, always suppress point adjustment.\n\
-\n\
-The default value is nil, in which case, point adjustment are\n\
-suppressed only after special commands that set\n\
-`disable-point-adjustment' (which see) to non-nil.");
+ doc: /* *If non-nil, always suppress point adjustment.
+
+The default value is nil, in which case, point adjustment are
+suppressed only after special commands that set
+`disable-point-adjustment' (which see) to non-nil. */);
Vglobal_disable_point_adjustment = Qnil;
DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings,
- "Non-nil means updating menu bindings is allowed.\n\
-A value of nil means menu bindings should not be updated.\n\
-Used during Emacs' startup.");
+ doc: /* Non-nil means updating menu bindings is allowed.
+A value of nil means menu bindings should not be updated.
+Used during Emacs' startup. */);
update_menu_bindings = 1;
DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout,
- "*How long to display an echo-area message when the minibuffer is active.\n\
-If the value is not a number, such messages don't time out.");
+ doc: /* *How long to display an echo-area message when the minibuffer is active.
+If the value is not a number, such messages don't time out. */);
Vminibuffer_message_timeout = make_number (2);
}
"ignore-event");
initial_define_lispy_key (Vspecial_event_map, "make-frame-visible",
"ignore-event");
+ initial_define_lispy_key (Vspecial_event_map, "select-window",
+ "handle-select-window");
+ initial_define_lispy_key (Vspecial_event_map, "save-session",
+ "handle-save-session");
}