1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995,
3 1996, 1997, 1999, 2000, 2001, 2002, 2003, 2004,
4 2005, 2006, 2007 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
29 #include "termhooks.h"
38 #include "dispextern.h"
40 #include "intervals.h"
42 #include "blockinput.h"
49 #ifdef HAVE_GTK_AND_PTHREAD
57 #include <sys/ioctl.h>
59 #endif /* not MSDOS */
61 #include "syssignal.h"
64 #include <sys/types.h>
73 /* This is to get the definitions of the XK_ symbols. */
80 #endif /* HAVE_NTGUI */
90 /* Variables for blockinput.h: */
92 /* Non-zero if interrupt input is blocked right now. */
93 volatile int interrupt_input_blocked
;
95 /* Nonzero means an input interrupt has arrived
96 during the current critical section. */
97 int interrupt_input_pending
;
100 /* File descriptor to use for input. */
103 #ifdef HAVE_WINDOW_SYSTEM
104 /* Make all keyboard buffers much bigger when using X windows. */
106 /* But not too big (local data > 32K error) if on Mac OS Classic. */
107 #define KBD_BUFFER_SIZE 512
109 #define KBD_BUFFER_SIZE 4096
111 #else /* No X-windows, character input */
112 #define KBD_BUFFER_SIZE 4096
113 #endif /* No X-windows */
115 #define abs(x) ((x) >= 0 ? (x) : -(x))
117 /* Following definition copied from eval.c */
121 struct backtrace
*next
;
122 Lisp_Object
*function
;
123 Lisp_Object
*args
; /* Points to vector of args. */
124 int nargs
; /* length of vector. If nargs is UNEVALLED,
125 args points to slot holding list of
128 /* Nonzero means call value of debugger when done with this operation. */
133 KBOARD
*initial_kboard
;
134 KBOARD
*current_kboard
;
138 KBOARD the_only_kboard
;
141 /* Non-nil disable property on a command means
142 do not execute it; call disabled-command-function's value instead. */
143 Lisp_Object Qdisabled
, Qdisabled_command_function
;
145 #define NUM_RECENT_KEYS (300)
146 int recent_keys_index
; /* Index for storing next element into recent_keys */
147 int total_keys
; /* Total number of elements stored into recent_keys */
148 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
150 /* Vector holding the key sequence that invoked the current command.
151 It is reused for each command, and it may be longer than the current
152 sequence; this_command_key_count indicates how many elements
153 actually mean something.
154 It's easier to staticpro a single Lisp_Object than an array. */
155 Lisp_Object this_command_keys
;
156 int this_command_key_count
;
158 /* 1 after calling Freset_this_command_lengths.
160 int this_command_key_count_reset
;
162 /* This vector is used as a buffer to record the events that were actually read
163 by read_key_sequence. */
164 Lisp_Object raw_keybuf
;
165 int raw_keybuf_count
;
167 #define GROW_RAW_KEYBUF \
168 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
170 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
172 new = Fmake_vector (make_number (newsize), Qnil); \
173 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
174 raw_keybuf_count * sizeof (Lisp_Object)); \
178 /* Number of elements of this_command_keys
179 that precede this key sequence. */
180 int this_single_command_key_start
;
182 /* Record values of this_command_key_count and echo_length ()
183 before this command was read. */
184 static int before_command_key_count
;
185 static int before_command_echo_length
;
187 extern int minbuf_level
;
189 extern int message_enable_multibyte
;
191 extern struct backtrace
*backtrace_list
;
193 /* If non-nil, the function that implements the display of help.
194 It's called with one argument, the help string to display. */
196 Lisp_Object Vshow_help_function
;
198 /* If a string, the message displayed before displaying a help-echo
201 Lisp_Object Vpre_help_message
;
203 /* Nonzero means do menu prompting. */
205 static int menu_prompting
;
207 /* Character to see next line of menu prompt. */
209 static Lisp_Object menu_prompt_more_char
;
211 /* For longjmp to where kbd input is being done. */
213 static jmp_buf getcjmp
;
215 /* True while doing kbd input. */
216 int waiting_for_input
;
218 /* True while displaying for echoing. Delays C-g throwing. */
222 /* Non-null means we can start echoing at the next input pause even
223 though there is something in the echo area. */
225 static struct kboard
*ok_to_echo_at_next_pause
;
227 /* The kboard last echoing, or null for none. Reset to 0 in
228 cancel_echoing. If non-null, and a current echo area message
229 exists, and echo_message_buffer is eq to the current message
230 buffer, we know that the message comes from echo_kboard. */
232 struct kboard
*echo_kboard
;
234 /* The buffer used for echoing. Set in echo_now, reset in
237 Lisp_Object echo_message_buffer
;
239 /* Nonzero means disregard local maps for the menu bar. */
240 static int inhibit_local_menu_bar_menus
;
242 /* Nonzero means C-g should cause immediate error-signal. */
245 /* The user's hook function for outputting an error message. */
246 Lisp_Object Vcommand_error_function
;
248 /* The user's ERASE setting. */
249 Lisp_Object Vtty_erase_char
;
251 /* Character to recognize as the help char. */
252 Lisp_Object Vhelp_char
;
254 /* List of other event types to recognize as meaning "help". */
255 Lisp_Object Vhelp_event_list
;
257 /* Form to execute when help char is typed. */
258 Lisp_Object Vhelp_form
;
260 /* Command to run when the help character follows a prefix key. */
261 Lisp_Object Vprefix_help_command
;
263 /* List of items that should move to the end of the menu bar. */
264 Lisp_Object Vmenu_bar_final_items
;
266 /* Non-nil means show the equivalent key-binding for
267 any M-x command that has one.
268 The value can be a length of time to show the message for.
269 If the value is non-nil and not a number, we wait 2 seconds. */
270 Lisp_Object Vsuggest_key_bindings
;
272 /* How long to display an echo-area message when the minibuffer is active.
273 If the value is not a number, such messages don't time out. */
274 Lisp_Object Vminibuffer_message_timeout
;
276 /* Character that causes a quit. Normally C-g.
278 If we are running on an ordinary terminal, this must be an ordinary
279 ASCII char, since we want to make it our interrupt character.
281 If we are not running on an ordinary terminal, it still needs to be
282 an ordinary ASCII char. This character needs to be recognized in
283 the input interrupt handler. At this point, the keystroke is
284 represented as a struct input_event, while the desired quit
285 character is specified as a lispy event. The mapping from struct
286 input_events to lispy events cannot run in an interrupt handler,
287 and the reverse mapping is difficult for anything but ASCII
290 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
294 extern Lisp_Object current_global_map
;
295 extern int minibuf_level
;
297 /* If non-nil, this is a map that overrides all other local maps. */
298 Lisp_Object Voverriding_local_map
;
300 /* If non-nil, Voverriding_local_map applies to the menu bar. */
301 Lisp_Object Voverriding_local_map_menu_flag
;
303 /* Keymap that defines special misc events that should
304 be processed immediately at a low level. */
305 Lisp_Object Vspecial_event_map
;
307 /* Current depth in recursive edits. */
308 int command_loop_level
;
310 /* Total number of times command_loop has read a key sequence. */
311 EMACS_INT num_input_keys
;
313 /* Last input character read as a command. */
314 Lisp_Object last_command_char
;
316 /* Last input character read as a command, not counting menus
317 reached by the mouse. */
318 Lisp_Object last_nonmenu_event
;
320 /* Last input character read for any purpose. */
321 Lisp_Object last_input_char
;
323 /* If not Qnil, a list of objects to be read as subsequent command input. */
324 Lisp_Object Vunread_command_events
;
326 /* If not Qnil, a list of objects to be read as subsequent command input
327 including input method processing. */
328 Lisp_Object Vunread_input_method_events
;
330 /* If not Qnil, a list of objects to be read as subsequent command input
331 but NOT including input method processing. */
332 Lisp_Object Vunread_post_input_method_events
;
334 /* If not -1, an event to be read as subsequent command input. */
335 EMACS_INT unread_command_char
;
337 /* If not Qnil, this is a switch-frame event which we decided to put
338 off until the end of a key sequence. This should be read as the
339 next command input, after any unread_command_events.
341 read_key_sequence uses this to delay switch-frame events until the
342 end of the key sequence; Fread_char uses it to put off switch-frame
343 events until a non-ASCII event is acceptable as input. */
344 Lisp_Object unread_switch_frame
;
346 /* A mask of extra modifier bits to put into every keyboard char. */
347 EMACS_INT extra_keyboard_modifiers
;
349 /* Char to use as prefix when a meta character is typed in.
350 This is bound on entry to minibuffer in case ESC is changed there. */
352 Lisp_Object meta_prefix_char
;
354 /* Last size recorded for a current buffer which is not a minibuffer. */
355 static int last_non_minibuf_size
;
357 /* Number of idle seconds before an auto-save and garbage collection. */
358 static Lisp_Object Vauto_save_timeout
;
360 /* Total number of times read_char has returned. */
361 int num_input_events
;
363 /* Total number of times read_char has returned, outside of macros. */
364 EMACS_INT num_nonmacro_input_events
;
366 /* Auto-save automatically when this many characters have been typed
367 since the last time. */
369 static EMACS_INT auto_save_interval
;
371 /* Value of num_nonmacro_input_events as of last auto save. */
375 /* The command being executed by the command loop.
376 Commands may set this, and the value set will be copied into
377 current_kboard->Vlast_command instead of the actual command. */
378 Lisp_Object Vthis_command
;
380 /* This is like Vthis_command, except that commands never set it. */
381 Lisp_Object real_this_command
;
383 /* If the lookup of the command returns a binding, the original
384 command is stored in this-original-command. It is nil otherwise. */
385 Lisp_Object Vthis_original_command
;
387 /* The value of point when the last command was started. */
388 int last_point_position
;
390 /* The buffer that was current when the last command was started. */
391 Lisp_Object last_point_position_buffer
;
393 /* The window that was selected when the last command was started. */
394 Lisp_Object last_point_position_window
;
396 /* The frame in which the last input event occurred, or Qmacro if the
397 last event came from a macro. We use this to determine when to
398 generate switch-frame events. This may be cleared by functions
399 like Fselect_frame, to make sure that a switch-frame event is
400 generated by the next character. */
401 Lisp_Object internal_last_event_frame
;
403 /* A user-visible version of the above, intended to allow users to
404 figure out where the last event came from, if the event doesn't
405 carry that information itself (i.e. if it was a character). */
406 Lisp_Object Vlast_event_frame
;
408 /* The timestamp of the last input event we received from the X server.
409 X Windows wants this for selection ownership. */
410 unsigned long last_event_timestamp
;
412 Lisp_Object Qself_insert_command
;
413 Lisp_Object Qforward_char
;
414 Lisp_Object Qbackward_char
;
415 Lisp_Object Qundefined
;
416 Lisp_Object Qtimer_event_handler
;
418 /* read_key_sequence stores here the command definition of the
419 key sequence that it reads. */
420 Lisp_Object read_key_sequence_cmd
;
422 /* Echo unfinished commands after this many seconds of pause. */
423 Lisp_Object Vecho_keystrokes
;
425 /* Form to evaluate (if non-nil) when Emacs is started. */
426 Lisp_Object Vtop_level
;
428 /* User-supplied table to translate input characters. */
429 Lisp_Object Vkeyboard_translate_table
;
431 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
432 extern Lisp_Object Vfunction_key_map
;
434 /* Another keymap that maps key sequences into key sequences.
435 This one takes precedence over ordinary definitions. */
436 extern Lisp_Object Vkey_translation_map
;
438 /* If non-nil, this implements the current input method. */
439 Lisp_Object Vinput_method_function
;
440 Lisp_Object Qinput_method_function
;
442 /* When we call Vinput_method_function,
443 this holds the echo area message that was just erased. */
444 Lisp_Object Vinput_method_previous_message
;
446 /* Non-nil means deactivate the mark at end of this command. */
447 Lisp_Object Vdeactivate_mark
;
449 /* Menu bar specified in Lucid Emacs fashion. */
451 Lisp_Object Vlucid_menu_bar_dirty_flag
;
452 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
454 Lisp_Object Qecho_area_clear_hook
;
456 /* Hooks to run before and after each command. */
457 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
458 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
459 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
461 /* List of deferred actions to be performed at a later time.
462 The precise format isn't relevant here; we just check whether it is nil. */
463 Lisp_Object Vdeferred_action_list
;
465 /* Function to call to handle deferred actions, when there are any. */
466 Lisp_Object Vdeferred_action_function
;
467 Lisp_Object Qdeferred_action_function
;
469 Lisp_Object Qinput_method_exit_on_first_char
;
470 Lisp_Object Qinput_method_use_echo_area
;
472 /* File in which we write all commands we read. */
475 /* Nonzero if input is available. */
478 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
479 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
483 extern char *pending_malloc_warning
;
485 /* Circular buffer for pre-read keyboard input. */
487 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
489 /* Pointer to next available character in kbd_buffer.
490 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
491 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
492 next available char is in kbd_buffer[0]. */
493 static struct input_event
*kbd_fetch_ptr
;
495 /* Pointer to next place to store character in kbd_buffer. This
496 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
497 character should go in kbd_buffer[0]. */
498 static struct input_event
* volatile kbd_store_ptr
;
500 /* The above pair of variables forms a "queue empty" flag. When we
501 enqueue a non-hook event, we increment kbd_store_ptr. When we
502 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
503 there is input available iff the two pointers are not equal.
505 Why not just have a flag set and cleared by the enqueuing and
506 dequeuing functions? Such a flag could be screwed up by interrupts
507 at inopportune times. */
509 /* If this flag is non-nil, we check mouse_moved to see when the
510 mouse moves, and motion events will appear in the input stream.
511 Otherwise, mouse motion is ignored. */
512 Lisp_Object do_mouse_tracking
;
514 /* Symbols to head events. */
515 Lisp_Object Qmouse_movement
;
516 Lisp_Object Qscroll_bar_movement
;
517 Lisp_Object Qswitch_frame
;
518 Lisp_Object Qdelete_frame
;
519 Lisp_Object Qiconify_frame
;
520 Lisp_Object Qmake_frame_visible
;
521 Lisp_Object Qselect_window
;
522 Lisp_Object Qhelp_echo
;
524 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
525 Lisp_Object Qmouse_fixup_help_message
;
528 /* Symbols to denote kinds of events. */
529 Lisp_Object Qfunction_key
;
530 Lisp_Object Qmouse_click
;
531 #if defined (WINDOWSNT) || defined (MAC_OS)
532 Lisp_Object Qlanguage_change
;
534 Lisp_Object Qdrag_n_drop
;
535 Lisp_Object Qsave_session
;
537 Lisp_Object Qmac_apple_event
;
540 /* Lisp_Object Qmouse_movement; - also an event header */
542 /* Properties of event headers. */
543 Lisp_Object Qevent_kind
;
544 Lisp_Object Qevent_symbol_elements
;
546 /* menu item parts */
547 Lisp_Object Qmenu_alias
;
548 Lisp_Object Qmenu_enable
;
549 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
550 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
551 extern Lisp_Object Vdefine_key_rebound_commands
;
552 extern Lisp_Object Qmenu_item
;
554 /* An event header symbol HEAD may have a property named
555 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
556 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
557 mask of modifiers applied to it. If present, this is used to help
558 speed up parse_modifiers. */
559 Lisp_Object Qevent_symbol_element_mask
;
561 /* An unmodified event header BASE may have a property named
562 Qmodifier_cache, which is an alist mapping modifier masks onto
563 modified versions of BASE. If present, this helps speed up
565 Lisp_Object Qmodifier_cache
;
567 /* Symbols to use for parts of windows. */
568 Lisp_Object Qmode_line
;
569 Lisp_Object Qvertical_line
;
570 Lisp_Object Qvertical_scroll_bar
;
571 Lisp_Object Qmenu_bar
;
572 extern Lisp_Object Qleft_margin
, Qright_margin
;
573 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
574 extern Lisp_Object QCmap
;
576 Lisp_Object
recursive_edit_unwind (), command_loop ();
577 Lisp_Object
Fthis_command_keys ();
578 Lisp_Object Qextended_command_history
;
579 EMACS_TIME
timer_check ();
581 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
583 extern char *x_get_keysym_name ();
585 static void record_menu_key ();
586 static int echo_length ();
588 Lisp_Object Qpolling_period
;
590 /* List of absolute timers. Appears in order of next scheduled event. */
591 Lisp_Object Vtimer_list
;
593 /* List of idle time timers. Appears in order of next scheduled event. */
594 Lisp_Object Vtimer_idle_list
;
596 /* Incremented whenever a timer is run. */
599 extern Lisp_Object Vprint_level
, Vprint_length
;
601 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
603 EMACS_TIME
*input_available_clear_time
;
605 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
606 Default is 1 if INTERRUPT_INPUT is defined. */
609 /* Nonzero while interrupts are temporarily deferred during redisplay. */
610 int interrupts_deferred
;
612 /* Nonzero means use ^S/^Q for flow control. */
615 /* Allow m- file to inhibit use of FIONREAD. */
616 #ifdef BROKEN_FIONREAD
620 /* We are unable to use interrupts if FIONREAD is not available,
621 so flush SIGIO so we won't try. */
622 #if !defined (FIONREAD)
628 /* If we support a window system, turn on the code to poll periodically
629 to detect C-g. It isn't actually used when doing interrupt input. */
630 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
631 #define POLL_FOR_INPUT
634 /* After a command is executed, if point is moved into a region that
635 has specific properties (e.g. composition, display), we adjust
636 point to the boundary of the region. But, if a command sets this
637 variable to non-nil, we suppress this point adjustment. This
638 variable is set to nil before reading a command. */
640 Lisp_Object Vdisable_point_adjustment
;
642 /* If non-nil, always disable point adjustment. */
644 Lisp_Object Vglobal_disable_point_adjustment
;
646 /* The time when Emacs started being idle. */
648 static EMACS_TIME timer_idleness_start_time
;
650 /* After Emacs stops being idle, this saves the last value
651 of timer_idleness_start_time from when it was idle. */
653 static EMACS_TIME timer_last_idleness_start_time
;
655 /* If non-nil, events produced by disabled menu items and tool-bar
656 buttons are not ignored. Help functions bind this to allow help on
657 those items and buttons. */
658 Lisp_Object Venable_disabled_menus_and_buttons
;
661 /* Global variable declarations. */
663 /* Flags for readable_events. */
664 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
665 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
666 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
668 /* Function for init_keyboard to call with no args (if nonzero). */
669 void (*keyboard_init_hook
) ();
671 static int read_avail_input
P_ ((int));
672 static void get_input_pending
P_ ((int *, int));
673 static int readable_events
P_ ((int));
674 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
675 Lisp_Object
, int *));
676 static Lisp_Object
read_char_x_menu_prompt ();
677 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
679 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
680 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
681 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
682 enum scroll_bar_part
,
683 Lisp_Object
, Lisp_Object
,
686 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
687 Lisp_Object
, char **,
688 Lisp_Object
*, unsigned));
689 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
690 static int parse_solitary_modifier
P_ ((Lisp_Object
));
691 static int parse_solitary_modifier ();
692 static void save_getcjmp
P_ ((jmp_buf));
693 static void save_getcjmp ();
694 static void restore_getcjmp
P_ ((jmp_buf));
695 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
696 static void clear_event
P_ ((struct input_event
*));
697 static void any_kboard_state
P_ ((void));
698 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
699 static void timer_start_idle
P_ ((void));
700 static void timer_stop_idle
P_ ((void));
701 static void timer_resume_idle
P_ ((void));
702 static SIGTYPE handle_user_signal
P_ ((int));
703 static char *find_user_signal_name
P_ ((int));
704 static int store_user_signal_events
P_ ((void));
706 /* Nonzero means don't try to suspend even if the operating system seems
708 static int cannot_suspend
;
710 extern Lisp_Object Qidentity
, Qonly
;
712 /* Install the string STR as the beginning of the string of echoing,
713 so that it serves as a prompt for the next character.
714 Also start echoing. */
720 current_kboard
->echo_string
= str
;
721 current_kboard
->echo_after_prompt
= SCHARS (str
);
725 /* Add C to the echo string, if echoing is going on.
726 C can be a character, which is printed prettily ("M-C-x" and all that
727 jazz), or a symbol, whose name is printed. */
733 if (current_kboard
->immediate_echo
)
735 int size
= KEY_DESCRIPTION_SIZE
+ 100;
736 char *buffer
= (char *) alloca (size
);
738 Lisp_Object echo_string
;
740 echo_string
= current_kboard
->echo_string
;
742 /* If someone has passed us a composite event, use its head symbol. */
747 ptr
= push_key_description (XINT (c
), ptr
, 1);
749 else if (SYMBOLP (c
))
751 Lisp_Object name
= SYMBOL_NAME (c
);
752 int nbytes
= SBYTES (name
);
754 if (size
- (ptr
- buffer
) < nbytes
)
756 int offset
= ptr
- buffer
;
757 size
= max (2 * size
, size
+ nbytes
);
758 buffer
= (char *) alloca (size
);
759 ptr
= buffer
+ offset
;
762 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
763 STRING_MULTIBYTE (name
), 1);
766 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
769 const char *text
= " (Type ? for further options)";
770 int len
= strlen (text
);
772 if (size
- (ptr
- buffer
) < len
)
774 int offset
= ptr
- buffer
;
776 buffer
= (char *) alloca (size
);
777 ptr
= buffer
+ offset
;
780 bcopy (text
, ptr
, len
);
784 /* Replace a dash from echo_dash with a space, otherwise
785 add a space at the end as a separator between keys. */
786 if (STRINGP (echo_string
)
787 && SCHARS (echo_string
) > 1)
789 Lisp_Object last_char
, prev_char
, idx
;
791 idx
= make_number (SCHARS (echo_string
) - 2);
792 prev_char
= Faref (echo_string
, idx
);
794 idx
= make_number (SCHARS (echo_string
) - 1);
795 last_char
= Faref (echo_string
, idx
);
797 /* We test PREV_CHAR to make sure this isn't the echoing
799 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
800 Faset (echo_string
, idx
, make_number (' '));
802 echo_string
= concat2 (echo_string
, build_string (" "));
804 else if (STRINGP (echo_string
))
805 echo_string
= concat2 (echo_string
, build_string (" "));
807 current_kboard
->echo_string
808 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
814 /* Temporarily add a dash to the end of the echo string if it's not
815 empty, so that it serves as a mini-prompt for the very next character. */
820 /* Do nothing if not echoing at all. */
821 if (NILP (current_kboard
->echo_string
))
824 if (!current_kboard
->immediate_echo
825 && SCHARS (current_kboard
->echo_string
) == 0)
828 /* Do nothing if we just printed a prompt. */
829 if (current_kboard
->echo_after_prompt
830 == SCHARS (current_kboard
->echo_string
))
833 /* Do nothing if we have already put a dash at the end. */
834 if (SCHARS (current_kboard
->echo_string
) > 1)
836 Lisp_Object last_char
, prev_char
, idx
;
838 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
839 prev_char
= Faref (current_kboard
->echo_string
, idx
);
841 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
842 last_char
= Faref (current_kboard
->echo_string
, idx
);
844 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
848 /* Put a dash at the end of the buffer temporarily,
849 but make it go away when the next character is added. */
850 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
855 /* Display the current echo string, and begin echoing if not already
861 if (!current_kboard
->immediate_echo
)
864 current_kboard
->immediate_echo
= 1;
866 for (i
= 0; i
< this_command_key_count
; i
++)
870 /* Set before_command_echo_length to the value that would
871 have been saved before the start of this subcommand in
872 command_loop_1, if we had already been echoing then. */
873 if (i
== this_single_command_key_start
)
874 before_command_echo_length
= echo_length ();
876 c
= XVECTOR (this_command_keys
)->contents
[i
];
877 if (! (EVENT_HAS_PARAMETERS (c
)
878 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
882 /* Set before_command_echo_length to the value that would
883 have been saved before the start of this subcommand in
884 command_loop_1, if we had already been echoing then. */
885 if (this_command_key_count
== this_single_command_key_start
)
886 before_command_echo_length
= echo_length ();
888 /* Put a dash at the end to invite the user to type more. */
893 message3_nolog (current_kboard
->echo_string
,
894 SBYTES (current_kboard
->echo_string
),
895 STRING_MULTIBYTE (current_kboard
->echo_string
));
898 /* Record in what buffer we echoed, and from which kboard. */
899 echo_message_buffer
= echo_area_buffer
[0];
900 echo_kboard
= current_kboard
;
902 if (waiting_for_input
&& !NILP (Vquit_flag
))
903 quit_throw_to_read_char ();
906 /* Turn off echoing, for the start of a new command. */
911 current_kboard
->immediate_echo
= 0;
912 current_kboard
->echo_after_prompt
= -1;
913 current_kboard
->echo_string
= Qnil
;
914 ok_to_echo_at_next_pause
= NULL
;
916 echo_message_buffer
= Qnil
;
919 /* Return the length of the current echo string. */
924 return (STRINGP (current_kboard
->echo_string
)
925 ? SCHARS (current_kboard
->echo_string
)
929 /* Truncate the current echo message to its first LEN chars.
930 This and echo_char get used by read_key_sequence when the user
931 switches frames while entering a key sequence. */
934 echo_truncate (nchars
)
937 if (STRINGP (current_kboard
->echo_string
))
938 current_kboard
->echo_string
939 = Fsubstring (current_kboard
->echo_string
,
940 make_number (0), make_number (nchars
));
941 truncate_echo_area (nchars
);
945 /* Functions for manipulating this_command_keys. */
947 add_command_key (key
)
950 #if 0 /* Not needed after we made Freset_this_command_lengths
951 do the job immediately. */
952 /* If reset-this-command-length was called recently, obey it now.
953 See the doc string of that function for an explanation of why. */
954 if (before_command_restore_flag
)
956 this_command_key_count
= before_command_key_count_1
;
957 if (this_command_key_count
< this_single_command_key_start
)
958 this_single_command_key_start
= this_command_key_count
;
959 echo_truncate (before_command_echo_length_1
);
960 before_command_restore_flag
= 0;
964 if (this_command_key_count
>= ASIZE (this_command_keys
))
965 this_command_keys
= larger_vector (this_command_keys
,
966 2 * ASIZE (this_command_keys
),
969 AREF (this_command_keys
, this_command_key_count
) = key
;
970 ++this_command_key_count
;
977 int count
= SPECPDL_INDEX ();
980 if (command_loop_level
> 0)
982 specbind (Qstandard_output
, Qt
);
983 specbind (Qstandard_input
, Qt
);
986 #ifdef HAVE_X_WINDOWS
987 /* The command loop has started an hourglass timer, so we have to
988 cancel it here, otherwise it will fire because the recursive edit
989 can take some time. Do not check for display_hourglass_p here,
990 because it could already be nil. */
994 /* This function may have been called from a debugger called from
995 within redisplay, for instance by Edebugging a function called
996 from fontification-functions. We want to allow redisplay in
997 the debugging session.
999 The recursive edit is left with a `(throw exit ...)'. The `exit'
1000 tag is not caught anywhere in redisplay, i.e. when we leave the
1001 recursive edit, the original redisplay leading to the recursive
1002 edit will be unwound. The outcome should therefore be safe. */
1003 specbind (Qinhibit_redisplay
, Qnil
);
1006 val
= command_loop ();
1008 Fsignal (Qquit
, Qnil
);
1009 /* Handle throw from read_minibuf when using minibuffer
1010 while it's active but we're in another window. */
1012 xsignal1 (Qerror
, val
);
1014 return unbind_to (count
, Qnil
);
1017 /* When an auto-save happens, record the "time", and don't do again soon. */
1022 last_auto_save
= num_nonmacro_input_events
;
1025 /* Make an auto save happen as soon as possible at command level. */
1028 force_auto_save_soon ()
1030 last_auto_save
= - auto_save_interval
- 1;
1032 record_asynch_buffer_change ();
1035 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
1036 doc
: /* Invoke the editor command loop recursively.
1037 To get out of the recursive edit, a command can do `(throw 'exit nil)';
1038 that tells this function to return.
1039 Alternatively, `(throw 'exit t)' makes this function signal an error.
1040 This function is called by the editor initialization to begin editing. */)
1043 int count
= SPECPDL_INDEX ();
1046 /* If we enter while input is blocked, don't lock up here.
1047 This may happen through the debugger during redisplay. */
1048 if (INPUT_BLOCKED_P
)
1051 command_loop_level
++;
1052 update_mode_lines
= 1;
1054 if (command_loop_level
1055 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1056 buffer
= Fcurrent_buffer ();
1060 /* If we leave recursive_edit_1 below with a `throw' for instance,
1061 like it is done in the splash screen display, we have to
1062 make sure that we restore single_kboard as command_loop_1
1063 would have done if it were left normally. */
1064 record_unwind_protect (recursive_edit_unwind
,
1065 Fcons (buffer
, single_kboard
? Qt
: Qnil
));
1067 recursive_edit_1 ();
1068 return unbind_to (count
, Qnil
);
1072 recursive_edit_unwind (info
)
1075 if (BUFFERP (XCAR (info
)))
1076 Fset_buffer (XCAR (info
));
1078 if (NILP (XCDR (info
)))
1079 any_kboard_state ();
1081 single_kboard_state ();
1083 command_loop_level
--;
1084 update_mode_lines
= 1;
1093 #if 0 /* Theory: if there's anything in Vunread_command_events,
1094 it will right away be read by read_key_sequence,
1095 and then if we do switch KBOARDS, it will go into the side
1096 queue then. So we don't need to do anything special here -- rms. */
1097 if (CONSP (Vunread_command_events
))
1099 current_kboard
->kbd_queue
1100 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1101 current_kboard
->kbd_queue_has_data
= 1;
1103 Vunread_command_events
= Qnil
;
1109 /* Switch to the single-kboard state, making current_kboard
1110 the only KBOARD from which further input is accepted. */
1113 single_kboard_state ()
1120 /* If we're in single_kboard state for kboard KBOARD,
1124 not_single_kboard_state (kboard
)
1128 if (kboard
== current_kboard
)
1133 /* Maintain a stack of kboards, so other parts of Emacs
1134 can switch temporarily to the kboard of a given frame
1135 and then revert to the previous status. */
1140 struct kboard_stack
*next
;
1143 static struct kboard_stack
*kboard_stack
;
1146 push_frame_kboard (f
)
1150 struct kboard_stack
*p
1151 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1153 p
->next
= kboard_stack
;
1154 p
->kboard
= current_kboard
;
1157 current_kboard
= FRAME_KBOARD (f
);
1165 struct kboard_stack
*p
= kboard_stack
;
1166 current_kboard
= p
->kboard
;
1167 kboard_stack
= p
->next
;
1172 /* Handle errors that are not handled at inner levels
1173 by printing an error message and returning to the editor command loop. */
1179 Lisp_Object old_level
, old_length
;
1180 char macroerror
[50];
1182 #ifdef HAVE_X_WINDOWS
1183 if (display_hourglass_p
)
1184 cancel_hourglass ();
1187 if (!NILP (executing_kbd_macro
))
1189 if (executing_kbd_macro_iterations
== 1)
1190 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1192 sprintf (macroerror
, "After %d kbd macro iterations: ",
1193 executing_kbd_macro_iterations
);
1198 Vstandard_output
= Qt
;
1199 Vstandard_input
= Qt
;
1200 Vexecuting_kbd_macro
= Qnil
;
1201 executing_kbd_macro
= Qnil
;
1202 current_kboard
->Vprefix_arg
= Qnil
;
1203 current_kboard
->Vlast_prefix_arg
= Qnil
;
1206 /* Avoid unquittable loop if data contains a circular list. */
1207 old_level
= Vprint_level
;
1208 old_length
= Vprint_length
;
1209 XSETFASTINT (Vprint_level
, 10);
1210 XSETFASTINT (Vprint_length
, 10);
1211 cmd_error_internal (data
, macroerror
);
1212 Vprint_level
= old_level
;
1213 Vprint_length
= old_length
;
1217 Vinhibit_quit
= Qnil
;
1219 if (command_loop_level
== 0 && minibuf_level
== 0)
1220 any_kboard_state ();
1223 return make_number (0);
1226 /* Take actions on handling an error. DATA is the data that describes
1229 CONTEXT is a C-string containing ASCII characters only which
1230 describes the context in which the error happened. If we need to
1231 generalize CONTEXT to allow multibyte characters, make it a Lisp
1235 cmd_error_internal (data
, context
)
1239 struct frame
*sf
= SELECTED_FRAME ();
1241 /* The immediate context is not interesting for Quits,
1242 since they are asyncronous. */
1243 if (EQ (XCAR (data
), Qquit
))
1244 Vsignaling_function
= Qnil
;
1249 /* Use user's specified output function if any. */
1250 if (!NILP (Vcommand_error_function
))
1251 call3 (Vcommand_error_function
, data
,
1252 build_string (context
? context
: ""),
1253 Vsignaling_function
);
1254 /* If the window system or terminal frame hasn't been initialized
1255 yet, or we're not interactive, write the message to stderr and exit. */
1256 else if (!sf
->glyphs_initialized_p
1257 /* This is the case of the frame dumped with Emacs, when we're
1258 running under a window system. */
1259 || (!NILP (Vwindow_system
)
1260 && !inhibit_window_system
1261 && FRAME_TERMCAP_P (sf
))
1264 print_error_message (data
, Qexternal_debugging_output
,
1265 context
, Vsignaling_function
);
1266 Fterpri (Qexternal_debugging_output
);
1267 Fkill_emacs (make_number (-1));
1271 clear_message (1, 0);
1273 message_log_maybe_newline ();
1276 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1279 Vsignaling_function
= Qnil
;
1282 Lisp_Object
command_loop_1 ();
1283 Lisp_Object
command_loop_2 ();
1284 Lisp_Object
top_level_1 ();
1286 /* Entry to editor-command-loop.
1287 This level has the catches for exiting/returning to editor command loop.
1288 It returns nil to exit recursive edit, t to abort it. */
1293 if (command_loop_level
> 0 || minibuf_level
> 0)
1296 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1297 executing_kbd_macro
= Qnil
;
1303 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1304 /* Reset single_kboard in case top-level set it while
1305 evaluating an -f option, or we are stuck there for some
1307 any_kboard_state ();
1308 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1309 executing_kbd_macro
= Qnil
;
1311 /* End of file in -batch run causes exit here. */
1317 /* Here we catch errors in execution of commands within the
1318 editing loop, and reenter the editing loop.
1319 When there is an error, cmd_error runs and returns a non-nil
1320 value to us. A value of nil means that command_loop_1 itself
1321 returned due to end of file (or end of kbd macro). */
1326 register Lisp_Object val
;
1329 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1330 while (!NILP (val
));
1338 return Feval (Vtop_level
);
1344 /* On entry to the outer level, run the startup file */
1345 if (!NILP (Vtop_level
))
1346 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1347 else if (!NILP (Vpurify_flag
))
1348 message ("Bare impure Emacs (standard Lisp code not loaded)");
1350 message ("Bare Emacs (standard Lisp code not loaded)");
1354 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1355 doc
: /* Exit all recursive editing levels. */)
1358 #ifdef HAVE_X_WINDOWS
1359 if (display_hourglass_p
)
1360 cancel_hourglass ();
1363 /* Unblock input if we enter with input blocked. This may happen if
1364 redisplay traps e.g. during tool-bar update with input blocked. */
1365 while (INPUT_BLOCKED_P
)
1368 return Fthrow (Qtop_level
, Qnil
);
1371 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1372 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1375 if (command_loop_level
> 0 || minibuf_level
> 0)
1376 Fthrow (Qexit
, Qnil
);
1378 error ("No recursive edit is in progress");
1382 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1383 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1386 if (command_loop_level
> 0 || minibuf_level
> 0)
1389 error ("No recursive edit is in progress");
1393 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1395 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1396 of this function. */
1399 tracking_off (old_value
)
1400 Lisp_Object old_value
;
1402 do_mouse_tracking
= old_value
;
1403 if (NILP (old_value
))
1405 /* Redisplay may have been preempted because there was input
1406 available, and it assumes it will be called again after the
1407 input has been processed. If the only input available was
1408 the sort that we have just disabled, then we need to call
1410 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1412 redisplay_preserve_echo_area (6);
1413 get_input_pending (&input_pending
,
1414 READABLE_EVENTS_DO_TIMERS_NOW
);
1420 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1421 doc
: /* Evaluate BODY with mouse movement events enabled.
1422 Within a `track-mouse' form, mouse motion generates input events that
1423 you can read with `read-event'.
1424 Normally, mouse motion is ignored.
1425 usage: (track-mouse BODY ...) */)
1429 int count
= SPECPDL_INDEX ();
1432 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1434 do_mouse_tracking
= Qt
;
1436 val
= Fprogn (args
);
1437 return unbind_to (count
, val
);
1440 /* If mouse has moved on some frame, return one of those frames.
1444 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1445 after resizing the tool-bar window. */
1447 int ignore_mouse_drag_p
;
1452 Lisp_Object tail
, frame
;
1454 if (ignore_mouse_drag_p
)
1456 /* ignore_mouse_drag_p = 0; */
1460 FOR_EACH_FRAME (tail
, frame
)
1462 if (XFRAME (frame
)->mouse_moved
)
1463 return XFRAME (frame
);
1469 #endif /* HAVE_MOUSE || HAVE_GPM */
1471 /* This is the actual command reading loop,
1472 sans error-handling encapsulation. */
1474 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1476 void safe_run_hooks
P_ ((Lisp_Object
));
1477 static void adjust_point_for_property
P_ ((int, int));
1479 /* Cancel hourglass from protect_unwind.
1481 #ifdef HAVE_X_WINDOWS
1483 cancel_hourglass_unwind (arg
)
1486 cancel_hourglass ();
1497 Lisp_Object keybuf
[30];
1500 int prev_modiff
= 0;
1501 struct buffer
*prev_buffer
= NULL
;
1503 int was_locked
= single_kboard
;
1505 int already_adjusted
;
1507 current_kboard
->Vprefix_arg
= Qnil
;
1508 current_kboard
->Vlast_prefix_arg
= Qnil
;
1509 Vdeactivate_mark
= Qnil
;
1510 waiting_for_input
= 0;
1514 this_command_key_count
= 0;
1515 this_command_key_count_reset
= 0;
1516 this_single_command_key_start
= 0;
1518 if (NILP (Vmemory_full
))
1520 /* Make sure this hook runs after commands that get errors and
1521 throw to top level. */
1522 /* Note that the value cell will never directly contain nil
1523 if the symbol is a local variable. */
1524 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1525 safe_run_hooks (Qpost_command_hook
);
1527 /* If displaying a message, resize the echo area window to fit
1528 that message's size exactly. */
1529 if (!NILP (echo_area_buffer
[0]))
1530 resize_echo_area_exactly ();
1532 if (!NILP (Vdeferred_action_list
))
1533 safe_run_hooks (Qdeferred_action_function
);
1536 /* Do this after running Vpost_command_hook, for consistency. */
1537 current_kboard
->Vlast_command
= Vthis_command
;
1538 current_kboard
->Vreal_last_command
= real_this_command
;
1542 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1545 /* Make sure the current window's buffer is selected. */
1546 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1547 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1549 /* Display any malloc warning that just came out. Use while because
1550 displaying one warning can cause another. */
1552 while (pending_malloc_warning
)
1553 display_malloc_warning ();
1557 Vdeactivate_mark
= Qnil
;
1559 /* If minibuffer on and echo area in use,
1560 wait a short time and redraw minibuffer. */
1563 && !NILP (echo_area_buffer
[0])
1564 && EQ (minibuf_window
, echo_area_window
))
1566 /* Bind inhibit-quit to t so that C-g gets read in
1567 rather than quitting back to the minibuffer. */
1568 int count
= SPECPDL_INDEX ();
1569 specbind (Qinhibit_quit
, Qt
);
1571 if (NUMBERP (Vminibuffer_message_timeout
))
1572 sit_for (Vminibuffer_message_timeout
, 0, 2);
1576 /* Clear the echo area. */
1578 safe_run_hooks (Qecho_area_clear_hook
);
1580 unbind_to (count
, Qnil
);
1582 /* If a C-g came in before, treat it as input now. */
1583 if (!NILP (Vquit_flag
))
1586 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1591 alloca (0); /* Cause a garbage collection now */
1592 /* Since we can free the most stuff here. */
1593 #endif /* C_ALLOCA */
1596 /* Select the frame that the last event came from. Usually,
1597 switch-frame events will take care of this, but if some lisp
1598 code swallows a switch-frame event, we'll fix things up here.
1599 Is this a good idea? */
1600 if (FRAMEP (internal_last_event_frame
)
1601 && !EQ (internal_last_event_frame
, selected_frame
))
1602 Fselect_frame (internal_last_event_frame
);
1604 /* If it has changed current-menubar from previous value,
1605 really recompute the menubar from the value. */
1606 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1607 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1608 call0 (Qrecompute_lucid_menubar
);
1610 before_command_key_count
= this_command_key_count
;
1611 before_command_echo_length
= echo_length ();
1613 Vthis_command
= Qnil
;
1614 real_this_command
= Qnil
;
1615 Vthis_original_command
= Qnil
;
1617 /* Read next key sequence; i gets its length. */
1618 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1621 /* A filter may have run while we were reading the input. */
1622 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1624 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1625 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1629 /* Now we have read a key sequence of length I,
1630 or else I is 0 and we found end of file. */
1632 if (i
== 0) /* End of file -- happens only in */
1633 return Qnil
; /* a kbd macro, at the end. */
1634 /* -1 means read_key_sequence got a menu that was rejected.
1635 Just loop around and read another command. */
1639 this_command_key_count
= 0;
1640 this_command_key_count_reset
= 0;
1641 this_single_command_key_start
= 0;
1645 last_command_char
= keybuf
[i
- 1];
1647 /* If the previous command tried to force a specific window-start,
1648 forget about that, in case this command moves point far away
1649 from that position. But also throw away beg_unchanged and
1650 end_unchanged information in that case, so that redisplay will
1651 update the whole window properly. */
1652 if (!NILP (XWINDOW (selected_window
)->force_start
))
1655 XWINDOW (selected_window
)->force_start
= Qnil
;
1656 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1657 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1660 cmd
= read_key_sequence_cmd
;
1661 if (!NILP (Vexecuting_kbd_macro
))
1663 if (!NILP (Vquit_flag
))
1665 Vexecuting_kbd_macro
= Qt
;
1666 QUIT
; /* Make some noise. */
1667 /* Will return since macro now empty. */
1671 /* Do redisplay processing after this command except in special
1672 cases identified below. */
1673 prev_buffer
= current_buffer
;
1674 prev_modiff
= MODIFF
;
1675 last_point_position
= PT
;
1676 last_point_position_window
= selected_window
;
1677 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1679 /* By default, we adjust point to a boundary of a region that
1680 has such a property that should be treated intangible
1681 (e.g. composition, display). But, some commands will set
1682 this variable differently. */
1683 Vdisable_point_adjustment
= Qnil
;
1685 /* Process filters and timers may have messed with deactivate-mark.
1686 reset it before we execute the command. */
1687 Vdeactivate_mark
= Qnil
;
1689 /* Remap command through active keymaps */
1690 Vthis_original_command
= cmd
;
1694 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1698 /* Execute the command. */
1700 Vthis_command
= cmd
;
1701 real_this_command
= cmd
;
1702 /* Note that the value cell will never directly contain nil
1703 if the symbol is a local variable. */
1704 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1705 safe_run_hooks (Qpre_command_hook
);
1707 already_adjusted
= 0;
1709 if (NILP (Vthis_command
))
1711 /* nil means key is undefined. */
1712 Lisp_Object keys
= Fvector (i
, keybuf
);
1713 keys
= Fkey_description (keys
, Qnil
);
1715 message_with_string ("%s is undefined", keys
, 0);
1716 current_kboard
->defining_kbd_macro
= Qnil
;
1717 update_mode_lines
= 1;
1718 current_kboard
->Vprefix_arg
= Qnil
;
1722 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1724 /* In case we jump to directly_done. */
1725 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1727 /* Recognize some common commands in common situations and
1728 do them directly. */
1729 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1731 struct Lisp_Char_Table
*dp
1732 = window_display_table (XWINDOW (selected_window
));
1733 lose
= FETCH_CHAR (PT_BYTE
);
1735 if (! NILP (Vpost_command_hook
))
1736 /* Put this before calling adjust_point_for_property
1737 so it will only get called once in any case. */
1739 if (current_buffer
== prev_buffer
1740 && last_point_position
!= PT
1741 && NILP (Vdisable_point_adjustment
)
1742 && NILP (Vglobal_disable_point_adjustment
))
1743 adjust_point_for_property (last_point_position
, 0);
1744 already_adjusted
= 1;
1745 if (PT
== last_point_position
+ 1
1747 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1748 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1749 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1750 && (lose
>= 0x20 && lose
< 0x7f)))
1751 : (lose
>= 0x20 && lose
< 0x7f))
1752 /* To extract the case of continuation on
1753 wide-column characters. */
1754 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE
)) == 1)
1755 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1757 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1759 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1761 && !windows_or_buffers_changed
1762 && EQ (current_buffer
->selective_display
, Qnil
)
1763 && !detect_input_pending ()
1764 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1765 && NILP (Vexecuting_kbd_macro
))
1766 direct_output_forward_char (1);
1769 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1771 struct Lisp_Char_Table
*dp
1772 = window_display_table (XWINDOW (selected_window
));
1774 lose
= FETCH_CHAR (PT_BYTE
);
1775 if (! NILP (Vpost_command_hook
))
1777 if (current_buffer
== prev_buffer
1778 && last_point_position
!= PT
1779 && NILP (Vdisable_point_adjustment
)
1780 && NILP (Vglobal_disable_point_adjustment
))
1781 adjust_point_for_property (last_point_position
, 0);
1782 already_adjusted
= 1;
1783 if (PT
== last_point_position
- 1
1785 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1786 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1787 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1788 && (lose
>= 0x20 && lose
< 0x7f)))
1789 : (lose
>= 0x20 && lose
< 0x7f))
1790 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1792 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1794 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1796 && !windows_or_buffers_changed
1797 && EQ (current_buffer
->selective_display
, Qnil
)
1798 && !detect_input_pending ()
1799 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1800 && NILP (Vexecuting_kbd_macro
))
1801 direct_output_forward_char (-1);
1804 else if (EQ (Vthis_command
, Qself_insert_command
)
1805 /* Try this optimization only on char keystrokes. */
1806 && NATNUMP (last_command_char
)
1807 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1810 = translate_char (Vtranslation_table_for_input
,
1811 XFASTINT (last_command_char
), 0, 0, 0);
1813 if (NILP (Vexecuting_kbd_macro
)
1814 && !EQ (minibuf_window
, selected_window
))
1816 if (!nonundocount
|| nonundocount
>= 20)
1824 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1826 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1828 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1830 || MODIFF
<= SAVE_MODIFF
1831 || windows_or_buffers_changed
1832 || !EQ (current_buffer
->selective_display
, Qnil
)
1833 || detect_input_pending ()
1834 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1835 || !NILP (Vexecuting_kbd_macro
));
1837 value
= internal_self_insert (c
, 0);
1842 if (! NILP (Vpost_command_hook
))
1843 /* Put this before calling adjust_point_for_property
1844 so it will only get called once in any case. */
1847 /* VALUE == 1 when AFTER-CHANGE functions are
1848 installed which is the case most of the time
1849 because FONT-LOCK installs one. */
1850 if (!lose
&& !value
)
1851 direct_output_for_insert (c
);
1856 /* Here for a command that isn't executed directly */
1859 #ifdef HAVE_X_WINDOWS
1860 int scount
= SPECPDL_INDEX ();
1862 if (display_hourglass_p
1863 && NILP (Vexecuting_kbd_macro
))
1865 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1871 if (NILP (current_kboard
->Vprefix_arg
))
1873 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1875 #ifdef HAVE_X_WINDOWS
1876 /* Do not check display_hourglass_p here, because
1877 Fcommand_execute could change it, but we should cancel
1878 hourglass cursor anyway.
1879 But don't cancel the hourglass within a macro
1880 just because a command in the macro finishes. */
1881 if (NILP (Vexecuting_kbd_macro
))
1882 unbind_to (scount
, Qnil
);
1887 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1889 /* Note that the value cell will never directly contain nil
1890 if the symbol is a local variable. */
1891 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1892 safe_run_hooks (Qpost_command_hook
);
1894 /* If displaying a message, resize the echo area window to fit
1895 that message's size exactly. */
1896 if (!NILP (echo_area_buffer
[0]))
1897 resize_echo_area_exactly ();
1899 if (!NILP (Vdeferred_action_list
))
1900 safe_run_hooks (Qdeferred_action_function
);
1902 /* If there is a prefix argument,
1903 1) We don't want Vlast_command to be ``universal-argument''
1904 (that would be dumb), so don't set Vlast_command,
1905 2) we want to leave echoing on so that the prefix will be
1906 echoed as part of this key sequence, so don't call
1908 3) we want to leave this_command_key_count non-zero, so that
1909 read_char will realize that it is re-reading a character, and
1910 not echo it a second time.
1912 If the command didn't actually create a prefix arg,
1913 but is merely a frame event that is transparent to prefix args,
1914 then the above doesn't apply. */
1915 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1917 current_kboard
->Vlast_command
= Vthis_command
;
1918 current_kboard
->Vreal_last_command
= real_this_command
;
1920 this_command_key_count
= 0;
1921 this_command_key_count_reset
= 0;
1922 this_single_command_key_start
= 0;
1925 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1927 /* Setting transient-mark-mode to `only' is a way of
1928 turning it on for just one command. */
1930 if (EQ (Vtransient_mark_mode
, Qidentity
))
1931 Vtransient_mark_mode
= Qnil
;
1932 if (EQ (Vtransient_mark_mode
, Qonly
))
1933 Vtransient_mark_mode
= Qidentity
;
1935 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1937 /* We could also call `deactivate'mark'. */
1938 if (EQ (Vtransient_mark_mode
, Qlambda
))
1939 Vtransient_mark_mode
= Qnil
;
1942 current_buffer
->mark_active
= Qnil
;
1943 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1946 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1947 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1952 if (current_buffer
== prev_buffer
1953 && last_point_position
!= PT
1954 && NILP (Vdisable_point_adjustment
)
1955 && NILP (Vglobal_disable_point_adjustment
)
1956 && !already_adjusted
)
1957 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
1959 /* Install chars successfully executed in kbd macro. */
1961 if (!NILP (current_kboard
->defining_kbd_macro
)
1962 && NILP (current_kboard
->Vprefix_arg
))
1963 finalize_kbd_macro_chars ();
1967 any_kboard_state ();
1972 extern Lisp_Object Qcomposition
, Qdisplay
;
1974 /* Adjust point to a boundary of a region that has such a property
1975 that should be treated intangible. For the moment, we check
1976 `composition', `display' and `invisible' properties.
1977 LAST_PT is the last position of point. */
1979 extern Lisp_Object Qafter_string
, Qbefore_string
;
1980 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
1983 adjust_point_for_property (last_pt
, modified
)
1988 Lisp_Object val
, overlay
, tmp
;
1989 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
1992 /* FIXME: cycling is probably not necessary because these properties
1993 can't be usefully combined anyway. */
1994 while (check_composition
|| check_display
|| check_invisible
)
1996 if (check_composition
1997 && PT
> BEGV
&& PT
< ZV
1998 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
1999 && COMPOSITION_VALID_P (beg
, end
, val
)
2000 && beg
< PT
/* && end > PT <- It's always the case. */
2001 && (last_pt
<= beg
|| last_pt
>= end
))
2004 SET_PT (PT
< last_pt
? beg
: end
);
2005 check_display
= check_invisible
= 1;
2007 check_composition
= 0;
2009 && PT
> BEGV
&& PT
< ZV
2010 && !NILP (val
= get_char_property_and_overlay
2011 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
2012 && display_prop_intangible_p (val
)
2013 && (!OVERLAYP (overlay
)
2014 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
2015 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
2016 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
2017 && (beg
< PT
/* && end > PT <- It's always the case. */
2018 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
2021 SET_PT (PT
< last_pt
2022 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
2024 check_composition
= check_invisible
= 1;
2027 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
2029 int inv
, ellipsis
= 0;
2032 /* Find boundaries `beg' and `end' of the invisible area, if any. */
2034 && !NILP (val
= get_char_property_and_overlay
2035 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
2036 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2038 ellipsis
= ellipsis
|| inv
> 1
2039 || (OVERLAYP (overlay
)
2040 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2041 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2042 tmp
= Fnext_single_char_property_change
2043 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
2044 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
2047 && !NILP (val
= get_char_property_and_overlay
2048 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
2049 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2051 ellipsis
= ellipsis
|| inv
> 1
2052 || (OVERLAYP (overlay
)
2053 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2054 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2055 tmp
= Fprevious_single_char_property_change
2056 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
2057 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
2060 /* Move away from the inside area. */
2061 if (beg
< PT
&& end
> PT
)
2063 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
2064 /* We haven't moved yet (so we don't need to fear
2065 infinite-looping) and we were outside the range
2066 before (so either end of the range still corresponds
2067 to a move in the right direction): pretend we moved
2068 less than we actually did, so that we still have
2069 more freedom below in choosing which end of the range
2071 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
2072 /* We either have moved already or the last point
2073 was already in the range: we don't get to choose
2074 which end of the range we have to go to. */
2075 : (PT
< last_pt
? beg
: end
));
2076 check_composition
= check_display
= 1;
2078 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
2079 the point to something other than its argument, due to
2080 point-motion hooks, intangibility, etc. */
2081 xassert (PT
== beg
|| PT
== end
);
2084 /* Pretend the area doesn't exist if the buffer is not
2086 if (!modified
&& !ellipsis
&& beg
< end
)
2088 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
2089 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
2090 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
2091 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
2092 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
2093 /* We've already moved as far as we can. Trying to go
2094 to the other end would mean moving backwards and thus
2095 could lead to an infinite loop. */
2097 else if (val
= get_pos_property (make_number (PT
),
2099 TEXT_PROP_MEANS_INVISIBLE (val
)
2100 && (val
= get_pos_property
2101 (make_number (PT
== beg
? end
: beg
),
2103 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2104 (check_composition
= check_display
= 1,
2105 SET_PT (PT
== beg
? end
: beg
));
2108 check_invisible
= 0;
2112 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2115 safe_run_hooks_1 (hook
)
2118 if (NILP (Vrun_hooks
))
2120 return call1 (Vrun_hooks
, Vinhibit_quit
);
2123 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2126 safe_run_hooks_error (data
)
2129 Lisp_Object args
[3];
2130 args
[0] = build_string ("Error in %s: %s");
2131 args
[1] = Vinhibit_quit
;
2134 return Fset (Vinhibit_quit
, Qnil
);
2137 /* If we get an error while running the hook, cause the hook variable
2138 to be nil. Also inhibit quits, so that C-g won't cause the hook
2139 to mysteriously evaporate. */
2142 safe_run_hooks (hook
)
2145 int count
= SPECPDL_INDEX ();
2146 specbind (Qinhibit_quit
, hook
);
2148 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2150 unbind_to (count
, Qnil
);
2154 /* Number of seconds between polling for input. This is a Lisp
2155 variable that can be bound. */
2157 EMACS_INT polling_period
;
2159 /* Nonzero means polling for input is temporarily suppressed. */
2161 int poll_suppress_count
;
2163 /* Asynchronous timer for polling. */
2165 struct atimer
*poll_timer
;
2168 #ifdef POLL_FOR_INPUT
2170 /* Poll for input, so what we catch a C-g if it comes in. This
2171 function is called from x_make_frame_visible, see comment
2177 if (interrupt_input_blocked
== 0
2178 && !waiting_for_input
)
2179 read_avail_input (0);
2182 /* Timer callback function for poll_timer. TIMER is equal to
2186 poll_for_input (timer
)
2187 struct atimer
*timer
;
2189 if (poll_suppress_count
== 0)
2191 interrupt_input_pending
= 1;
2193 poll_for_input_1 ();
2197 #endif /* POLL_FOR_INPUT */
2199 /* Begin signals to poll for input, if they are appropriate.
2200 This function is called unconditionally from various places. */
2205 #ifdef POLL_FOR_INPUT
2206 if (read_socket_hook
&& !interrupt_input
)
2208 /* Turn alarm handling on unconditionally. It might have
2209 been turned off in process.c. */
2210 turn_on_atimers (1);
2212 /* If poll timer doesn't exist, are we need one with
2213 a different interval, start a new one. */
2214 if (poll_timer
== NULL
2215 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2217 EMACS_TIME interval
;
2220 cancel_atimer (poll_timer
);
2222 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2223 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2224 poll_for_input
, NULL
);
2227 /* Let the timer's callback function poll for input
2228 if this becomes zero. */
2229 --poll_suppress_count
;
2234 /* Nonzero if we are using polling to handle input asynchronously. */
2237 input_polling_used ()
2239 #ifdef POLL_FOR_INPUT
2240 return read_socket_hook
&& !interrupt_input
;
2246 /* Turn off polling. */
2251 #ifdef POLL_FOR_INPUT
2252 if (read_socket_hook
&& !interrupt_input
)
2253 ++poll_suppress_count
;
2257 /* Set the value of poll_suppress_count to COUNT
2258 and start or stop polling accordingly. */
2261 set_poll_suppress_count (count
)
2264 #ifdef POLL_FOR_INPUT
2265 if (count
== 0 && poll_suppress_count
!= 0)
2267 poll_suppress_count
= 1;
2270 else if (count
!= 0 && poll_suppress_count
== 0)
2274 poll_suppress_count
= count
;
2278 /* Bind polling_period to a value at least N.
2279 But don't decrease it. */
2282 bind_polling_period (n
)
2285 #ifdef POLL_FOR_INPUT
2286 int new = polling_period
;
2291 stop_other_atimers (poll_timer
);
2293 specbind (Qpolling_period
, make_number (new));
2294 /* Start a new alarm with the new period. */
2299 /* Apply the control modifier to CHARACTER. */
2305 /* Save the upper bits here. */
2306 int upper
= c
& ~0177;
2310 /* Everything in the columns containing the upper-case letters
2311 denotes a control character. */
2312 if (c
>= 0100 && c
< 0140)
2316 /* Set the shift modifier for a control char
2317 made from a shifted letter. But only for letters! */
2318 if (oc
>= 'A' && oc
<= 'Z')
2319 c
|= shift_modifier
;
2322 /* The lower-case letters denote control characters too. */
2323 else if (c
>= 'a' && c
<= 'z')
2326 /* Include the bits for control and shift
2327 only if the basic ASCII code can't indicate them. */
2331 /* Replace the high bits. */
2332 c
|= (upper
& ~ctrl_modifier
);
2337 /* Display the help-echo property of the character after the mouse pointer.
2338 Either show it in the echo area, or call show-help-function to display
2339 it by other means (maybe in a tooltip).
2341 If HELP is nil, that means clear the previous help echo.
2343 If HELP is a string, display that string. If HELP is a function,
2344 call it with OBJECT and POS as arguments; the function should
2345 return a help string or nil for none. For all other types of HELP,
2346 evaluate it to obtain a string.
2348 WINDOW is the window in which the help was generated, if any.
2349 It is nil if not in a window.
2351 If OBJECT is a buffer, POS is the position in the buffer where the
2352 `help-echo' text property was found.
2354 If OBJECT is an overlay, that overlay has a `help-echo' property,
2355 and POS is the position in the overlay's buffer under the mouse.
2357 If OBJECT is a string (an overlay string or a string displayed with
2358 the `display' property). POS is the position in that string under
2361 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2362 echo overwrites a keystroke echo currently displayed in the echo
2365 Note: this function may only be called with HELP nil or a string
2366 from X code running asynchronously. */
2369 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2370 Lisp_Object help
, window
, object
, pos
;
2371 int ok_to_overwrite_keystroke_echo
;
2373 if (!NILP (help
) && !STRINGP (help
))
2375 if (FUNCTIONP (help
))
2377 Lisp_Object args
[4];
2382 help
= safe_call (4, args
);
2385 help
= safe_eval (help
);
2387 if (!STRINGP (help
))
2391 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2392 if (!noninteractive
&& STRINGP (help
))
2394 /* The mouse-fixup-help-message Lisp function can call
2395 mouse_position_hook, which resets the mouse_moved flags.
2396 This causes trouble if we are trying to read a mouse motion
2397 event (i.e., if we are inside a `track-mouse' form), so we
2398 restore the mouse_moved flag. */
2399 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2400 help
= call1 (Qmouse_fixup_help_message
, help
);
2406 if (STRINGP (help
) || NILP (help
))
2408 if (!NILP (Vshow_help_function
))
2409 call1 (Vshow_help_function
, help
);
2410 else if (/* Don't overwrite minibuffer contents. */
2411 !MINI_WINDOW_P (XWINDOW (selected_window
))
2412 /* Don't overwrite a keystroke echo. */
2413 && (NILP (echo_message_buffer
)
2414 || ok_to_overwrite_keystroke_echo
)
2415 /* Don't overwrite a prompt. */
2416 && !cursor_in_echo_area
)
2420 int count
= SPECPDL_INDEX ();
2422 if (!help_echo_showing_p
)
2423 Vpre_help_message
= current_message ();
2425 specbind (Qmessage_truncate_lines
, Qt
);
2426 message3_nolog (help
, SBYTES (help
),
2427 STRING_MULTIBYTE (help
));
2428 unbind_to (count
, Qnil
);
2430 else if (STRINGP (Vpre_help_message
))
2432 message3_nolog (Vpre_help_message
,
2433 SBYTES (Vpre_help_message
),
2434 STRING_MULTIBYTE (Vpre_help_message
));
2435 Vpre_help_message
= Qnil
;
2441 help_echo_showing_p
= STRINGP (help
);
2447 /* Input of single characters from keyboard */
2449 Lisp_Object
print_help ();
2450 static Lisp_Object
kbd_buffer_get_event ();
2451 static void record_char ();
2453 static Lisp_Object help_form_saved_window_configs
;
2455 read_char_help_form_unwind (arg
)
2457 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2458 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2459 if (!NILP (window_config
))
2460 Fset_window_configuration (window_config
);
2465 static jmp_buf wrong_kboard_jmpbuf
;
2468 #define STOP_POLLING \
2469 do { if (! polling_stopped_here) stop_polling (); \
2470 polling_stopped_here = 1; } while (0)
2472 #define RESUME_POLLING \
2473 do { if (polling_stopped_here) start_polling (); \
2474 polling_stopped_here = 0; } while (0)
2476 /* read a character from the keyboard; call the redisplay if needed */
2477 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2478 -1 means do not do redisplay, but do do autosaving.
2481 /* The arguments MAPS and NMAPS are for menu prompting.
2482 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2484 PREV_EVENT is the previous input event, or nil if we are reading
2485 the first event of a key sequence (or not reading a key sequence).
2486 If PREV_EVENT is t, that is a "magic" value that says
2487 not to run input methods, but in other respects to act as if
2488 not reading a key sequence.
2490 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2491 if we used a mouse menu to read the input, or zero otherwise. If
2492 USED_MOUSE_MENU is null, we don't dereference it.
2494 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2495 specifying the maximum time to wait until. If no input arrives by
2496 that time, stop waiting and return nil.
2498 Value is t if we showed a menu and the user rejected it. */
2501 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
, end_time
)
2505 Lisp_Object prev_event
;
2506 int *used_mouse_menu
;
2507 EMACS_TIME
*end_time
;
2509 volatile Lisp_Object c
;
2510 int count
, jmpcount
;
2511 jmp_buf local_getcjmp
;
2513 volatile int key_already_recorded
= 0;
2514 Lisp_Object tem
, save
;
2515 volatile Lisp_Object previous_echo_area_message
;
2516 volatile Lisp_Object also_record
;
2517 volatile int reread
;
2518 struct gcpro gcpro1
, gcpro2
;
2519 int polling_stopped_here
= 0;
2523 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2524 before_command_key_count
= this_command_key_count
;
2525 before_command_echo_length
= echo_length ();
2528 previous_echo_area_message
= Qnil
;
2530 GCPRO2 (c
, previous_echo_area_message
);
2535 if (CONSP (Vunread_post_input_method_events
))
2537 c
= XCAR (Vunread_post_input_method_events
);
2538 Vunread_post_input_method_events
2539 = XCDR (Vunread_post_input_method_events
);
2541 /* Undo what read_char_x_menu_prompt did when it unread
2542 additional keys returned by Fx_popup_menu. */
2544 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2552 if (unread_command_char
!= -1)
2554 XSETINT (c
, unread_command_char
);
2555 unread_command_char
= -1;
2561 if (CONSP (Vunread_command_events
))
2563 c
= XCAR (Vunread_command_events
);
2564 Vunread_command_events
= XCDR (Vunread_command_events
);
2568 /* Undo what sit-for did when it unread additional keys
2569 inside universal-argument. */
2572 && EQ (XCAR (c
), Qt
))
2578 /* Undo what read_char_x_menu_prompt did when it unread
2579 additional keys returned by Fx_popup_menu. */
2581 && EQ (XCDR (c
), Qdisabled
)
2582 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2585 /* If the queued event is something that used the mouse,
2586 set used_mouse_menu accordingly. */
2588 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2589 *used_mouse_menu
= 1;
2591 goto reread_for_input_method
;
2594 if (CONSP (Vunread_input_method_events
))
2596 c
= XCAR (Vunread_input_method_events
);
2597 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2599 /* Undo what read_char_x_menu_prompt did when it unread
2600 additional keys returned by Fx_popup_menu. */
2602 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2606 goto reread_for_input_method
;
2609 this_command_key_count_reset
= 0;
2611 if (!NILP (Vexecuting_kbd_macro
))
2613 /* We set this to Qmacro; since that's not a frame, nobody will
2614 try to switch frames on us, and the selected window will
2617 Since this event came from a macro, it would be misleading to
2618 leave internal_last_event_frame set to wherever the last
2619 real event came from. Normally, a switch-frame event selects
2620 internal_last_event_frame after each command is read, but
2621 events read from a macro should never cause a new frame to be
2623 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2625 /* Exit the macro if we are at the end.
2626 Also, some things replace the macro with t
2627 to force an early exit. */
2628 if (EQ (Vexecuting_kbd_macro
, Qt
)
2629 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2635 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2636 if (STRINGP (Vexecuting_kbd_macro
)
2637 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2638 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2640 executing_kbd_macro_index
++;
2645 if (!NILP (unread_switch_frame
))
2647 c
= unread_switch_frame
;
2648 unread_switch_frame
= Qnil
;
2650 /* This event should make it into this_command_keys, and get echoed
2651 again, so we do not set `reread'. */
2655 /* if redisplay was requested */
2656 if (commandflag
>= 0)
2658 /* If there is pending input, process any events which are not
2659 user-visible, such as X selection_request events. */
2661 || detect_input_pending_run_timers (0))
2662 swallow_events (0); /* may clear input_pending */
2664 /* Redisplay if no pending input. */
2665 while (!input_pending
)
2667 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2668 redisplay_preserve_echo_area (5);
2673 /* Normal case: no input arrived during redisplay. */
2676 /* Input arrived and pre-empted redisplay.
2677 Process any events which are not user-visible. */
2679 /* If that cleared input_pending, try again to redisplay. */
2683 /* Message turns off echoing unless more keystrokes turn it on again.
2685 The code in 20.x for the condition was
2687 1. echo_area_glyphs && *echo_area_glyphs
2688 2. && echo_area_glyphs != current_kboard->echobuf
2689 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2691 (1) means there's a current message displayed
2693 (2) means it's not the message from echoing from the current
2696 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2697 is set to a non-null value. This is done in read_char and it is
2698 set to echo_area_glyphs after a call to echo_char. That means
2699 ok_to_echo_at_next_pause is either null or
2700 current_kboard->echobuf with the appropriate current_kboard at
2703 So, condition (3) means in clear text ok_to_echo_at_next_pause
2704 must be either null, or the current message isn't from echoing at
2705 all, or it's from echoing from a different kboard than the
2708 if (/* There currently is something in the echo area. */
2709 !NILP (echo_area_buffer
[0])
2710 && (/* And it's either not from echoing. */
2711 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2712 /* Or it's an echo from a different kboard. */
2713 || echo_kboard
!= current_kboard
2714 /* Or we explicitly allow overwriting whatever there is. */
2715 || ok_to_echo_at_next_pause
== NULL
))
2720 /* Try reading a character via menu prompting in the minibuf.
2721 Try this before the sit-for, because the sit-for
2722 would do the wrong thing if we are supposed to do
2723 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2724 after a mouse event so don't try a minibuf menu. */
2726 if (nmaps
> 0 && INTERACTIVE
2727 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2728 /* Don't bring up a menu if we already have another event. */
2729 && NILP (Vunread_command_events
)
2730 && unread_command_char
< 0
2731 && !detect_input_pending_run_timers (0))
2733 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2736 key_already_recorded
= 1;
2741 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2742 We will do that below, temporarily for short sections of code,
2743 when appropriate. local_getcjmp must be in effect
2744 around any call to sit_for or kbd_buffer_get_event;
2745 it *must not* be in effect when we call redisplay. */
2747 jmpcount
= SPECPDL_INDEX ();
2748 if (_setjmp (local_getcjmp
))
2750 /* We must have saved the outer value of getcjmp here,
2751 so restore it now. */
2752 restore_getcjmp (save_jump
);
2753 unbind_to (jmpcount
, Qnil
);
2754 XSETINT (c
, quit_char
);
2755 internal_last_event_frame
= selected_frame
;
2756 Vlast_event_frame
= internal_last_event_frame
;
2757 /* If we report the quit char as an event,
2758 don't do so more than once. */
2759 if (!NILP (Vinhibit_quit
))
2764 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2765 if (kb
!= current_kboard
)
2767 Lisp_Object link
= kb
->kbd_queue
;
2768 /* We shouldn't get here if we were in single-kboard mode! */
2773 while (CONSP (XCDR (link
)))
2775 if (!NILP (XCDR (link
)))
2779 kb
->kbd_queue
= Fcons (c
, Qnil
);
2781 XSETCDR (link
, Fcons (c
, Qnil
));
2782 kb
->kbd_queue_has_data
= 1;
2783 current_kboard
= kb
;
2784 /* This is going to exit from read_char
2785 so we had better get rid of this frame's stuff. */
2787 longjmp (wrong_kboard_jmpbuf
, 1);
2794 /* Start idle timers if no time limit is supplied. We don't do it
2795 if a time limit is supplied to avoid an infinite recursion in the
2796 situation where an idle timer calls `sit-for'. */
2799 timer_start_idle ();
2801 /* If in middle of key sequence and minibuffer not active,
2802 start echoing if enough time elapses. */
2804 if (minibuf_level
== 0
2806 && !current_kboard
->immediate_echo
2807 && this_command_key_count
> 0
2809 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2810 && NILP (Fzerop (Vecho_keystrokes
))
2811 && (/* No message. */
2812 NILP (echo_area_buffer
[0])
2813 /* Or empty message. */
2814 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2815 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2816 /* Or already echoing from same kboard. */
2817 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2818 /* Or not echoing before and echoing allowed. */
2819 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2821 /* After a mouse event, start echoing right away.
2822 This is because we are probably about to display a menu,
2823 and we don't want to delay before doing so. */
2824 if (EVENT_HAS_PARAMETERS (prev_event
))
2830 save_getcjmp (save_jump
);
2831 restore_getcjmp (local_getcjmp
);
2832 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2833 restore_getcjmp (save_jump
);
2835 && ! CONSP (Vunread_command_events
))
2840 /* Maybe auto save due to number of keystrokes. */
2842 if (commandflag
!= 0
2843 && auto_save_interval
> 0
2844 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2845 && !detect_input_pending_run_timers (0))
2847 Fdo_auto_save (Qnil
, Qnil
);
2848 /* Hooks can actually change some buffers in auto save. */
2852 /* Try reading using an X menu.
2853 This is never confused with reading using the minibuf
2854 because the recursive call of read_char in read_char_minibuf_menu_prompt
2855 does not pass on any keymaps. */
2857 if (nmaps
> 0 && INTERACTIVE
2858 && !NILP (prev_event
)
2859 && EVENT_HAS_PARAMETERS (prev_event
)
2860 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2861 && !EQ (XCAR (prev_event
), Qtool_bar
)
2862 /* Don't bring up a menu if we already have another event. */
2863 && NILP (Vunread_command_events
)
2864 && unread_command_char
< 0)
2866 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2868 /* Now that we have read an event, Emacs is not idle. */
2875 /* Maybe autosave and/or garbage collect due to idleness. */
2877 if (INTERACTIVE
&& NILP (c
))
2879 int delay_level
, buffer_size
;
2881 /* Slow down auto saves logarithmically in size of current buffer,
2882 and garbage collect while we're at it. */
2883 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2884 last_non_minibuf_size
= Z
- BEG
;
2885 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2887 while (buffer_size
> 64)
2888 delay_level
++, buffer_size
-= buffer_size
>> 2;
2889 if (delay_level
< 4) delay_level
= 4;
2890 /* delay_level is 4 for files under around 50k, 7 at 100k,
2891 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2893 /* Auto save if enough time goes by without input. */
2894 if (commandflag
!= 0
2895 && num_nonmacro_input_events
> last_auto_save
2896 && INTEGERP (Vauto_save_timeout
)
2897 && XINT (Vauto_save_timeout
) > 0)
2900 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2902 save_getcjmp (save_jump
);
2903 restore_getcjmp (local_getcjmp
);
2904 tem0
= sit_for (make_number (timeout
), 1, 1);
2905 restore_getcjmp (save_jump
);
2908 && ! CONSP (Vunread_command_events
))
2910 Fdo_auto_save (Qnil
, Qnil
);
2912 /* If we have auto-saved and there is still no input
2913 available, garbage collect if there has been enough
2914 consing going on to make it worthwhile. */
2915 if (!detect_input_pending_run_timers (0)
2916 && consing_since_gc
> gc_cons_threshold
/ 2)
2917 Fgarbage_collect ();
2924 /* If this has become non-nil here, it has been set by a timer
2925 or sentinel or filter. */
2926 if (CONSP (Vunread_command_events
))
2928 c
= XCAR (Vunread_command_events
);
2929 Vunread_command_events
= XCDR (Vunread_command_events
);
2932 /* Read something from current KBOARD's side queue, if possible. */
2936 if (current_kboard
->kbd_queue_has_data
)
2938 if (!CONSP (current_kboard
->kbd_queue
))
2940 c
= XCAR (current_kboard
->kbd_queue
);
2941 current_kboard
->kbd_queue
2942 = XCDR (current_kboard
->kbd_queue
);
2943 if (NILP (current_kboard
->kbd_queue
))
2944 current_kboard
->kbd_queue_has_data
= 0;
2945 input_pending
= readable_events (0);
2946 if (EVENT_HAS_PARAMETERS (c
)
2947 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2948 internal_last_event_frame
= XCAR (XCDR (c
));
2949 Vlast_event_frame
= internal_last_event_frame
;
2954 /* If current_kboard's side queue is empty check the other kboards.
2955 If one of them has data that we have not yet seen here,
2956 switch to it and process the data waiting for it.
2958 Note: if the events queued up for another kboard
2959 have already been seen here, and therefore are not a complete command,
2960 the kbd_queue_has_data field is 0, so we skip that kboard here.
2961 That's to avoid an infinite loop switching between kboards here. */
2962 if (NILP (c
) && !single_kboard
)
2965 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2966 if (kb
->kbd_queue_has_data
)
2968 current_kboard
= kb
;
2969 /* This is going to exit from read_char
2970 so we had better get rid of this frame's stuff. */
2972 longjmp (wrong_kboard_jmpbuf
, 1);
2981 /* Finally, we read from the main queue,
2982 and if that gives us something we can't use yet, we put it on the
2983 appropriate side queue and try again. */
2992 EMACS_GET_TIME (now
);
2993 if (EMACS_TIME_GE (now
, *end_time
))
2997 /* Actually read a character, waiting if necessary. */
2998 save_getcjmp (save_jump
);
2999 restore_getcjmp (local_getcjmp
);
3001 timer_start_idle ();
3002 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
3003 restore_getcjmp (save_jump
);
3006 if (! NILP (c
) && (kb
!= current_kboard
))
3008 Lisp_Object link
= kb
->kbd_queue
;
3011 while (CONSP (XCDR (link
)))
3013 if (!NILP (XCDR (link
)))
3017 kb
->kbd_queue
= Fcons (c
, Qnil
);
3019 XSETCDR (link
, Fcons (c
, Qnil
));
3020 kb
->kbd_queue_has_data
= 1;
3024 current_kboard
= kb
;
3025 /* This is going to exit from read_char
3026 so we had better get rid of this frame's stuff. */
3028 longjmp (wrong_kboard_jmpbuf
, 1);
3033 /* Terminate Emacs in batch mode if at eof. */
3034 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
3035 Fkill_emacs (make_number (1));
3039 /* Add in any extra modifiers, where appropriate. */
3040 if ((extra_keyboard_modifiers
& CHAR_CTL
)
3041 || ((extra_keyboard_modifiers
& 0177) < ' '
3042 && (extra_keyboard_modifiers
& 0177) != 0))
3043 XSETINT (c
, make_ctrl_char (XINT (c
)));
3045 /* Transfer any other modifier bits directly from
3046 extra_keyboard_modifiers to c. Ignore the actual character code
3047 in the low 16 bits of extra_keyboard_modifiers. */
3048 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
3059 if (commandflag
>= 0
3060 && !input_pending
&& !detect_input_pending_run_timers (0))
3068 /* Buffer switch events are only for internal wakeups
3069 so don't show them to the user.
3070 Also, don't record a key if we already did. */
3071 if (BUFFERP (c
) || key_already_recorded
)
3074 /* Process special events within read_char
3075 and loop around to read another event. */
3078 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
3083 int was_locked
= single_kboard
;
3085 last_input_char
= c
;
3086 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
3088 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
3089 /* We stopped being idle for this event; undo that. This
3090 prevents automatic window selection (under
3091 mouse_autoselect_window from acting as a real input event, for
3092 example banishing the mouse under mouse-avoidance-mode. */
3093 timer_resume_idle ();
3095 /* Resume allowing input from any kboard, if that was true before. */
3097 any_kboard_state ();
3102 /* Handle things that only apply to characters. */
3105 /* If kbd_buffer_get_event gave us an EOF, return that. */
3109 if ((STRINGP (Vkeyboard_translate_table
)
3110 && SCHARS (Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
3111 || (VECTORP (Vkeyboard_translate_table
)
3112 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
3113 || (CHAR_TABLE_P (Vkeyboard_translate_table
)
3114 && CHAR_VALID_P (XINT (c
), 0)))
3117 d
= Faref (Vkeyboard_translate_table
, c
);
3118 /* nil in keyboard-translate-table means no translation. */
3124 /* If this event is a mouse click in the menu bar,
3125 return just menu-bar for now. Modify the mouse click event
3126 so we won't do this twice, then queue it up. */
3127 if (EVENT_HAS_PARAMETERS (c
)
3129 && CONSP (EVENT_START (c
))
3130 && CONSP (XCDR (EVENT_START (c
))))
3134 posn
= POSN_POSN (EVENT_START (c
));
3135 /* Handle menu-bar events:
3136 insert the dummy prefix event `menu-bar'. */
3137 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
3139 /* Change menu-bar to (menu-bar) as the event "position". */
3140 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
3143 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
3148 /* Store these characters into recent_keys, the dribble file if any,
3149 and the keyboard macro being defined, if any. */
3151 if (! NILP (also_record
))
3152 record_char (also_record
);
3154 /* Wipe the echo area.
3155 But first, if we are about to use an input method,
3156 save the echo area contents for it to refer to. */
3158 && ! NILP (Vinput_method_function
)
3159 && (unsigned) XINT (c
) >= ' '
3160 && (unsigned) XINT (c
) != 127
3161 && (unsigned) XINT (c
) < 256)
3163 previous_echo_area_message
= Fcurrent_message ();
3164 Vinput_method_previous_message
= previous_echo_area_message
;
3167 /* Now wipe the echo area, except for help events which do their
3168 own stuff with the echo area. */
3170 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3171 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3173 if (!NILP (echo_area_buffer
[0]))
3174 safe_run_hooks (Qecho_area_clear_hook
);
3175 clear_message (1, 0);
3178 reread_for_input_method
:
3180 /* Pass this to the input method, if appropriate. */
3182 && ! NILP (Vinput_method_function
)
3183 /* Don't run the input method within a key sequence,
3184 after the first event of the key sequence. */
3185 && NILP (prev_event
)
3186 && (unsigned) XINT (c
) >= ' '
3187 && (unsigned) XINT (c
) != 127
3188 && (unsigned) XINT (c
) < 256)
3191 int key_count
, key_count_reset
;
3192 struct gcpro gcpro1
;
3193 int count
= SPECPDL_INDEX ();
3195 /* Save the echo status. */
3196 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3197 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3198 Lisp_Object saved_echo_string
= current_kboard
->echo_string
;
3199 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3202 if (before_command_restore_flag
)
3204 this_command_key_count
= before_command_key_count_1
;
3205 if (this_command_key_count
< this_single_command_key_start
)
3206 this_single_command_key_start
= this_command_key_count
;
3207 echo_truncate (before_command_echo_length_1
);
3208 before_command_restore_flag
= 0;
3212 /* Save the this_command_keys status. */
3213 key_count
= this_command_key_count
;
3214 key_count_reset
= this_command_key_count_reset
;
3217 keys
= Fcopy_sequence (this_command_keys
);
3222 /* Clear out this_command_keys. */
3223 this_command_key_count
= 0;
3224 this_command_key_count_reset
= 0;
3226 /* Now wipe the echo area. */
3227 if (!NILP (echo_area_buffer
[0]))
3228 safe_run_hooks (Qecho_area_clear_hook
);
3229 clear_message (1, 0);
3232 /* If we are not reading a key sequence,
3233 never use the echo area. */
3236 specbind (Qinput_method_use_echo_area
, Qt
);
3239 /* Call the input method. */
3240 tem
= call1 (Vinput_method_function
, c
);
3242 tem
= unbind_to (count
, tem
);
3244 /* Restore the saved echoing state
3245 and this_command_keys state. */
3246 this_command_key_count
= key_count
;
3247 this_command_key_count_reset
= key_count_reset
;
3249 this_command_keys
= keys
;
3252 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3253 current_kboard
->echo_string
= saved_echo_string
;
3254 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3255 if (saved_immediate_echo
)
3260 /* The input method can return no events. */
3263 /* Bring back the previous message, if any. */
3264 if (! NILP (previous_echo_area_message
))
3265 message_with_string ("%s", previous_echo_area_message
, 0);
3268 /* It returned one event or more. */
3270 Vunread_post_input_method_events
3271 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3276 /* Display help if not echoing. */
3277 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3279 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3280 Lisp_Object help
, object
, position
, window
, tem
;
3282 tem
= Fcdr (XCDR (c
));
3285 window
= Fcar (tem
);
3287 object
= Fcar (tem
);
3289 position
= Fcar (tem
);
3291 show_help_echo (help
, window
, object
, position
, 0);
3293 /* We stopped being idle for this event; undo that. */
3295 timer_resume_idle ();
3299 if ((! reread
|| this_command_key_count
== 0
3300 || this_command_key_count_reset
)
3304 /* Don't echo mouse motion events. */
3305 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3306 && NILP (Fzerop (Vecho_keystrokes
))
3307 && ! (EVENT_HAS_PARAMETERS (c
)
3308 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3311 if (! NILP (also_record
))
3312 echo_char (also_record
);
3313 /* Once we reread a character, echoing can happen
3314 the next time we pause to read a new one. */
3315 ok_to_echo_at_next_pause
= current_kboard
;
3318 /* Record this character as part of the current key. */
3319 add_command_key (c
);
3320 if (! NILP (also_record
))
3321 add_command_key (also_record
);
3324 last_input_char
= c
;
3327 /* Process the help character specially if enabled */
3328 if (!NILP (Vhelp_form
) && help_char_p (c
))
3331 count
= SPECPDL_INDEX ();
3333 help_form_saved_window_configs
3334 = Fcons (Fcurrent_window_configuration (Qnil
),
3335 help_form_saved_window_configs
);
3336 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3338 tem0
= Feval (Vhelp_form
);
3340 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3345 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3346 if (EVENT_HAS_PARAMETERS (c
)
3347 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3348 XSETCAR (help_form_saved_window_configs
, Qnil
);
3350 while (BUFFERP (c
));
3351 /* Remove the help from the frame */
3352 unbind_to (count
, Qnil
);
3355 if (EQ (c
, make_number (040)))
3359 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3360 while (BUFFERP (c
));
3369 /* Record a key that came from a mouse menu.
3370 Record it for echoing, for this-command-keys, and so on. */
3376 /* Wipe the echo area. */
3377 clear_message (1, 0);
3382 before_command_key_count
= this_command_key_count
;
3383 before_command_echo_length
= echo_length ();
3386 /* Don't echo mouse motion events. */
3387 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3388 && NILP (Fzerop (Vecho_keystrokes
)))
3392 /* Once we reread a character, echoing can happen
3393 the next time we pause to read a new one. */
3394 ok_to_echo_at_next_pause
= 0;
3397 /* Record this character as part of the current key. */
3398 add_command_key (c
);
3400 /* Re-reading in the middle of a command */
3401 last_input_char
= c
;
3405 /* Return 1 if should recognize C as "the help character". */
3413 if (EQ (c
, Vhelp_char
))
3415 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3416 if (EQ (c
, XCAR (tail
)))
3421 /* Record the input event C in various ways. */
3429 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3431 /* To avoid filling recent_keys with help-echo and mouse-movement
3432 events, we filter out repeated help-echo events, only store the
3433 first and last in a series of mouse-movement events, and don't
3434 store repeated help-echo events which are only separated by
3435 mouse-movement events. */
3437 Lisp_Object ev1
, ev2
, ev3
;
3440 if ((ix1
= recent_keys_index
- 1) < 0)
3441 ix1
= NUM_RECENT_KEYS
- 1;
3442 ev1
= AREF (recent_keys
, ix1
);
3444 if ((ix2
= ix1
- 1) < 0)
3445 ix2
= NUM_RECENT_KEYS
- 1;
3446 ev2
= AREF (recent_keys
, ix2
);
3448 if ((ix3
= ix2
- 1) < 0)
3449 ix3
= NUM_RECENT_KEYS
- 1;
3450 ev3
= AREF (recent_keys
, ix3
);
3452 if (EQ (XCAR (c
), Qhelp_echo
))
3454 /* Don't record `help-echo' in recent_keys unless it shows some help
3455 message, and a different help than the previously recorded
3457 Lisp_Object help
, last_help
;
3459 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3460 if (!STRINGP (help
))
3462 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3463 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3465 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3466 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3467 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3469 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3470 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3471 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3472 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3475 else if (EQ (XCAR (c
), Qmouse_movement
))
3477 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3478 So additional mouse movement events replace the last element. */
3479 Lisp_Object last_window
, window
;
3481 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3482 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3483 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3484 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3485 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3487 ASET (recent_keys
, ix1
, c
);
3493 store_kbd_macro_char (c
);
3498 ASET (recent_keys
, recent_keys_index
, c
);
3499 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3500 recent_keys_index
= 0;
3502 else if (recorded
< 0)
3504 /* We need to remove one or two events from recent_keys.
3505 To do this, we simply put nil at those events and move the
3506 recent_keys_index backwards over those events. Usually,
3507 users will never see those nil events, as they will be
3508 overwritten by the command keys entered to see recent_keys
3511 while (recorded
++ < 0 && total_keys
> 0)
3513 if (total_keys
< NUM_RECENT_KEYS
)
3515 if (--recent_keys_index
< 0)
3516 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3517 ASET (recent_keys
, recent_keys_index
, Qnil
);
3521 num_nonmacro_input_events
++;
3523 /* Write c to the dribble file. If c is a lispy event, write
3524 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3525 If you, dear reader, have a better idea, you've got the source. :-) */
3531 if (XUINT (c
) < 0x100)
3532 putc (XINT (c
), dribble
);
3534 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3538 Lisp_Object dribblee
;
3540 /* If it's a structured event, take the event header. */
3541 dribblee
= EVENT_HEAD (c
);
3543 if (SYMBOLP (dribblee
))
3545 putc ('<', dribble
);
3546 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3547 SBYTES (SYMBOL_NAME (dribblee
)),
3549 putc ('>', dribble
);
3562 struct buffer
*old
= current_buffer
;
3563 Fprinc (object
, Qnil
);
3564 set_buffer_internal (XBUFFER (Vstandard_output
));
3565 call0 (intern ("help-mode"));
3566 set_buffer_internal (old
);
3570 /* Copy out or in the info on where C-g should throw to.
3571 This is used when running Lisp code from within get_char,
3572 in case get_char is called recursively.
3573 See read_process_output. */
3579 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3583 restore_getcjmp (temp
)
3586 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3589 /* Low level keyboard/mouse input.
3590 kbd_buffer_store_event places events in kbd_buffer, and
3591 kbd_buffer_get_event retrieves them. */
3593 /* Return true iff there are any events in the queue that read-char
3594 would return. If this returns false, a read-char would block. */
3596 readable_events (flags
)
3599 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3602 /* If the buffer contains only FOCUS_IN_EVENT events, and
3603 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3604 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3606 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3607 #ifdef USE_TOOLKIT_SCROLL_BARS
3608 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3612 struct input_event
*event
;
3614 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3621 #ifdef USE_TOOLKIT_SCROLL_BARS
3622 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3624 event
->kind
== FOCUS_IN_EVENT
)
3625 #ifdef USE_TOOLKIT_SCROLL_BARS
3626 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3627 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3628 && event
->part
== scroll_bar_handle
3629 && event
->modifiers
== 0)
3634 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3637 while (event
!= kbd_store_ptr
);
3643 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3644 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3645 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3650 if (current_kboard
->kbd_queue_has_data
)
3656 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3657 if (kb
->kbd_queue_has_data
)
3663 /* Set this for debugging, to have a way to get out */
3668 event_to_kboard (event
)
3669 struct input_event
*event
;
3672 frame
= event
->frame_or_window
;
3674 frame
= XCAR (frame
);
3675 else if (WINDOWP (frame
))
3676 frame
= WINDOW_FRAME (XWINDOW (frame
));
3678 /* There are still some events that don't set this field.
3679 For now, just ignore the problem.
3680 Also ignore dead frames here. */
3681 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3684 return FRAME_KBOARD (XFRAME (frame
));
3689 Lisp_Object Vthrow_on_input
;
3691 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3694 kbd_buffer_store_event (event
)
3695 register struct input_event
*event
;
3697 kbd_buffer_store_event_hold (event
, 0);
3700 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3702 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3703 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3704 Else, if EVENT is a quit event, store the quit event
3705 in HOLD_QUIT, and return (thus ignoring further events).
3707 This is used in read_avail_input to postpone the processing
3708 of the quit event until all subsequent input events have been
3709 parsed (and discarded).
3713 kbd_buffer_store_event_hold (event
, hold_quit
)
3714 register struct input_event
*event
;
3715 struct input_event
*hold_quit
;
3717 if (event
->kind
== NO_EVENT
)
3720 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3723 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3725 register int c
= event
->code
& 0377;
3727 if (event
->modifiers
& ctrl_modifier
)
3728 c
= make_ctrl_char (c
);
3730 c
|= (event
->modifiers
3731 & (meta_modifier
| alt_modifier
3732 | hyper_modifier
| super_modifier
));
3738 struct input_event
*sp
;
3741 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
3742 kb
!= current_kboard
))
3745 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3746 Fcons (make_number (c
), Qnil
));
3747 kb
->kbd_queue_has_data
= 1;
3748 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3750 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3753 if (event_to_kboard (sp
) == kb
)
3755 sp
->kind
= NO_EVENT
;
3756 sp
->frame_or_window
= Qnil
;
3766 bcopy (event
, (char *) hold_quit
, sizeof (*event
));
3770 /* If this results in a quit_char being returned to Emacs as
3771 input, set Vlast_event_frame properly. If this doesn't
3772 get returned to Emacs as an event, the next event read
3773 will set Vlast_event_frame again, so this is safe to do. */
3777 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3779 focus
= event
->frame_or_window
;
3780 internal_last_event_frame
= focus
;
3781 Vlast_event_frame
= focus
;
3784 last_event_timestamp
= event
->timestamp
;
3785 interrupt_signal (0 /* dummy */);
3789 if (c
&& c
== stop_character
)
3795 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3796 Just ignore the second one. */
3797 else if (event
->kind
== BUFFER_SWITCH_EVENT
3798 && kbd_fetch_ptr
!= kbd_store_ptr
3799 && ((kbd_store_ptr
== kbd_buffer
3800 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3801 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3804 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3805 kbd_store_ptr
= kbd_buffer
;
3807 /* Don't let the very last slot in the buffer become full,
3808 since that would make the two pointers equal,
3809 and that is indistinguishable from an empty buffer.
3810 Discard the event if it would fill the last slot. */
3811 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3813 *kbd_store_ptr
= *event
;
3817 /* If we're inside while-no-input, and this event qualifies
3818 as input, set quit-flag to cause an interrupt. */
3819 if (!NILP (Vthrow_on_input
)
3820 && event
->kind
!= FOCUS_IN_EVENT
3821 && event
->kind
!= HELP_EVENT
3822 && event
->kind
!= DEICONIFY_EVENT
)
3824 Vquit_flag
= Vthrow_on_input
;
3825 /* If we're inside a function that wants immediate quits,
3827 if (immediate_quit
&& NILP (Vinhibit_quit
))
3837 /* Put an input event back in the head of the event queue. */
3840 kbd_buffer_unget_event (event
)
3841 register struct input_event
*event
;
3843 if (kbd_fetch_ptr
== kbd_buffer
)
3844 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3846 /* Don't let the very last slot in the buffer become full, */
3847 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3850 *kbd_fetch_ptr
= *event
;
3855 /* Generate HELP_EVENT input_events in BUFP which has room for
3856 SIZE events. If there's not enough room in BUFP, ignore this
3859 HELP is the help form.
3861 FRAME is the frame on which the help is generated. OBJECT is the
3862 Lisp object where the help was found (a buffer, a string, an
3863 overlay, or nil if neither from a string nor from a buffer. POS is
3864 the position within OBJECT where the help was found.
3866 Value is the number of input_events generated. */
3869 gen_help_event (help
, frame
, window
, object
, pos
)
3870 Lisp_Object help
, frame
, object
, window
;
3873 struct input_event event
;
3877 event
.kind
= HELP_EVENT
;
3878 event
.frame_or_window
= frame
;
3880 event
.x
= WINDOWP (window
) ? window
: frame
;
3883 kbd_buffer_store_event (&event
);
3887 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3890 kbd_buffer_store_help_event (frame
, help
)
3891 Lisp_Object frame
, help
;
3893 struct input_event event
;
3895 event
.kind
= HELP_EVENT
;
3896 event
.frame_or_window
= frame
;
3901 kbd_buffer_store_event (&event
);
3905 /* Discard any mouse events in the event buffer by setting them to
3908 discard_mouse_events ()
3910 struct input_event
*sp
;
3911 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3913 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3916 if (sp
->kind
== MOUSE_CLICK_EVENT
3917 || sp
->kind
== WHEEL_EVENT
3919 || sp
->kind
== W32_SCROLL_BAR_CLICK_EVENT
3921 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3923 sp
->kind
= NO_EVENT
;
3929 /* Return non-zero if there are any real events waiting in the event
3930 buffer, not counting `NO_EVENT's.
3932 If DISCARD is non-zero, discard NO_EVENT events at the front of
3933 the input queue, possibly leaving the input queue empty if there
3934 are no real input events. */
3937 kbd_buffer_events_waiting (discard
)
3940 struct input_event
*sp
;
3942 for (sp
= kbd_fetch_ptr
;
3943 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3946 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3953 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3957 /* Clear input event EVENT. */
3961 struct input_event
*event
;
3963 event
->kind
= NO_EVENT
;
3967 /* Read one event from the event buffer, waiting if necessary.
3968 The value is a Lisp object representing the event.
3969 The value is nil for an event that should be ignored,
3970 or that was handled here.
3971 We always read and discard one event. */
3974 kbd_buffer_get_event (kbp
, used_mouse_menu
, end_time
)
3976 int *used_mouse_menu
;
3977 EMACS_TIME
*end_time
;
3986 *kbp
= current_kboard
;
3990 /* Wait until there is input available. */
3993 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3995 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3996 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4000 /* If the quit flag is set, then read_char will return
4001 quit_char, so that counts as "available input." */
4002 if (!NILP (Vquit_flag
))
4003 quit_throw_to_read_char ();
4005 /* One way or another, wait until input is available; then, if
4006 interrupt handlers have not read it, read it now. */
4009 wait_for_kbd_input ();
4011 /* Note SIGIO has been undef'd if FIONREAD is missing. */
4015 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4017 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4018 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4023 EMACS_TIME duration
;
4024 EMACS_GET_TIME (duration
);
4025 if (EMACS_TIME_GE (duration
, *end_time
))
4026 return Qnil
; /* finished waiting */
4029 EMACS_SUB_TIME (duration
, *end_time
, duration
);
4030 wait_reading_process_output (EMACS_SECS (duration
),
4031 EMACS_USECS (duration
),
4032 -1, 1, Qnil
, NULL
, 0);
4036 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
4038 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
4039 /* Pass 1 for EXPECT since we just waited to have input. */
4040 read_avail_input (1);
4041 #endif /* not VMS */
4044 if (CONSP (Vunread_command_events
))
4047 first
= XCAR (Vunread_command_events
);
4048 Vunread_command_events
= XCDR (Vunread_command_events
);
4049 *kbp
= current_kboard
;
4053 /* At this point, we know that there is a readable event available
4054 somewhere. If the event queue is empty, then there must be a
4055 mouse movement enabled and available. */
4056 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4058 struct input_event
*event
;
4060 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4064 last_event_timestamp
= event
->timestamp
;
4067 *kbp
= event_to_kboard (event
);
4069 *kbp
= current_kboard
; /* Better than returning null ptr? */
4071 *kbp
= &the_only_kboard
;
4076 /* These two kinds of events get special handling
4077 and don't actually appear to the command loop.
4078 We return nil for them. */
4079 if (event
->kind
== SELECTION_REQUEST_EVENT
4080 || event
->kind
== SELECTION_CLEAR_EVENT
)
4083 struct input_event copy
;
4085 /* Remove it from the buffer before processing it,
4086 since otherwise swallow_events will see it
4087 and process it again. */
4089 kbd_fetch_ptr
= event
+ 1;
4090 input_pending
= readable_events (0);
4091 x_handle_selection_event (©
);
4093 /* We're getting selection request events, but we don't have
4099 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4100 else if (event
->kind
== DELETE_WINDOW_EVENT
)
4102 /* Make an event (delete-frame (FRAME)). */
4103 obj
= Fcons (event
->frame_or_window
, Qnil
);
4104 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
4105 kbd_fetch_ptr
= event
+ 1;
4108 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
4109 else if (event
->kind
== ICONIFY_EVENT
)
4111 /* Make an event (iconify-frame (FRAME)). */
4112 obj
= Fcons (event
->frame_or_window
, Qnil
);
4113 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
4114 kbd_fetch_ptr
= event
+ 1;
4116 else if (event
->kind
== DEICONIFY_EVENT
)
4118 /* Make an event (make-frame-visible (FRAME)). */
4119 obj
= Fcons (event
->frame_or_window
, Qnil
);
4120 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
4121 kbd_fetch_ptr
= event
+ 1;
4124 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
4126 /* The value doesn't matter here; only the type is tested. */
4127 XSETBUFFER (obj
, current_buffer
);
4128 kbd_fetch_ptr
= event
+ 1;
4130 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
4131 || defined (USE_GTK)
4132 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4134 kbd_fetch_ptr
= event
+ 1;
4135 input_pending
= readable_events (0);
4136 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4137 x_activate_menubar (XFRAME (event
->frame_or_window
));
4140 #if defined (WINDOWSNT) || defined (MAC_OS)
4141 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4144 /* Make an event (language-change (KEY_SCRIPT)). */
4145 obj
= Fcons (make_number (event
->code
), Qnil
);
4147 /* Make an event (language-change (FRAME CHARSET LCID)). */
4148 obj
= Fcons (event
->frame_or_window
, Qnil
);
4150 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4151 kbd_fetch_ptr
= event
+ 1;
4154 else if (event
->kind
== SAVE_SESSION_EVENT
)
4156 obj
= Fcons (Qsave_session
, Qnil
);
4157 kbd_fetch_ptr
= event
+ 1;
4159 /* Just discard these, by returning nil.
4160 With MULTI_KBOARD, these events are used as placeholders
4161 when we need to randomly delete events from the queue.
4162 (They shouldn't otherwise be found in the buffer,
4163 but on some machines it appears they do show up
4164 even without MULTI_KBOARD.) */
4165 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4166 mouse events during a popup-menu call. */
4167 else if (event
->kind
== NO_EVENT
)
4168 kbd_fetch_ptr
= event
+ 1;
4169 else if (event
->kind
== HELP_EVENT
)
4171 Lisp_Object object
, position
, help
, frame
, window
;
4173 frame
= event
->frame_or_window
;
4174 object
= event
->arg
;
4175 position
= make_number (event
->code
);
4178 clear_event (event
);
4180 kbd_fetch_ptr
= event
+ 1;
4181 if (!WINDOWP (window
))
4183 obj
= Fcons (Qhelp_echo
,
4184 list5 (frame
, help
, window
, object
, position
));
4186 else if (event
->kind
== FOCUS_IN_EVENT
)
4188 /* Notification of a FocusIn event. The frame receiving the
4189 focus is in event->frame_or_window. Generate a
4190 switch-frame event if necessary. */
4191 Lisp_Object frame
, focus
;
4193 frame
= event
->frame_or_window
;
4194 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4198 if (!EQ (frame
, internal_last_event_frame
)
4199 && !EQ (frame
, selected_frame
))
4200 obj
= make_lispy_switch_frame (frame
);
4201 internal_last_event_frame
= frame
;
4202 kbd_fetch_ptr
= event
+ 1;
4206 /* If this event is on a different frame, return a switch-frame this
4207 time, and leave the event in the queue for next time. */
4211 frame
= event
->frame_or_window
;
4213 frame
= XCAR (frame
);
4214 else if (WINDOWP (frame
))
4215 frame
= WINDOW_FRAME (XWINDOW (frame
));
4217 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4221 if (! EQ (frame
, internal_last_event_frame
)
4222 && !EQ (frame
, selected_frame
))
4223 obj
= make_lispy_switch_frame (frame
);
4224 internal_last_event_frame
= frame
;
4226 /* If we didn't decide to make a switch-frame event, go ahead
4227 and build a real event from the queue entry. */
4231 obj
= make_lispy_event (event
);
4233 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4234 || defined (USE_GTK)
4235 /* If this was a menu selection, then set the flag to inhibit
4236 writing to last_nonmenu_event. Don't do this if the event
4237 we're returning is (menu-bar), though; that indicates the
4238 beginning of the menu sequence, and we might as well leave
4239 that as the `event with parameters' for this selection. */
4241 && !EQ (event
->frame_or_window
, event
->arg
)
4242 && (event
->kind
== MENU_BAR_EVENT
4243 || event
->kind
== TOOL_BAR_EVENT
))
4244 *used_mouse_menu
= 1;
4247 /* Wipe out this event, to catch bugs. */
4248 clear_event (event
);
4249 kbd_fetch_ptr
= event
+ 1;
4253 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4254 /* Try generating a mouse motion event. */
4255 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4257 FRAME_PTR f
= some_mouse_moved ();
4258 Lisp_Object bar_window
;
4259 enum scroll_bar_part part
;
4263 *kbp
= current_kboard
;
4264 /* Note that this uses F to determine which display to look at.
4265 If there is no valid info, it does not store anything
4266 so x remains nil. */
4268 (*mouse_position_hook
) (&f
, 0, &bar_window
, &part
, &x
, &y
, &time
);
4272 /* Decide if we should generate a switch-frame event. Don't
4273 generate switch-frame events for motion outside of all Emacs
4279 frame
= FRAME_FOCUS_FRAME (f
);
4281 XSETFRAME (frame
, f
);
4283 if (! EQ (frame
, internal_last_event_frame
)
4284 && !EQ (frame
, selected_frame
))
4285 obj
= make_lispy_switch_frame (frame
);
4286 internal_last_event_frame
= frame
;
4289 /* If we didn't decide to make a switch-frame event, go ahead and
4290 return a mouse-motion event. */
4291 if (!NILP (x
) && NILP (obj
))
4292 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4294 #endif /* HAVE_MOUSE || HAVE GPM */
4296 /* We were promised by the above while loop that there was
4297 something for us to read! */
4300 input_pending
= readable_events (0);
4302 Vlast_event_frame
= internal_last_event_frame
;
4307 /* Process any events that are not user-visible,
4308 then return, without reading any user-visible events. */
4311 swallow_events (do_display
)
4316 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4318 struct input_event
*event
;
4320 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4324 last_event_timestamp
= event
->timestamp
;
4326 /* These two kinds of events get special handling
4327 and don't actually appear to the command loop. */
4328 if (event
->kind
== SELECTION_REQUEST_EVENT
4329 || event
->kind
== SELECTION_CLEAR_EVENT
)
4332 struct input_event copy
;
4334 /* Remove it from the buffer before processing it,
4335 since otherwise swallow_events called recursively could see it
4336 and process it again. */
4338 kbd_fetch_ptr
= event
+ 1;
4339 input_pending
= readable_events (0);
4340 x_handle_selection_event (©
);
4342 /* We're getting selection request events, but we don't have
4351 old_timers_run
= timers_run
;
4352 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4354 if (timers_run
!= old_timers_run
&& do_display
)
4355 redisplay_preserve_echo_area (7);
4358 /* Record the start of when Emacs is idle,
4359 for the sake of running idle-time timers. */
4366 /* If we are already in the idle state, do nothing. */
4367 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4370 EMACS_GET_TIME (timer_idleness_start_time
);
4372 timer_last_idleness_start_time
= timer_idleness_start_time
;
4374 /* Mark all idle-time timers as once again candidates for running. */
4375 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4379 timer
= XCAR (timers
);
4381 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4383 XVECTOR (timer
)->contents
[0] = Qnil
;
4387 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4392 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4395 /* Resume idle timer from last idle start time. */
4398 timer_resume_idle ()
4400 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4403 timer_idleness_start_time
= timer_last_idleness_start_time
;
4406 /* This is only for debugging. */
4407 struct input_event last_timer_event
;
4409 /* Check whether a timer has fired. To prevent larger problems we simply
4410 disregard elements that are not proper timers. Do not make a circular
4411 timer list for the time being.
4413 Returns the number of seconds to wait until the next timer fires. If a
4414 timer is triggering now, return zero seconds.
4415 If no timer is active, return -1 seconds.
4417 If a timer is ripe, we run it, with quitting turned off.
4419 DO_IT_NOW is now ignored. It used to mean that we should
4420 run the timer directly instead of queueing a timer-event.
4421 Now we always run timers directly. */
4424 timer_check (do_it_now
)
4427 EMACS_TIME nexttime
;
4428 EMACS_TIME now
, idleness_now
;
4429 Lisp_Object timers
, idle_timers
, chosen_timer
;
4430 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4432 EMACS_SET_SECS (nexttime
, -1);
4433 EMACS_SET_USECS (nexttime
, -1);
4435 /* Always consider the ordinary timers. */
4436 timers
= Vtimer_list
;
4437 /* Consider the idle timers only if Emacs is idle. */
4438 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4439 idle_timers
= Vtimer_idle_list
;
4442 chosen_timer
= Qnil
;
4443 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4445 if (CONSP (timers
) || CONSP (idle_timers
))
4447 EMACS_GET_TIME (now
);
4448 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4449 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4452 while (CONSP (timers
) || CONSP (idle_timers
))
4454 Lisp_Object
*vector
;
4455 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4456 EMACS_TIME timer_time
, idle_timer_time
;
4457 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4459 /* Skip past invalid timers and timers already handled. */
4462 timer
= XCAR (timers
);
4463 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4465 timers
= XCDR (timers
);
4468 vector
= XVECTOR (timer
)->contents
;
4470 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4471 || !INTEGERP (vector
[3])
4472 || ! NILP (vector
[0]))
4474 timers
= XCDR (timers
);
4478 if (!NILP (idle_timers
))
4480 timer
= XCAR (idle_timers
);
4481 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4483 idle_timers
= XCDR (idle_timers
);
4486 vector
= XVECTOR (timer
)->contents
;
4488 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4489 || !INTEGERP (vector
[3])
4490 || ! NILP (vector
[0]))
4492 idle_timers
= XCDR (idle_timers
);
4497 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4498 based on the next ordinary timer.
4499 TIMER_DIFFERENCE is the distance in time from NOW to when
4500 this timer becomes ripe (negative if it's already ripe). */
4503 timer
= XCAR (timers
);
4504 vector
= XVECTOR (timer
)->contents
;
4505 EMACS_SET_SECS (timer_time
,
4506 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4507 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4508 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4511 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4512 based on the next idle timer. */
4513 if (!NILP (idle_timers
))
4515 idle_timer
= XCAR (idle_timers
);
4516 vector
= XVECTOR (idle_timer
)->contents
;
4517 EMACS_SET_SECS (idle_timer_time
,
4518 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4519 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4520 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4523 /* Decide which timer is the next timer,
4524 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4525 Also step down the list where we found that timer. */
4527 if (! NILP (timers
) && ! NILP (idle_timers
))
4530 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4531 if (EMACS_TIME_NEG_P (temp
))
4533 chosen_timer
= timer
;
4534 timers
= XCDR (timers
);
4535 difference
= timer_difference
;
4539 chosen_timer
= idle_timer
;
4540 idle_timers
= XCDR (idle_timers
);
4541 difference
= idle_timer_difference
;
4544 else if (! NILP (timers
))
4546 chosen_timer
= timer
;
4547 timers
= XCDR (timers
);
4548 difference
= timer_difference
;
4552 chosen_timer
= idle_timer
;
4553 idle_timers
= XCDR (idle_timers
);
4554 difference
= idle_timer_difference
;
4556 vector
= XVECTOR (chosen_timer
)->contents
;
4558 /* If timer is ripe, run it if it hasn't been run. */
4559 if (EMACS_TIME_NEG_P (difference
)
4560 || (EMACS_SECS (difference
) == 0
4561 && EMACS_USECS (difference
) == 0))
4563 if (NILP (vector
[0]))
4565 int was_locked
= single_kboard
;
4566 int count
= SPECPDL_INDEX ();
4567 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4569 /* Mark the timer as triggered to prevent problems if the lisp
4570 code fails to reschedule it right. */
4573 specbind (Qinhibit_quit
, Qt
);
4575 call1 (Qtimer_event_handler
, chosen_timer
);
4576 Vdeactivate_mark
= old_deactivate_mark
;
4578 unbind_to (count
, Qnil
);
4580 /* Resume allowing input from any kboard, if that was true before. */
4582 any_kboard_state ();
4584 /* Since we have handled the event,
4585 we don't need to tell the caller to wake up and do it. */
4589 /* When we encounter a timer that is still waiting,
4590 return the amount of time to wait before it is ripe. */
4597 /* No timers are pending in the future. */
4598 /* Return 0 if we generated an event, and -1 if not. */
4603 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4604 doc
: /* Return the current length of Emacs idleness.
4605 The value is returned as a list of three integers. The first has the
4606 most significant 16 bits of the seconds, while the second has the
4607 least significant 16 bits. The third integer gives the microsecond
4610 The microsecond count is zero on systems that do not provide
4611 resolution finer than a second. */)
4614 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4616 EMACS_TIME now
, idleness_now
;
4618 EMACS_GET_TIME (now
);
4619 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4621 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4622 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4623 make_number (EMACS_USECS (idleness_now
)));
4629 /* Caches for modify_event_symbol. */
4630 static Lisp_Object accent_key_syms
;
4631 static Lisp_Object func_key_syms
;
4632 static Lisp_Object mouse_syms
;
4633 static Lisp_Object wheel_syms
;
4634 static Lisp_Object drag_n_drop_syms
;
4636 /* This is a list of keysym codes for special "accent" characters.
4637 It parallels lispy_accent_keys. */
4639 static int lispy_accent_codes
[] =
4641 #ifdef XK_dead_circumflex
4646 #ifdef XK_dead_grave
4651 #ifdef XK_dead_tilde
4656 #ifdef XK_dead_diaeresis
4661 #ifdef XK_dead_macron
4666 #ifdef XK_dead_degree
4671 #ifdef XK_dead_acute
4676 #ifdef XK_dead_cedilla
4681 #ifdef XK_dead_breve
4686 #ifdef XK_dead_ogonek
4691 #ifdef XK_dead_caron
4696 #ifdef XK_dead_doubleacute
4697 XK_dead_doubleacute
,
4701 #ifdef XK_dead_abovedot
4706 #ifdef XK_dead_abovering
4716 #ifdef XK_dead_belowdot
4721 #ifdef XK_dead_voiced_sound
4722 XK_dead_voiced_sound
,
4726 #ifdef XK_dead_semivoiced_sound
4727 XK_dead_semivoiced_sound
,
4743 /* This is a list of Lisp names for special "accent" characters.
4744 It parallels lispy_accent_codes. */
4746 static char *lispy_accent_keys
[] =
4764 "dead-voiced-sound",
4765 "dead-semivoiced-sound",
4771 #define FUNCTION_KEY_OFFSET 0x0
4773 char *lispy_function_keys
[] =
4777 0, /* VK_LBUTTON 0x01 */
4778 0, /* VK_RBUTTON 0x02 */
4779 "cancel", /* VK_CANCEL 0x03 */
4780 0, /* VK_MBUTTON 0x04 */
4782 0, 0, 0, /* 0x05 .. 0x07 */
4784 "backspace", /* VK_BACK 0x08 */
4785 "tab", /* VK_TAB 0x09 */
4787 0, 0, /* 0x0A .. 0x0B */
4789 "clear", /* VK_CLEAR 0x0C */
4790 "return", /* VK_RETURN 0x0D */
4792 0, 0, /* 0x0E .. 0x0F */
4794 0, /* VK_SHIFT 0x10 */
4795 0, /* VK_CONTROL 0x11 */
4796 0, /* VK_MENU 0x12 */
4797 "pause", /* VK_PAUSE 0x13 */
4798 "capslock", /* VK_CAPITAL 0x14 */
4800 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4802 "escape", /* VK_ESCAPE 0x1B */
4804 0, 0, 0, 0, /* 0x1C .. 0x1F */
4806 0, /* VK_SPACE 0x20 */
4807 "prior", /* VK_PRIOR 0x21 */
4808 "next", /* VK_NEXT 0x22 */
4809 "end", /* VK_END 0x23 */
4810 "home", /* VK_HOME 0x24 */
4811 "left", /* VK_LEFT 0x25 */
4812 "up", /* VK_UP 0x26 */
4813 "right", /* VK_RIGHT 0x27 */
4814 "down", /* VK_DOWN 0x28 */
4815 "select", /* VK_SELECT 0x29 */
4816 "print", /* VK_PRINT 0x2A */
4817 "execute", /* VK_EXECUTE 0x2B */
4818 "snapshot", /* VK_SNAPSHOT 0x2C */
4819 "insert", /* VK_INSERT 0x2D */
4820 "delete", /* VK_DELETE 0x2E */
4821 "help", /* VK_HELP 0x2F */
4823 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4825 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4827 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4829 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4831 0, 0, 0, 0, 0, 0, 0, 0, 0,
4832 0, 0, 0, 0, 0, 0, 0, 0, 0,
4833 0, 0, 0, 0, 0, 0, 0, 0,
4835 "lwindow", /* VK_LWIN 0x5B */
4836 "rwindow", /* VK_RWIN 0x5C */
4837 "apps", /* VK_APPS 0x5D */
4839 0, 0, /* 0x5E .. 0x5F */
4841 "kp-0", /* VK_NUMPAD0 0x60 */
4842 "kp-1", /* VK_NUMPAD1 0x61 */
4843 "kp-2", /* VK_NUMPAD2 0x62 */
4844 "kp-3", /* VK_NUMPAD3 0x63 */
4845 "kp-4", /* VK_NUMPAD4 0x64 */
4846 "kp-5", /* VK_NUMPAD5 0x65 */
4847 "kp-6", /* VK_NUMPAD6 0x66 */
4848 "kp-7", /* VK_NUMPAD7 0x67 */
4849 "kp-8", /* VK_NUMPAD8 0x68 */
4850 "kp-9", /* VK_NUMPAD9 0x69 */
4851 "kp-multiply", /* VK_MULTIPLY 0x6A */
4852 "kp-add", /* VK_ADD 0x6B */
4853 "kp-separator", /* VK_SEPARATOR 0x6C */
4854 "kp-subtract", /* VK_SUBTRACT 0x6D */
4855 "kp-decimal", /* VK_DECIMAL 0x6E */
4856 "kp-divide", /* VK_DIVIDE 0x6F */
4857 "f1", /* VK_F1 0x70 */
4858 "f2", /* VK_F2 0x71 */
4859 "f3", /* VK_F3 0x72 */
4860 "f4", /* VK_F4 0x73 */
4861 "f5", /* VK_F5 0x74 */
4862 "f6", /* VK_F6 0x75 */
4863 "f7", /* VK_F7 0x76 */
4864 "f8", /* VK_F8 0x77 */
4865 "f9", /* VK_F9 0x78 */
4866 "f10", /* VK_F10 0x79 */
4867 "f11", /* VK_F11 0x7A */
4868 "f12", /* VK_F12 0x7B */
4869 "f13", /* VK_F13 0x7C */
4870 "f14", /* VK_F14 0x7D */
4871 "f15", /* VK_F15 0x7E */
4872 "f16", /* VK_F16 0x7F */
4873 "f17", /* VK_F17 0x80 */
4874 "f18", /* VK_F18 0x81 */
4875 "f19", /* VK_F19 0x82 */
4876 "f20", /* VK_F20 0x83 */
4877 "f21", /* VK_F21 0x84 */
4878 "f22", /* VK_F22 0x85 */
4879 "f23", /* VK_F23 0x86 */
4880 "f24", /* VK_F24 0x87 */
4882 0, 0, 0, 0, /* 0x88 .. 0x8B */
4883 0, 0, 0, 0, /* 0x8C .. 0x8F */
4885 "kp-numlock", /* VK_NUMLOCK 0x90 */
4886 "scroll", /* VK_SCROLL 0x91 */
4888 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4889 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4890 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4891 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4892 "kp-end", /* VK_NUMPAD_END 0x96 */
4893 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4894 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4895 "kp-up", /* VK_NUMPAD_UP 0x99 */
4896 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4897 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4898 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4899 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4901 0, 0, /* 0x9E .. 0x9F */
4904 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4905 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4906 * No other API or message will distinguish left and right keys this way.
4910 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4911 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4912 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4913 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4914 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4920 "attn", /* VK_ATTN 0xF6 */
4921 "crsel", /* VK_CRSEL 0xF7 */
4922 "exsel", /* VK_EXSEL 0xF8 */
4923 "ereof", /* VK_EREOF 0xF9 */
4924 "play", /* VK_PLAY 0xFA */
4925 "zoom", /* VK_ZOOM 0xFB */
4926 "noname", /* VK_NONAME 0xFC */
4927 "pa1", /* VK_PA1 0xFD */
4928 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4932 #else /* not HAVE_NTGUI */
4934 /* This should be dealt with in XTread_socket now, and that doesn't
4935 depend on the client system having the Kana syms defined. See also
4936 the XK_kana_A case below. */
4939 static char *lispy_kana_keys
[] =
4941 /* X Keysym value */
4942 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4943 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4944 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4945 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4946 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4947 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4948 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4949 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4950 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4951 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4952 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4953 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4954 "kana-i", "kana-u", "kana-e", "kana-o",
4955 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4956 "prolongedsound", "kana-A", "kana-I", "kana-U",
4957 "kana-E", "kana-O", "kana-KA", "kana-KI",
4958 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4959 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4960 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4961 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4962 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4963 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4964 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4965 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4966 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4967 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4968 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4969 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4971 #endif /* XK_kana_A */
4974 #define FUNCTION_KEY_OFFSET 0xff00
4976 /* You'll notice that this table is arranged to be conveniently
4977 indexed by X Windows keysym values. */
4978 static char *lispy_function_keys
[] =
4980 /* X Keysym value */
4982 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4983 "backspace", "tab", "linefeed", "clear",
4985 0, 0, 0, "pause", /* 0xff10...1f */
4986 0, 0, 0, 0, 0, 0, 0, "escape",
4988 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4989 "romaji", "hiragana", "katakana", "hiragana-katakana",
4990 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4991 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4992 "eisu-toggle", /* 0xff30...3f */
4993 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4994 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4996 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4997 "down", "prior", "next", "end",
4998 "begin", 0, 0, 0, 0, 0, 0, 0,
4999 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5010 "break", /* 0xff6b */
5013 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5014 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5015 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5016 0, 0, 0, 0, 0, 0, 0, 0,
5017 "kp-tab", /* 0xff89 */
5019 "kp-enter", /* 0xff8d */
5021 "kp-f1", /* 0xff91 */
5025 "kp-home", /* 0xff95 */
5030 "kp-prior", /* kp-page-up */
5031 "kp-next", /* kp-page-down */
5037 0, 0, 0, 0, 0, 0, 0, 0, 0,
5038 "kp-multiply", /* 0xffaa */
5043 "kp-divide", /* 0xffaf */
5044 "kp-0", /* 0xffb0 */
5045 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5048 "kp-equal", /* 0xffbd */
5049 "f1", /* 0xffbe */ /* IsFunctionKey */
5051 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5052 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5053 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5054 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5055 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5056 0, 0, 0, 0, 0, 0, 0, 0,
5057 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5058 0, 0, 0, 0, 0, 0, 0, "delete"
5061 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5062 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5064 static char *iso_lispy_function_keys
[] =
5066 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5067 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5068 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5069 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5070 "iso-lefttab", /* 0xfe20 */
5071 "iso-move-line-up", "iso-move-line-down",
5072 "iso-partial-line-up", "iso-partial-line-down",
5073 "iso-partial-space-left", "iso-partial-space-right",
5074 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5075 "iso-release-margin-left", "iso-release-margin-right",
5076 "iso-release-both-margins",
5077 "iso-fast-cursor-left", "iso-fast-cursor-right",
5078 "iso-fast-cursor-up", "iso-fast-cursor-down",
5079 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5080 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5083 #endif /* not HAVE_NTGUI */
5085 Lisp_Object Vlispy_mouse_stem
;
5087 static char *lispy_wheel_names
[] =
5089 "wheel-up", "wheel-down"
5092 /* drag-n-drop events are generated when a set of selected files are
5093 dragged from another application and dropped onto an Emacs window. */
5094 static char *lispy_drag_n_drop_names
[] =
5099 /* Scroll bar parts. */
5100 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5101 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5102 Lisp_Object Qtop
, Qratio
;
5104 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5105 Lisp_Object
*scroll_bar_parts
[] = {
5106 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5107 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5110 /* A vector, indexed by button number, giving the down-going location
5111 of currently depressed buttons, both scroll bar and non-scroll bar.
5113 The elements have the form
5114 (BUTTON-NUMBER MODIFIER-MASK . REST)
5115 where REST is the cdr of a position as it would be reported in the event.
5117 The make_lispy_event function stores positions here to tell the
5118 difference between click and drag events, and to store the starting
5119 location to be included in drag events. */
5121 static Lisp_Object button_down_location
;
5123 /* Information about the most recent up-going button event: Which
5124 button, what location, and what time. */
5126 static int last_mouse_button
;
5127 static int last_mouse_x
;
5128 static int last_mouse_y
;
5129 static unsigned long button_down_time
;
5131 /* The maximum time between clicks to make a double-click, or Qnil to
5132 disable double-click detection, or Qt for no time limit. */
5134 Lisp_Object Vdouble_click_time
;
5136 /* Maximum number of pixels the mouse may be moved between clicks
5137 to make a double-click. */
5139 EMACS_INT double_click_fuzz
;
5141 /* The number of clicks in this multiple-click. */
5143 int double_click_count
;
5145 /* Return position of a mouse click or wheel event */
5148 make_lispy_position (f
, x
, y
, time
)
5154 enum window_part part
;
5155 Lisp_Object posn
= Qnil
;
5156 Lisp_Object extra_info
= Qnil
;
5159 /* Set `window' to the window under frame pixel coordinates (x,y) */
5161 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5162 &part
, &wx
, &wy
, 0);
5166 if (WINDOWP (window
))
5168 /* It's a click in window window at frame coordinates (x,y) */
5169 struct window
*w
= XWINDOW (window
);
5170 Lisp_Object string_info
= Qnil
;
5171 int textpos
= -1, rx
= -1, ry
= -1;
5172 int dx
= -1, dy
= -1;
5173 int width
= -1, height
= -1;
5174 Lisp_Object object
= Qnil
;
5176 /* Set event coordinates to window-relative coordinates
5177 for constructing the Lisp event below. */
5181 if (part
== ON_TEXT
)
5183 wx
+= WINDOW_LEFT_MARGIN_WIDTH (w
);
5185 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5187 /* Mode line or header line. Look for a string under
5188 the mouse that may have a `local-map' property. */
5192 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5194 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5195 &object
, &dx
, &dy
, &width
, &height
);
5196 if (STRINGP (string
))
5197 string_info
= Fcons (string
, make_number (charpos
));
5198 if (w
== XWINDOW (selected_window
))
5201 textpos
= XMARKER (w
->pointm
)->charpos
;
5203 else if (part
== ON_VERTICAL_BORDER
)
5205 posn
= Qvertical_line
;
5210 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5215 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5217 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5218 &object
, &dx
, &dy
, &width
, &height
);
5219 if (STRINGP (string
))
5220 string_info
= Fcons (string
, make_number (charpos
));
5221 if (part
== ON_LEFT_MARGIN
)
5224 wx
= window_box_right_offset (w
, TEXT_AREA
) - 1;
5226 else if (part
== ON_LEFT_FRINGE
)
5228 posn
= Qleft_fringe
;
5231 wx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5233 : window_box_width (w
, LEFT_MARGIN_AREA
));
5236 else if (part
== ON_RIGHT_FRINGE
)
5238 posn
= Qright_fringe
;
5241 wx
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5242 + window_box_width (w
, TEXT_AREA
)
5243 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5244 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5250 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5251 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5256 Lisp_Object string2
, object2
= Qnil
;
5257 struct display_pos p
;
5259 int width2
, height2
;
5260 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5261 &object2
, &dx2
, &dy2
,
5263 textpos
= CHARPOS (p
.pos
);
5264 if (rx
< 0) rx
= wx
;
5265 if (ry
< 0) ry
= wy
;
5266 if (dx
< 0) dx
= dx2
;
5267 if (dy
< 0) dy
= dy2
;
5268 if (width
< 0) width
= width2
;
5269 if (height
< 0) height
= height2
;
5273 posn
= make_number (textpos
);
5274 if (STRINGP (string2
))
5275 string_info
= Fcons (string2
,
5276 make_number (CHARPOS (p
.string_pos
)));
5282 #ifdef HAVE_WINDOW_SYSTEM
5283 if (IMAGEP (object
))
5285 Lisp_Object image_map
, hotspot
;
5286 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5288 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5290 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5291 posn
= XCAR (hotspot
);
5296 extra_info
= Fcons (object
,
5297 Fcons (Fcons (make_number (dx
),
5299 Fcons (Fcons (make_number (width
),
5300 make_number (height
)),
5304 extra_info
= Fcons (string_info
,
5305 Fcons (make_number (textpos
),
5306 Fcons (Fcons (make_number (rx
),
5312 XSETFRAME (window
, f
);
5317 XSETFASTINT (*x
, 0);
5318 XSETFASTINT (*y
, 0);
5321 return Fcons (window
,
5323 Fcons (Fcons (*x
, *y
),
5324 Fcons (make_number (time
),
5328 /* Given a struct input_event, build the lisp event which represents
5329 it. If EVENT is 0, build a mouse movement event from the mouse
5330 movement buffer, which should have a movement event in it.
5332 Note that events must be passed to this function in the order they
5333 are received; this function stores the location of button presses
5334 in order to build drag events when the button is released. */
5337 make_lispy_event (event
)
5338 struct input_event
*event
;
5342 switch (SWITCH_ENUM_CAST (event
->kind
))
5344 /* A simple keystroke. */
5345 case ASCII_KEYSTROKE_EVENT
:
5347 Lisp_Object lispy_c
;
5348 int c
= event
->code
& 0377;
5349 /* Turn ASCII characters into control characters
5351 if (event
->modifiers
& ctrl_modifier
)
5352 c
= make_ctrl_char (c
);
5354 /* Add in the other modifier bits. We took care of ctrl_modifier
5355 just above, and the shift key was taken care of by the X code,
5356 and applied to control characters by make_ctrl_char. */
5357 c
|= (event
->modifiers
5358 & (meta_modifier
| alt_modifier
5359 | hyper_modifier
| super_modifier
));
5360 /* Distinguish Shift-SPC from SPC. */
5361 if ((event
->code
& 0377) == 040
5362 && event
->modifiers
& shift_modifier
)
5363 c
|= shift_modifier
;
5364 button_down_time
= 0;
5365 XSETFASTINT (lispy_c
, c
);
5369 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5371 Lisp_Object lispy_c
;
5372 int c
= event
->code
;
5374 /* Add in the other modifier bits. We took care of ctrl_modifier
5375 just above, and the shift key was taken care of by the X code,
5376 and applied to control characters by make_ctrl_char. */
5377 c
|= (event
->modifiers
5378 & (meta_modifier
| alt_modifier
5379 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5380 /* What about the `shift' modifier ? */
5381 button_down_time
= 0;
5382 XSETFASTINT (lispy_c
, c
);
5386 /* A function key. The symbol may need to have modifier prefixes
5388 case NON_ASCII_KEYSTROKE_EVENT
:
5389 button_down_time
= 0;
5391 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5392 if (event
->code
== lispy_accent_codes
[i
])
5393 return modify_event_symbol (i
,
5395 Qfunction_key
, Qnil
,
5396 lispy_accent_keys
, &accent_key_syms
,
5397 (sizeof (lispy_accent_keys
)
5398 / sizeof (lispy_accent_keys
[0])));
5402 if (event
->code
>= 0x400 && event
->code
< 0x500)
5403 return modify_event_symbol (event
->code
- 0x400,
5404 event
->modifiers
& ~shift_modifier
,
5405 Qfunction_key
, Qnil
,
5406 lispy_kana_keys
, &func_key_syms
,
5407 (sizeof (lispy_kana_keys
)
5408 / sizeof (lispy_kana_keys
[0])));
5409 #endif /* XK_kana_A */
5412 #ifdef ISO_FUNCTION_KEY_OFFSET
5413 if (event
->code
< FUNCTION_KEY_OFFSET
5414 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5415 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5417 Qfunction_key
, Qnil
,
5418 iso_lispy_function_keys
, &func_key_syms
,
5419 (sizeof (iso_lispy_function_keys
)
5420 / sizeof (iso_lispy_function_keys
[0])));
5423 /* Handle system-specific or unknown keysyms. */
5424 if (event
->code
& (1 << 28)
5425 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5426 || (event
->code
- FUNCTION_KEY_OFFSET
5427 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5428 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5430 /* We need to use an alist rather than a vector as the cache
5431 since we can't make a vector long enuf. */
5432 if (NILP (current_kboard
->system_key_syms
))
5433 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5434 return modify_event_symbol (event
->code
,
5437 current_kboard
->Vsystem_key_alist
,
5438 0, ¤t_kboard
->system_key_syms
,
5442 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5444 Qfunction_key
, Qnil
,
5445 lispy_function_keys
, &func_key_syms
,
5446 (sizeof (lispy_function_keys
)
5447 / sizeof (lispy_function_keys
[0])));
5450 /* A mouse click. Figure out where it is, decide whether it's
5451 a press, click or drag, and build the appropriate structure. */
5452 case MOUSE_CLICK_EVENT
:
5453 #ifndef USE_TOOLKIT_SCROLL_BARS
5454 case SCROLL_BAR_CLICK_EVENT
:
5457 int button
= event
->code
;
5459 Lisp_Object position
;
5460 Lisp_Object
*start_pos_ptr
;
5461 Lisp_Object start_pos
;
5465 /* Build the position as appropriate for this mouse click. */
5466 if (event
->kind
== MOUSE_CLICK_EVENT
)
5468 struct frame
*f
= XFRAME (event
->frame_or_window
);
5469 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5473 /* Ignore mouse events that were made on frame that
5474 have been deleted. */
5475 if (! FRAME_LIVE_P (f
))
5478 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5479 /* EVENT->x and EVENT->y are frame-relative pixel
5480 coordinates at this place. Under old redisplay, COLUMN
5481 and ROW are set to frame relative glyph coordinates
5482 which are then used to determine whether this click is
5483 in a menu (non-toolkit version). */
5484 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5485 &column
, &row
, NULL
, 1);
5487 /* In the non-toolkit version, clicks on the menu bar
5488 are ordinary button events in the event buffer.
5489 Distinguish them, and invoke the menu.
5491 (In the toolkit version, the toolkit handles the menu bar
5492 and Emacs doesn't know about it until after the user
5493 makes a selection.) */
5494 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5495 && (event
->modifiers
& down_modifier
))
5497 Lisp_Object items
, item
;
5502 /* Activate the menu bar on the down event. If the
5503 up event comes in before the menu code can deal with it,
5505 if (! (event
->modifiers
& down_modifier
))
5509 /* Find the menu bar item under `column'. */
5511 items
= FRAME_MENU_BAR_ITEMS (f
);
5512 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5514 Lisp_Object pos
, string
;
5515 string
= AREF (items
, i
+ 1);
5516 pos
= AREF (items
, i
+ 3);
5519 if (column
>= XINT (pos
)
5520 && column
< XINT (pos
) + SCHARS (string
))
5522 item
= AREF (items
, i
);
5527 /* ELisp manual 2.4b says (x y) are window relative but
5528 code says they are frame-relative. */
5530 = Fcons (event
->frame_or_window
,
5532 Fcons (Fcons (event
->x
, event
->y
),
5533 Fcons (make_number (event
->timestamp
),
5536 return Fcons (item
, Fcons (position
, Qnil
));
5538 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5540 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5543 #ifndef USE_TOOLKIT_SCROLL_BARS
5546 /* It's a scrollbar click. */
5548 Lisp_Object portion_whole
;
5551 window
= event
->frame_or_window
;
5552 portion_whole
= Fcons (event
->x
, event
->y
);
5553 part
= *scroll_bar_parts
[(int) event
->part
];
5557 Fcons (Qvertical_scroll_bar
,
5558 Fcons (portion_whole
,
5559 Fcons (make_number (event
->timestamp
),
5560 Fcons (part
, Qnil
)))));
5562 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5564 if (button
>= ASIZE (button_down_location
))
5566 button_down_location
= larger_vector (button_down_location
,
5568 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5571 start_pos_ptr
= &AREF (button_down_location
, button
);
5572 start_pos
= *start_pos_ptr
;
5573 *start_pos_ptr
= Qnil
;
5576 /* On window-system frames, use the value of
5577 double-click-fuzz as is. On other frames, interpret it
5578 as a multiple of 1/8 characters. */
5582 if (WINDOWP (event
->frame_or_window
))
5583 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5584 else if (FRAMEP (event
->frame_or_window
))
5585 f
= XFRAME (event
->frame_or_window
);
5589 if (FRAME_WINDOW_P (f
))
5590 fuzz
= double_click_fuzz
;
5592 fuzz
= double_click_fuzz
/ 8;
5594 is_double
= (button
== last_mouse_button
5595 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5596 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5597 && button_down_time
!= 0
5598 && (EQ (Vdouble_click_time
, Qt
)
5599 || (INTEGERP (Vdouble_click_time
)
5600 && ((int)(event
->timestamp
- button_down_time
)
5601 < XINT (Vdouble_click_time
)))));
5604 last_mouse_button
= button
;
5605 last_mouse_x
= XINT (event
->x
);
5606 last_mouse_y
= XINT (event
->y
);
5608 /* If this is a button press, squirrel away the location, so
5609 we can decide later whether it was a click or a drag. */
5610 if (event
->modifiers
& down_modifier
)
5614 double_click_count
++;
5615 event
->modifiers
|= ((double_click_count
> 2)
5620 double_click_count
= 1;
5621 button_down_time
= event
->timestamp
;
5622 *start_pos_ptr
= Fcopy_alist (position
);
5623 ignore_mouse_drag_p
= 0;
5626 /* Now we're releasing a button - check the co-ordinates to
5627 see if this was a click or a drag. */
5628 else if (event
->modifiers
& up_modifier
)
5630 /* If we did not see a down before this up, ignore the up.
5631 Probably this happened because the down event chose a
5632 menu item. It would be an annoyance to treat the
5633 release of the button that chose the menu item as a
5636 if (!CONSP (start_pos
))
5639 event
->modifiers
&= ~up_modifier
;
5640 #if 0 /* Formerly we treated an up with no down as a click event. */
5641 if (!CONSP (start_pos
))
5642 event
->modifiers
|= click_modifier
;
5647 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5649 /* The third element of every position
5650 should be the (x,y) pair. */
5651 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5653 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5655 xdiff
= XINT (event
->x
) - XINT (XCAR (down
));
5656 ydiff
= XINT (event
->y
) - XINT (XCDR (down
));
5659 if (ignore_mouse_drag_p
)
5661 event
->modifiers
|= click_modifier
;
5662 ignore_mouse_drag_p
= 0;
5664 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5665 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5666 /* Maybe the mouse has moved a lot, caused scrolling, and
5667 eventually ended up at the same screen position (but
5668 not buffer position) in which case it is a drag, not
5670 /* FIXME: OTOH if the buffer position has changed
5671 because of a timer or process filter rather than
5672 because of mouse movement, it should be considered as
5673 a click. But mouse-drag-region completely ignores
5674 this case and it hasn't caused any real problem, so
5675 it's probably OK to ignore it as well. */
5676 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5677 /* Mouse hasn't moved (much). */
5678 event
->modifiers
|= click_modifier
;
5681 button_down_time
= 0;
5682 event
->modifiers
|= drag_modifier
;
5685 /* Don't check is_double; treat this as multiple
5686 if the down-event was multiple. */
5687 if (double_click_count
> 1)
5688 event
->modifiers
|= ((double_click_count
> 2)
5694 /* Every mouse event should either have the down_modifier or
5695 the up_modifier set. */
5699 /* Get the symbol we should use for the mouse click. */
5702 head
= modify_event_symbol (button
,
5704 Qmouse_click
, Vlispy_mouse_stem
,
5707 XVECTOR (mouse_syms
)->size
);
5708 if (event
->modifiers
& drag_modifier
)
5713 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5716 Fcons (make_number (double_click_count
),
5727 Lisp_Object position
;
5730 /* Build the position as appropriate for this mouse click. */
5731 struct frame
*f
= XFRAME (event
->frame_or_window
);
5733 /* Ignore wheel events that were made on frame that have been
5735 if (! FRAME_LIVE_P (f
))
5738 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5741 /* Set double or triple modifiers to indicate the wheel speed. */
5743 /* On window-system frames, use the value of
5744 double-click-fuzz as is. On other frames, interpret it
5745 as a multiple of 1/8 characters. */
5750 if (WINDOWP (event
->frame_or_window
))
5751 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5752 else if (FRAMEP (event
->frame_or_window
))
5753 f
= XFRAME (event
->frame_or_window
);
5757 if (FRAME_WINDOW_P (f
))
5758 fuzz
= double_click_fuzz
;
5760 fuzz
= double_click_fuzz
/ 8;
5762 is_double
= (last_mouse_button
< 0
5763 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5764 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5765 && button_down_time
!= 0
5766 && (EQ (Vdouble_click_time
, Qt
)
5767 || (INTEGERP (Vdouble_click_time
)
5768 && ((int)(event
->timestamp
- button_down_time
)
5769 < XINT (Vdouble_click_time
)))));
5772 double_click_count
++;
5773 event
->modifiers
|= ((double_click_count
> 2)
5779 double_click_count
= 1;
5780 event
->modifiers
|= click_modifier
;
5783 button_down_time
= event
->timestamp
;
5784 /* Use a negative value to distinguish wheel from mouse button. */
5785 last_mouse_button
= -1;
5786 last_mouse_x
= XINT (event
->x
);
5787 last_mouse_y
= XINT (event
->y
);
5793 if (event
->modifiers
& up_modifier
)
5795 /* Emit a wheel-up event. */
5796 event
->modifiers
&= ~up_modifier
;
5799 else if (event
->modifiers
& down_modifier
)
5801 /* Emit a wheel-down event. */
5802 event
->modifiers
&= ~down_modifier
;
5806 /* Every wheel event should either have the down_modifier or
5807 the up_modifier set. */
5810 /* Get the symbol we should use for the wheel event. */
5811 head
= modify_event_symbol (symbol_num
,
5817 ASIZE (wheel_syms
));
5820 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5823 Fcons (make_number (double_click_count
),
5832 #ifdef USE_TOOLKIT_SCROLL_BARS
5834 /* We don't have down and up events if using toolkit scroll bars,
5835 so make this always a click event. Store in the `part' of
5836 the Lisp event a symbol which maps to the following actions:
5838 `above_handle' page up
5839 `below_handle' page down
5843 `bottom' bottom of buffer
5844 `handle' thumb has been dragged.
5845 `end-scroll' end of interaction with scroll bar
5847 The incoming input_event contains in its `part' member an
5848 index of type `enum scroll_bar_part' which we can use as an
5849 index in scroll_bar_parts to get the appropriate symbol. */
5851 case SCROLL_BAR_CLICK_EVENT
:
5853 Lisp_Object position
, head
, window
, portion_whole
, part
;
5855 window
= event
->frame_or_window
;
5856 portion_whole
= Fcons (event
->x
, event
->y
);
5857 part
= *scroll_bar_parts
[(int) event
->part
];
5861 Fcons (Qvertical_scroll_bar
,
5862 Fcons (portion_whole
,
5863 Fcons (make_number (event
->timestamp
),
5864 Fcons (part
, Qnil
)))));
5866 /* Always treat scroll bar events as clicks. */
5867 event
->modifiers
|= click_modifier
;
5868 event
->modifiers
&= ~up_modifier
;
5870 if (event
->code
>= ASIZE (mouse_syms
))
5871 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5873 /* Get the symbol we should use for the mouse click. */
5874 head
= modify_event_symbol (event
->code
,
5879 XVECTOR (mouse_syms
)->size
);
5880 return Fcons (head
, Fcons (position
, Qnil
));
5883 #endif /* USE_TOOLKIT_SCROLL_BARS */
5886 case W32_SCROLL_BAR_CLICK_EVENT
:
5888 int button
= event
->code
;
5890 Lisp_Object position
;
5891 Lisp_Object
*start_pos_ptr
;
5892 Lisp_Object start_pos
;
5896 Lisp_Object portion_whole
;
5899 window
= event
->frame_or_window
;
5900 portion_whole
= Fcons (event
->x
, event
->y
);
5901 part
= *scroll_bar_parts
[(int) event
->part
];
5905 Fcons (Qvertical_scroll_bar
,
5906 Fcons (portion_whole
,
5907 Fcons (make_number (event
->timestamp
),
5908 Fcons (part
, Qnil
)))));
5911 /* Always treat W32 scroll bar events as clicks. */
5912 event
->modifiers
|= click_modifier
;
5915 /* Get the symbol we should use for the mouse click. */
5918 head
= modify_event_symbol (button
,
5923 XVECTOR (mouse_syms
)->size
);
5929 #endif /* WINDOWSNT */
5931 case DRAG_N_DROP_EVENT
:
5934 Lisp_Object head
, position
;
5937 f
= XFRAME (event
->frame_or_window
);
5940 /* Ignore mouse events that were made on frames that
5941 have been deleted. */
5942 if (! FRAME_LIVE_P (f
))
5945 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5948 head
= modify_event_symbol (0, event
->modifiers
,
5950 lispy_drag_n_drop_names
,
5951 &drag_n_drop_syms
, 1);
5957 #endif /* HAVE_MOUSE */
5959 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
5960 || defined (USE_GTK)
5961 case MENU_BAR_EVENT
:
5962 if (EQ (event
->arg
, event
->frame_or_window
))
5963 /* This is the prefix key. We translate this to
5964 `(menu_bar)' because the code in keyboard.c for menu
5965 events, which we use, relies on this. */
5966 return Fcons (Qmenu_bar
, Qnil
);
5970 case SELECT_WINDOW_EVENT
:
5971 /* Make an event (select-window (WINDOW)). */
5972 return Fcons (Qselect_window
,
5973 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5976 case TOOL_BAR_EVENT
:
5977 if (EQ (event
->arg
, event
->frame_or_window
))
5978 /* This is the prefix key. We translate this to
5979 `(tool_bar)' because the code in keyboard.c for tool bar
5980 events, which we use, relies on this. */
5981 return Fcons (Qtool_bar
, Qnil
);
5982 else if (SYMBOLP (event
->arg
))
5983 return apply_modifiers (event
->modifiers
, event
->arg
);
5986 case USER_SIGNAL_EVENT
:
5987 /* A user signal. */
5989 char *name
= find_user_signal_name (event
->code
);
5992 return intern (name
);
5995 case SAVE_SESSION_EVENT
:
5996 return Qsave_session
;
5999 case MAC_APPLE_EVENT
:
6001 Lisp_Object spec
[2];
6005 return Fcons (Qmac_apple_event
,
6006 Fcons (Fvector (2, spec
),
6007 Fcons (event
->arg
, Qnil
)));
6012 case GPM_CLICK_EVENT
:
6014 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
6015 Lisp_Object head
, position
;
6016 Lisp_Object
*start_pos_ptr
;
6017 Lisp_Object start_pos
;
6018 int button
= event
->code
;
6020 if (button
>= ASIZE (button_down_location
))
6022 button_down_location
= larger_vector (button_down_location
,
6024 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
6027 start_pos_ptr
= &AREF (button_down_location
, button
);
6028 start_pos
= *start_pos_ptr
;
6030 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6033 if (event
->modifiers
& down_modifier
)
6034 *start_pos_ptr
= Fcopy_alist (position
);
6035 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
6037 if (!CONSP (start_pos
))
6039 event
->modifiers
&= ~up_modifier
;
6042 head
= modify_event_symbol (button
,
6044 Qmouse_click
, Vlispy_mouse_stem
,
6047 XVECTOR (mouse_syms
)->size
);
6049 if (event
->modifiers
& drag_modifier
)
6054 else if (event
->modifiers
& double_modifier
)
6057 Fcons (make_number (2),
6059 else if (event
->modifiers
& triple_modifier
)
6062 Fcons (make_number (3),
6069 #endif /* HAVE_GPM */
6071 /* The 'kind' field of the event is something we don't recognize. */
6077 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6080 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
6082 Lisp_Object bar_window
;
6083 enum scroll_bar_part part
;
6087 /* Is it a scroll bar movement? */
6088 if (frame
&& ! NILP (bar_window
))
6090 Lisp_Object part_sym
;
6092 part_sym
= *scroll_bar_parts
[(int) part
];
6093 return Fcons (Qscroll_bar_movement
,
6094 (Fcons (Fcons (bar_window
,
6095 Fcons (Qvertical_scroll_bar
,
6096 Fcons (Fcons (x
, y
),
6097 Fcons (make_number (time
),
6103 /* Or is it an ordinary mouse movement? */
6106 Lisp_Object position
;
6108 position
= make_lispy_position (frame
, &x
, &y
, time
);
6110 return Fcons (Qmouse_movement
,
6116 #endif /* HAVE_MOUSE || HAVE GPM */
6118 /* Construct a switch frame event. */
6120 make_lispy_switch_frame (frame
)
6123 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6126 /* Manipulating modifiers. */
6128 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6130 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6131 SYMBOL's name of the end of the modifiers; the string from this
6132 position is the unmodified symbol name.
6134 This doesn't use any caches. */
6137 parse_modifiers_uncached (symbol
, modifier_end
)
6145 CHECK_SYMBOL (symbol
);
6148 name
= SYMBOL_NAME (symbol
);
6150 for (i
= 0; i
+2 <= SBYTES (name
); )
6152 int this_mod_end
= 0;
6155 /* See if the name continues with a modifier word.
6156 Check that the word appears, but don't check what follows it.
6157 Set this_mod and this_mod_end to record what we find. */
6159 switch (SREF (name
, i
))
6161 #define SINGLE_LETTER_MOD(BIT) \
6162 (this_mod_end = i + 1, this_mod = BIT)
6165 SINGLE_LETTER_MOD (alt_modifier
);
6169 SINGLE_LETTER_MOD (ctrl_modifier
);
6173 SINGLE_LETTER_MOD (hyper_modifier
);
6177 SINGLE_LETTER_MOD (meta_modifier
);
6181 SINGLE_LETTER_MOD (shift_modifier
);
6185 SINGLE_LETTER_MOD (super_modifier
);
6188 #undef SINGLE_LETTER_MOD
6190 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6191 if (i + LEN + 1 <= SBYTES (name) \
6192 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6194 this_mod_end = i + LEN; \
6199 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6200 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6201 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6205 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6207 #undef MULTI_LETTER_MOD
6211 /* If we found no modifier, stop looking for them. */
6212 if (this_mod_end
== 0)
6215 /* Check there is a dash after the modifier, so that it
6216 really is a modifier. */
6217 if (this_mod_end
>= SBYTES (name
)
6218 || SREF (name
, this_mod_end
) != '-')
6221 /* This modifier is real; look for another. */
6222 modifiers
|= this_mod
;
6223 i
= this_mod_end
+ 1;
6226 /* Should we include the `click' modifier? */
6227 if (! (modifiers
& (down_modifier
| drag_modifier
6228 | double_modifier
| triple_modifier
))
6229 && i
+ 7 == SBYTES (name
)
6230 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
6231 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6232 modifiers
|= click_modifier
;
6240 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6241 prepended to the string BASE[0..BASE_LEN-1].
6242 This doesn't use any caches. */
6244 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
6247 int base_len
, base_len_byte
;
6249 /* Since BASE could contain nulls, we can't use intern here; we have
6250 to use Fintern, which expects a genuine Lisp_String, and keeps a
6253 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6259 /* Only the event queue may use the `up' modifier; it should always
6260 be turned into a click or drag event before presented to lisp code. */
6261 if (modifiers
& up_modifier
)
6264 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6265 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6266 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6267 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6268 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6269 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6270 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6271 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6272 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6273 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6274 /* The click modifier is denoted by the absence of other modifiers. */
6278 mod_len
= p
- new_mods
;
6282 Lisp_Object new_name
;
6284 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6285 mod_len
+ base_len_byte
);
6286 bcopy (new_mods
, SDATA (new_name
), mod_len
);
6287 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
6289 return Fintern (new_name
, Qnil
);
6294 static char *modifier_names
[] =
6296 "up", "down", "drag", "click", "double", "triple", 0, 0,
6297 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6298 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6300 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6302 static Lisp_Object modifier_symbols
;
6304 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6306 lispy_modifier_list (modifiers
)
6309 Lisp_Object modifier_list
;
6312 modifier_list
= Qnil
;
6313 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6314 if (modifiers
& (1<<i
))
6315 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6318 return modifier_list
;
6322 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6323 where UNMODIFIED is the unmodified form of SYMBOL,
6324 MASK is the set of modifiers present in SYMBOL's name.
6325 This is similar to parse_modifiers_uncached, but uses the cache in
6326 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6327 Qevent_symbol_elements property. */
6330 parse_modifiers (symbol
)
6333 Lisp_Object elements
;
6335 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6336 if (CONSP (elements
))
6341 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6342 Lisp_Object unmodified
;
6345 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6346 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6349 if (modifiers
& ~INTMASK
)
6351 XSETFASTINT (mask
, modifiers
);
6352 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6354 /* Cache the parsing results on SYMBOL. */
6355 Fput (symbol
, Qevent_symbol_element_mask
,
6357 Fput (symbol
, Qevent_symbol_elements
,
6358 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6360 /* Since we know that SYMBOL is modifiers applied to unmodified,
6361 it would be nice to put that in unmodified's cache.
6362 But we can't, since we're not sure that parse_modifiers is
6369 /* Apply the modifiers MODIFIERS to the symbol BASE.
6370 BASE must be unmodified.
6372 This is like apply_modifiers_uncached, but uses BASE's
6373 Qmodifier_cache property, if present. It also builds
6374 Qevent_symbol_elements properties, since it has that info anyway.
6376 apply_modifiers copies the value of BASE's Qevent_kind property to
6377 the modified symbol. */
6379 apply_modifiers (modifiers
, base
)
6383 Lisp_Object cache
, index
, entry
, new_symbol
;
6385 /* Mask out upper bits. We don't know where this value's been. */
6386 modifiers
&= INTMASK
;
6388 /* The click modifier never figures into cache indices. */
6389 cache
= Fget (base
, Qmodifier_cache
);
6390 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6391 entry
= assq_no_quit (index
, cache
);
6394 new_symbol
= XCDR (entry
);
6397 /* We have to create the symbol ourselves. */
6398 new_symbol
= apply_modifiers_uncached (modifiers
,
6399 SDATA (SYMBOL_NAME (base
)),
6400 SCHARS (SYMBOL_NAME (base
)),
6401 SBYTES (SYMBOL_NAME (base
)));
6403 /* Add the new symbol to the base's cache. */
6404 entry
= Fcons (index
, new_symbol
);
6405 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6407 /* We have the parsing info now for free, so we could add it to
6409 XSETFASTINT (index, modifiers);
6410 Fput (new_symbol, Qevent_symbol_element_mask,
6411 Fcons (base, Fcons (index, Qnil)));
6412 Fput (new_symbol, Qevent_symbol_elements,
6413 Fcons (base, lispy_modifier_list (modifiers)));
6414 Sadly, this is only correct if `base' is indeed a base event,
6415 which is not necessarily the case. -stef */
6418 /* Make sure this symbol is of the same kind as BASE.
6420 You'd think we could just set this once and for all when we
6421 intern the symbol above, but reorder_modifiers may call us when
6422 BASE's property isn't set right; we can't assume that just
6423 because it has a Qmodifier_cache property it must have its
6424 Qevent_kind set right as well. */
6425 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6429 kind
= Fget (base
, Qevent_kind
);
6431 Fput (new_symbol
, Qevent_kind
, kind
);
6438 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6439 return a symbol with the modifiers placed in the canonical order.
6440 Canonical order is alphabetical, except for down and drag, which
6441 always come last. The 'click' modifier is never written out.
6443 Fdefine_key calls this to make sure that (for example) C-M-foo
6444 and M-C-foo end up being equivalent in the keymap. */
6447 reorder_modifiers (symbol
)
6450 /* It's hopefully okay to write the code this way, since everything
6451 will soon be in caches, and no consing will be done at all. */
6454 parsed
= parse_modifiers (symbol
);
6455 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6460 /* For handling events, we often want to produce a symbol whose name
6461 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6462 to some base, like the name of a function key or mouse button.
6463 modify_event_symbol produces symbols of this sort.
6465 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6466 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6469 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6470 into symbol names, or a string specifying a name stem used to
6471 construct a symbol name or the form `STEM-N', where N is the decimal
6472 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6473 non-nil; otherwise NAME_TABLE is used.
6475 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6476 persist between calls to modify_event_symbol that it can use to
6477 store a cache of the symbols it's generated for this NAME_TABLE
6478 before. The object stored there may be a vector or an alist.
6480 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6482 MODIFIERS is a set of modifier bits (as given in struct input_events)
6483 whose prefixes should be applied to the symbol name.
6485 SYMBOL_KIND is the value to be placed in the event_kind property of
6486 the returned symbol.
6488 The symbols we create are supposed to have an
6489 `event-symbol-elements' property, which lists the modifiers present
6490 in the symbol's name. */
6493 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6494 name_table
, symbol_table
, table_size
)
6497 Lisp_Object symbol_kind
;
6498 Lisp_Object name_alist_or_stem
;
6500 Lisp_Object
*symbol_table
;
6501 unsigned int table_size
;
6504 Lisp_Object symbol_int
;
6506 /* Get rid of the "vendor-specific" bit here. */
6507 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6509 /* Is this a request for a valid symbol? */
6510 if (symbol_num
< 0 || symbol_num
>= table_size
)
6513 if (CONSP (*symbol_table
))
6514 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6516 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6517 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6518 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6519 we've never used that symbol before. */
6522 if (! VECTORP (*symbol_table
)
6523 || XVECTOR (*symbol_table
)->size
!= table_size
)
6527 XSETFASTINT (size
, table_size
);
6528 *symbol_table
= Fmake_vector (size
, Qnil
);
6531 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6534 /* Have we already used this symbol before? */
6537 /* No; let's create it. */
6538 if (CONSP (name_alist_or_stem
))
6539 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6540 else if (STRINGP (name_alist_or_stem
))
6542 int len
= SBYTES (name_alist_or_stem
);
6543 char *buf
= (char *) alloca (len
+ 50);
6544 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6545 (long) XINT (symbol_int
) + 1);
6546 value
= intern (buf
);
6548 else if (name_table
!= 0 && name_table
[symbol_num
])
6549 value
= intern (name_table
[symbol_num
]);
6551 #ifdef HAVE_WINDOW_SYSTEM
6554 char *name
= x_get_keysym_name (symbol_num
);
6556 value
= intern (name
);
6563 sprintf (buf
, "key-%d", symbol_num
);
6564 value
= intern (buf
);
6567 if (CONSP (*symbol_table
))
6568 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6570 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6572 /* Fill in the cache entries for this symbol; this also
6573 builds the Qevent_symbol_elements property, which the user
6575 apply_modifiers (modifiers
& click_modifier
, value
);
6576 Fput (value
, Qevent_kind
, symbol_kind
);
6579 /* Apply modifiers to that symbol. */
6580 return apply_modifiers (modifiers
, value
);
6583 /* Convert a list that represents an event type,
6584 such as (ctrl meta backspace), into the usual representation of that
6585 event type as a number or a symbol. */
6587 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6588 doc
: /* Convert the event description list EVENT-DESC to an event type.
6589 EVENT-DESC should contain one base event type (a character or symbol)
6590 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6591 drag, down, double or triple). The base must be last.
6592 The return value is an event type (a character or symbol) which
6593 has the same base event type and all the specified modifiers. */)
6595 Lisp_Object event_desc
;
6603 while (CONSP (rest
))
6611 /* Given a symbol, see if it is a modifier name. */
6612 if (SYMBOLP (elt
) && CONSP (rest
))
6613 this = parse_solitary_modifier (elt
);
6617 else if (!NILP (base
))
6618 error ("Two bases given in one event");
6624 /* Let the symbol A refer to the character A. */
6625 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6626 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6628 if (INTEGERP (base
))
6630 /* Turn (shift a) into A. */
6631 if ((modifiers
& shift_modifier
) != 0
6632 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6634 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6635 modifiers
&= ~shift_modifier
;
6638 /* Turn (control a) into C-a. */
6639 if (modifiers
& ctrl_modifier
)
6640 return make_number ((modifiers
& ~ctrl_modifier
)
6641 | make_ctrl_char (XINT (base
)));
6643 return make_number (modifiers
| XINT (base
));
6645 else if (SYMBOLP (base
))
6646 return apply_modifiers (modifiers
, base
);
6649 error ("Invalid base event");
6654 /* Try to recognize SYMBOL as a modifier name.
6655 Return the modifier flag bit, or 0 if not recognized. */
6658 parse_solitary_modifier (symbol
)
6661 Lisp_Object name
= SYMBOL_NAME (symbol
);
6663 switch (SREF (name
, 0))
6665 #define SINGLE_LETTER_MOD(BIT) \
6666 if (SBYTES (name) == 1) \
6669 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6670 if (LEN == SBYTES (name) \
6671 && ! strncmp (SDATA (name), NAME, LEN)) \
6675 SINGLE_LETTER_MOD (alt_modifier
);
6679 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6683 SINGLE_LETTER_MOD (ctrl_modifier
);
6687 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6688 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6692 SINGLE_LETTER_MOD (hyper_modifier
);
6696 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6700 SINGLE_LETTER_MOD (meta_modifier
);
6704 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6708 SINGLE_LETTER_MOD (shift_modifier
);
6712 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6713 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6714 SINGLE_LETTER_MOD (super_modifier
);
6718 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6719 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6720 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6724 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6727 #undef SINGLE_LETTER_MOD
6728 #undef MULTI_LETTER_MOD
6734 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6735 Such a list is not valid as an event,
6736 but it can be a Lucid-style event type list. */
6739 lucid_event_type_list_p (object
)
6744 if (! CONSP (object
))
6747 if (EQ (XCAR (object
), Qhelp_echo
)
6748 || EQ (XCAR (object
), Qvertical_line
)
6749 || EQ (XCAR (object
), Qmode_line
)
6750 || EQ (XCAR (object
), Qheader_line
))
6753 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6757 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6764 /* Store into *addr a value nonzero if terminal input chars are available.
6765 Serves the purpose of ioctl (0, FIONREAD, addr)
6766 but works even if FIONREAD does not exist.
6767 (In fact, this may actually read some input.)
6769 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6770 timer events that are ripe.
6771 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6772 events (FOCUS_IN_EVENT).
6773 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6774 movements and toolkit scroll bar thumb drags. */
6777 get_input_pending (addr
, flags
)
6781 /* First of all, have we already counted some input? */
6782 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6784 /* If input is being read as it arrives, and we have none, there is none. */
6785 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6788 /* Try to read some input and see how much we get. */
6790 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6793 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6796 gobble_input (expected
)
6801 if (interrupt_input
)
6804 mask
= sigblock (sigmask (SIGIO
));
6805 read_avail_input (expected
);
6809 #ifdef POLL_FOR_INPUT
6810 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
6813 mask
= sigblock (sigmask (SIGALRM
));
6814 read_avail_input (expected
);
6820 read_avail_input (expected
);
6824 /* Put a BUFFER_SWITCH_EVENT in the buffer
6825 so that read_key_sequence will notice the new current buffer. */
6828 record_asynch_buffer_change ()
6830 struct input_event event
;
6834 event
.kind
= BUFFER_SWITCH_EVENT
;
6835 event
.frame_or_window
= Qnil
;
6839 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6840 The purpose of the event is to make read_key_sequence look up the
6841 keymaps again. If we aren't in read_key_sequence, we don't need one,
6842 and the event could cause trouble by messing up (input-pending-p). */
6843 tem
= Fwaiting_for_user_input_p ();
6847 /* We never need these events if we have no asynchronous subprocesses. */
6851 /* Make sure no interrupt happens while storing the event. */
6853 if (interrupt_input
)
6856 mask
= sigblock (sigmask (SIGIO
));
6857 kbd_buffer_store_event (&event
);
6864 kbd_buffer_store_event (&event
);
6871 /* Read any terminal input already buffered up by the system
6872 into the kbd_buffer, but do not wait.
6874 EXPECTED should be nonzero if the caller knows there is some input.
6876 Except on VMS, all input is read by this function.
6877 If interrupt_input is nonzero, this function MUST be called
6878 only when SIGIO is blocked.
6880 Returns the number of keyboard chars read, or -1 meaning
6881 this is a bad time to try to read input. */
6884 read_avail_input (expected
)
6890 /* Store pending user signal events, if any. */
6891 if (store_user_signal_events ())
6894 if (read_socket_hook
)
6897 struct input_event hold_quit
;
6899 EVENT_INIT (hold_quit
);
6900 hold_quit
.kind
= NO_EVENT
;
6902 /* No need for FIONREAD or fcntl; just say don't wait. */
6903 while (nr
= (*read_socket_hook
) (input_fd
, expected
, &hold_quit
), nr
> 0)
6908 if (hold_quit
.kind
!= NO_EVENT
)
6909 kbd_buffer_store_event (&hold_quit
);
6913 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6914 the kbd_buffer can really hold. That may prevent loss
6915 of characters on some systems when input is stuffed at us. */
6916 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6919 /* Determine how many characters we should *try* to read. */
6922 #else /* not WINDOWSNT */
6924 n_to_read
= dos_keysns ();
6927 #else /* not MSDOS */
6932 struct input_event hold_quit
;
6935 EVENT_INIT (hold_quit
);
6936 hold_quit
.kind
= NO_EVENT
;
6938 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
6939 nread
+= handle_one_term_event (&event
, &hold_quit
);
6941 if (hold_quit
.kind
!= NO_EVENT
)
6942 kbd_buffer_store_event (&hold_quit
);
6946 #endif /* HAVE_GPM */
6949 /* Find out how much input is available. */
6950 if (ioctl (input_fd
, FIONREAD
, &n_to_read
) < 0)
6951 /* Formerly simply reported no input, but that sometimes led to
6952 a failure of Emacs to terminate.
6953 SIGHUP seems appropriate if we can't reach the terminal. */
6954 /* ??? Is it really right to send the signal just to this process
6955 rather than to the whole process group?
6956 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6958 if (! noninteractive
)
6959 kill (getpid (), SIGHUP
);
6965 if (n_to_read
> sizeof cbuf
)
6966 n_to_read
= sizeof cbuf
;
6967 #else /* no FIONREAD */
6968 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
6969 /* Read some input if available, but don't wait. */
6970 n_to_read
= sizeof cbuf
;
6971 fcntl (input_fd
, F_SETFL
, O_NDELAY
);
6976 #endif /* not MSDOS */
6977 #endif /* not WINDOWSNT */
6979 /* Now read; for one reason or another, this will not block.
6980 NREAD is set to the number of chars read. */
6984 cbuf
[0] = dos_keyread ();
6987 nread
= emacs_read (input_fd
, cbuf
, n_to_read
);
6989 /* POSIX infers that processes which are not in the session leader's
6990 process group won't get SIGHUP's at logout time. BSDI adheres to
6991 this part standard and returns -1 from read (0) with errno==EIO
6992 when the control tty is taken away.
6993 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6994 if (nread
== -1 && errno
== EIO
)
6996 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6997 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6998 This looks incorrect, but it isn't, because _BSD causes
6999 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7000 and that causes a value other than 0 when there is no input. */
7006 /* We used to retry the read if it was interrupted.
7007 But this does the wrong thing when O_NDELAY causes
7008 an EAGAIN error. Does anybody know of a situation
7009 where a retry is actually needed? */
7011 nread
< 0 && (errno
== EAGAIN
7025 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
7026 fcntl (input_fd
, F_SETFL
, 0);
7027 #endif /* USG or DGUX or CYGWIN */
7028 #endif /* no FIONREAD */
7029 for (i
= 0; i
< nread
; i
++)
7031 struct input_event buf
;
7033 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7035 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
7036 buf
.modifiers
= meta_modifier
;
7041 buf
.frame_or_window
= selected_frame
;
7044 kbd_buffer_store_event (&buf
);
7045 /* Don't look at input that follows a C-g too closely.
7046 This reduces lossage due to autorepeat on C-g. */
7047 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7048 && buf
.code
== quit_char
)
7055 #endif /* not VMS */
7058 handle_async_input ()
7061 extern int select_alarmed
;
7064 interrupt_input_pending
= 0;
7069 nread
= read_avail_input (1);
7070 /* -1 means it's not ok to read the input now.
7071 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7072 0 means there was no keyboard input available. */
7077 select_alarmed
= 1; /* Force the select emulator back to life */
7082 #ifdef SIGIO /* for entire page */
7083 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7086 input_available_signal (signo
)
7089 /* Must preserve main program's value of errno. */
7090 int old_errno
= errno
;
7091 #if defined (USG) && !defined (POSIX_SIGNALS)
7092 /* USG systems forget handlers when they are used;
7093 must reestablish each time */
7094 signal (signo
, input_available_signal
);
7102 interrupt_input_pending
= 1;
7104 SIGNAL_THREAD_CHECK (signo
);
7107 if (input_available_clear_time
)
7108 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7111 handle_async_input ();
7121 /* Send ourselves a SIGIO.
7123 This function exists so that the UNBLOCK_INPUT macro in
7124 blockinput.h can have some way to take care of input we put off
7125 dealing with, without assuming that every file which uses
7126 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7128 reinvoke_input_signal ()
7131 handle_async_input ();
7137 /* User signal events. */
7139 struct user_signal_info
7141 /* Signal number. */
7144 /* Name of the signal. */
7147 /* Number of pending signals. */
7150 struct user_signal_info
*next
;
7153 /* List of user signals. */
7154 static struct user_signal_info
*user_signals
= NULL
;
7157 add_user_signal (sig
, name
)
7161 struct user_signal_info
*p
;
7163 for (p
= user_signals
; p
; p
= p
->next
)
7165 /* Already added. */
7168 p
= xmalloc (sizeof (struct user_signal_info
));
7170 p
->name
= xstrdup (name
);
7172 p
->next
= user_signals
;
7175 signal (sig
, handle_user_signal
);
7179 handle_user_signal (sig
)
7182 int old_errno
= errno
;
7183 struct user_signal_info
*p
;
7185 #if defined (USG) && !defined (POSIX_SIGNALS)
7186 /* USG systems forget handlers when they are used;
7187 must reestablish each time */
7188 signal (sig
, handle_user_signal
);
7191 SIGNAL_THREAD_CHECK (sig
);
7193 for (p
= user_signals
; p
; p
= p
->next
)
7198 if (interrupt_input
)
7199 kill (getpid (), SIGIO
);
7203 /* Tell wait_reading_process_output that it needs to wake
7204 up and look around. */
7205 if (input_available_clear_time
)
7206 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7215 find_user_signal_name (sig
)
7218 struct user_signal_info
*p
;
7220 for (p
= user_signals
; p
; p
= p
->next
)
7228 store_user_signal_events ()
7230 struct user_signal_info
*p
;
7231 struct input_event buf
;
7234 for (p
= user_signals
; p
; p
= p
->next
)
7235 if (p
->npending
> 0)
7241 bzero (&buf
, sizeof buf
);
7242 buf
.kind
= USER_SIGNAL_EVENT
;
7243 buf
.frame_or_window
= selected_frame
;
7245 nstored
+= p
->npending
;
7247 mask
= sigblock (sigmask (p
->sig
));
7251 kbd_buffer_store_event (&buf
);
7254 while (p
->npending
> 0);
7262 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
7263 static Lisp_Object menu_bar_one_keymap_changed_items
;
7265 /* These variables hold the vector under construction within
7266 menu_bar_items and its subroutines, and the current index
7267 for storing into that vector. */
7268 static Lisp_Object menu_bar_items_vector
;
7269 static int menu_bar_items_index
;
7271 /* Return a vector of menu items for a menu bar, appropriate
7272 to the current buffer. Each item has three elements in the vector:
7275 OLD is an old vector we can optionally reuse, or nil. */
7278 menu_bar_items (old
)
7281 /* The number of keymaps we're scanning right now, and the number of
7282 keymaps we have allocated space for. */
7285 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7286 in the current keymaps, or nil where it is not a prefix. */
7289 Lisp_Object def
, tail
;
7298 /* In order to build the menus, we need to call the keymap
7299 accessors. They all call QUIT. But this function is called
7300 during redisplay, during which a quit is fatal. So inhibit
7301 quitting while building the menus.
7302 We do this instead of specbind because (1) errors will clear it anyway
7303 and (2) this avoids risk of specpdl overflow. */
7304 oquit
= Vinhibit_quit
;
7308 menu_bar_items_vector
= old
;
7310 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7311 menu_bar_items_index
= 0;
7313 /* Build our list of keymaps.
7314 If we recognize a function key and replace its escape sequence in
7315 keybuf with its symbol, or if the sequence starts with a mouse
7316 click and we need to switch buffers, we jump back here to rebuild
7317 the initial keymaps from the current buffer. */
7321 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7322 if (!NILP (Voverriding_local_map_menu_flag
))
7324 /* Yes, use them (if non-nil) as well as the global map. */
7325 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7327 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7328 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7329 if (!NILP (Voverriding_local_map
))
7330 maps
[nmaps
++] = Voverriding_local_map
;
7334 /* No, so use major and minor mode keymaps and keymap property.
7335 Note that menu-bar bindings in the local-map and keymap
7336 properties may not work reliable, as they are only
7337 recognized when the menu-bar (or mode-line) is updated,
7338 which does not normally happen after every command. */
7341 nminor
= current_minor_maps (NULL
, &tmaps
);
7342 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7344 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7345 maps
[nmaps
++] = tem
;
7346 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7348 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7350 maps
[nmaps
++] = current_global_map
;
7353 /* Look up in each map the dummy prefix key `menu-bar'. */
7357 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7358 if (!NILP (maps
[mapno
]))
7360 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7364 menu_bar_one_keymap_changed_items
= Qnil
;
7365 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7369 /* Move to the end those items that should be at the end. */
7371 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7374 int end
= menu_bar_items_index
;
7376 for (i
= 0; i
< end
; i
+= 4)
7377 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7379 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7380 /* Move the item at index I to the end,
7381 shifting all the others forward. */
7382 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7383 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7384 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7385 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7387 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7388 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7389 (end
- i
- 4) * sizeof (Lisp_Object
));
7390 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7391 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7392 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7393 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7398 /* Add nil, nil, nil, nil at the end. */
7399 i
= menu_bar_items_index
;
7400 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7403 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7404 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7405 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7406 menu_bar_items_vector
= tem
;
7408 /* Add this item. */
7409 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7410 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7411 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7412 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7413 menu_bar_items_index
= i
;
7415 Vinhibit_quit
= oquit
;
7416 return menu_bar_items_vector
;
7419 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7420 If there's already an item for KEY, add this DEF to it. */
7422 Lisp_Object item_properties
;
7425 menu_bar_item (key
, item
, dummy1
, dummy2
)
7426 Lisp_Object key
, item
, dummy1
;
7429 struct gcpro gcpro1
;
7433 if (EQ (item
, Qundefined
))
7435 /* If a map has an explicit `undefined' as definition,
7436 discard any previously made menu bar item. */
7438 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7439 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7441 if (menu_bar_items_index
> i
+ 4)
7442 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7443 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7444 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7445 menu_bar_items_index
-= 4;
7449 /* If this keymap has already contributed to this KEY,
7450 don't contribute to it a second time. */
7451 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7452 if (!NILP (tem
) || NILP (item
))
7455 menu_bar_one_keymap_changed_items
7456 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7458 /* We add to menu_bar_one_keymap_changed_items before doing the
7459 parse_menu_item, so that if it turns out it wasn't a menu item,
7460 it still correctly hides any further menu item. */
7462 i
= parse_menu_item (item
, 0, 1);
7467 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7469 /* Find any existing item for this KEY. */
7470 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7471 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7474 /* If we did not find this KEY, add it at the end. */
7475 if (i
== menu_bar_items_index
)
7477 /* If vector is too small, get a bigger one. */
7478 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7481 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7482 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7483 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7484 menu_bar_items_vector
= tem
;
7487 /* Add this item. */
7488 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7489 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7490 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7491 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7492 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7493 menu_bar_items_index
= i
;
7495 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7499 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7500 /* If the new and the old items are not both keymaps,
7501 the lookup will only find `item'. */
7502 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7503 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7507 /* This is used as the handler when calling menu_item_eval_property. */
7509 menu_item_eval_property_1 (arg
)
7512 /* If we got a quit from within the menu computation,
7513 quit all the way out of it. This takes care of C-] in the debugger. */
7514 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7515 Fsignal (Qquit
, Qnil
);
7520 /* Evaluate an expression and return the result (or nil if something
7521 went wrong). Used to evaluate dynamic parts of menu items. */
7523 menu_item_eval_property (sexpr
)
7526 int count
= SPECPDL_INDEX ();
7528 specbind (Qinhibit_redisplay
, Qt
);
7529 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7530 menu_item_eval_property_1
);
7531 return unbind_to (count
, val
);
7534 /* This function parses a menu item and leaves the result in the
7535 vector item_properties.
7536 ITEM is a key binding, a possible menu item.
7537 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7538 evaluate dynamic expressions in the menu item.
7539 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7541 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7542 parse_menu_item returns true if the item is a menu item and false
7546 parse_menu_item (item
, notreal
, inmenubar
)
7548 int notreal
, inmenubar
;
7550 Lisp_Object def
, tem
, item_string
, start
;
7551 Lisp_Object cachelist
;
7553 Lisp_Object keyhint
;
7564 /* Create item_properties vector if necessary. */
7565 if (NILP (item_properties
))
7567 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7569 /* Initialize optional entries. */
7570 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7571 AREF (item_properties
, i
) = Qnil
;
7572 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7574 /* Save the item here to protect it from GC. */
7575 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7577 item_string
= XCAR (item
);
7581 if (STRINGP (item_string
))
7583 /* Old format menu item. */
7584 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7586 /* Maybe help string. */
7587 if (CONSP (item
) && STRINGP (XCAR (item
)))
7589 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7594 /* Maybe key binding cache. */
7595 if (CONSP (item
) && CONSP (XCAR (item
))
7596 && (NILP (XCAR (XCAR (item
)))
7597 || VECTORP (XCAR (XCAR (item
)))))
7599 cachelist
= XCAR (item
);
7603 /* This is the real definition--the function to run. */
7604 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7606 /* Get enable property, if any. */
7609 tem
= Fget (item
, Qmenu_enable
);
7610 if (!NILP (Venable_disabled_menus_and_buttons
))
7611 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7612 else if (!NILP (tem
))
7613 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7616 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7618 /* New format menu item. */
7619 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7620 start
= XCDR (item
);
7623 /* We have a real binding. */
7624 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7626 item
= XCDR (start
);
7627 /* Is there a cache list with key equivalences. */
7628 if (CONSP (item
) && CONSP (XCAR (item
)))
7630 cachelist
= XCAR (item
);
7634 /* Parse properties. */
7635 while (CONSP (item
) && CONSP (XCDR (item
)))
7640 if (EQ (tem
, QCenable
))
7642 if (!NILP (Venable_disabled_menus_and_buttons
))
7643 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7645 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7647 else if (EQ (tem
, QCvisible
) && !notreal
)
7649 /* If got a visible property and that evaluates to nil
7650 then ignore this item. */
7651 tem
= menu_item_eval_property (XCAR (item
));
7655 else if (EQ (tem
, QChelp
))
7656 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7657 else if (EQ (tem
, QCfilter
))
7659 else if (EQ (tem
, QCkey_sequence
))
7662 if (NILP (cachelist
)
7663 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7664 /* Be GC protected. Set keyhint to item instead of tem. */
7667 else if (EQ (tem
, QCkeys
))
7670 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7671 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7673 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7678 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7680 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7682 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7689 else if (inmenubar
|| !NILP (start
))
7693 return 0; /* not a menu item */
7695 /* If item string is not a string, evaluate it to get string.
7696 If we don't get a string, skip this item. */
7697 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7698 if (!(STRINGP (item_string
) || notreal
))
7700 item_string
= menu_item_eval_property (item_string
);
7701 if (!STRINGP (item_string
))
7703 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7706 /* If got a filter apply it on definition. */
7707 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7710 def
= menu_item_eval_property (list2 (XCAR (filter
),
7711 list2 (Qquote
, def
)));
7713 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7716 /* Enable or disable selection of item. */
7717 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7723 tem
= menu_item_eval_property (tem
);
7724 if (inmenubar
&& NILP (tem
))
7725 return 0; /* Ignore disabled items in menu bar. */
7726 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7729 /* If we got no definition, this item is just unselectable text which
7730 is OK in a submenu but not in the menubar. */
7732 return (inmenubar
? 0 : 1);
7734 /* See if this is a separate pane or a submenu. */
7735 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7736 tem
= get_keymap (def
, 0, 1);
7737 /* For a subkeymap, just record its details and exit. */
7740 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7741 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7745 /* At the top level in the menu bar, do likewise for commands also.
7746 The menu bar does not display equivalent key bindings anyway.
7747 ITEM_PROPERTY_DEF is already set up properly. */
7751 /* This is a command. See if there is an equivalent key binding. */
7752 if (NILP (cachelist
))
7754 /* We have to create a cachelist. */
7755 CHECK_IMPURE (start
);
7756 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
7757 cachelist
= XCAR (XCDR (start
));
7759 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7760 if (!NILP (keyhint
))
7762 XSETCAR (cachelist
, XCAR (keyhint
));
7765 else if (STRINGP (tem
))
7767 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
7768 XSETCAR (cachelist
, Qt
);
7772 tem
= XCAR (cachelist
);
7779 tem
= Fkey_binding (tem
, Qnil
, Qnil
, Qnil
);
7781 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7784 def
= XCAR (prefix
);
7785 prefix
= XCDR (prefix
);
7788 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7790 if (NILP (XCAR (cachelist
))) /* Have no saved key. */
7792 if (newcache
/* Always check first time. */
7793 /* Should we check everything when precomputing key
7795 /* If something had no key binding before, don't recheck it
7796 because that is too slow--except if we have a list of
7797 rebound commands in Vdefine_key_rebound_commands, do
7798 recheck any command that appears in that list. */
7799 || (CONSP (Vdefine_key_rebound_commands
)
7800 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
7803 /* We had a saved key. Is it still bound to the command? */
7806 /* If the command is an alias for another
7807 (such as lmenu.el set it up), check if the
7808 original command matches the cached command. */
7809 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7810 chkcache
= 1; /* Need to recompute key binding. */
7814 /* Recompute equivalent key binding. If the command is an alias
7815 for another (such as lmenu.el set it up), see if the original
7816 command name has equivalent keys. Otherwise look up the
7817 specified command itself. We don't try both, because that
7818 makes lmenu menus slow. */
7820 && SYMBOLP (XSYMBOL (def
)->function
)
7821 && ! NILP (Fget (def
, Qmenu_alias
)))
7822 def
= XSYMBOL (def
)->function
;
7823 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
7824 XSETCAR (cachelist
, tem
);
7827 XSETCDR (cachelist
, Qnil
);
7831 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
7833 tem
= XCAR (cachelist
);
7837 newcache
= chkcache
;
7840 tem
= Fkey_description (tem
, Qnil
);
7843 if (STRINGP (XCAR (prefix
)))
7844 tem
= concat2 (XCAR (prefix
), tem
);
7845 if (STRINGP (XCDR (prefix
)))
7846 tem
= concat2 (tem
, XCDR (prefix
));
7848 XSETCDR (cachelist
, tem
);
7852 tem
= XCDR (cachelist
);
7853 if (newcache
&& !NILP (tem
))
7855 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
7856 XSETCDR (cachelist
, tem
);
7859 /* If we only want to precompute equivalent key bindings, stop here. */
7863 /* If we have an equivalent key binding, use that. */
7864 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7866 /* Include this when menu help is implemented.
7867 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7868 if (!(NILP (tem) || STRINGP (tem)))
7870 tem = menu_item_eval_property (tem);
7873 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7877 /* Handle radio buttons or toggle boxes. */
7878 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7880 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7881 = menu_item_eval_property (tem
);
7888 /***********************************************************************
7890 ***********************************************************************/
7892 /* A vector holding tool bar items while they are parsed in function
7893 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7896 static Lisp_Object tool_bar_items_vector
;
7898 /* A vector holding the result of parse_tool_bar_item. Layout is like
7899 the one for a single item in tool_bar_items_vector. */
7901 static Lisp_Object tool_bar_item_properties
;
7903 /* Next free index in tool_bar_items_vector. */
7905 static int ntool_bar_items
;
7907 /* The symbols `tool-bar', and `:image'. */
7909 extern Lisp_Object Qtool_bar
;
7910 Lisp_Object QCimage
;
7912 /* Function prototypes. */
7914 static void init_tool_bar_items
P_ ((Lisp_Object
));
7915 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
7916 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7917 static void append_tool_bar_item
P_ ((void));
7920 /* Return a vector of tool bar items for keymaps currently in effect.
7921 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7922 tool bar items found. */
7925 tool_bar_items (reuse
, nitems
)
7936 /* In order to build the menus, we need to call the keymap
7937 accessors. They all call QUIT. But this function is called
7938 during redisplay, during which a quit is fatal. So inhibit
7939 quitting while building the menus. We do this instead of
7940 specbind because (1) errors will clear it anyway and (2) this
7941 avoids risk of specpdl overflow. */
7942 oquit
= Vinhibit_quit
;
7945 /* Initialize tool_bar_items_vector and protect it from GC. */
7946 init_tool_bar_items (reuse
);
7948 /* Build list of keymaps in maps. Set nmaps to the number of maps
7951 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7952 if (!NILP (Voverriding_local_map_menu_flag
))
7954 /* Yes, use them (if non-nil) as well as the global map. */
7955 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7957 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7958 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7959 if (!NILP (Voverriding_local_map
))
7960 maps
[nmaps
++] = Voverriding_local_map
;
7964 /* No, so use major and minor mode keymaps and keymap property.
7965 Note that tool-bar bindings in the local-map and keymap
7966 properties may not work reliable, as they are only
7967 recognized when the tool-bar (or mode-line) is updated,
7968 which does not normally happen after every command. */
7971 nminor
= current_minor_maps (NULL
, &tmaps
);
7972 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7974 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7975 maps
[nmaps
++] = tem
;
7976 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7978 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7981 /* Add global keymap at the end. */
7982 maps
[nmaps
++] = current_global_map
;
7984 /* Process maps in reverse order and look up in each map the prefix
7986 for (i
= nmaps
- 1; i
>= 0; --i
)
7987 if (!NILP (maps
[i
]))
7991 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7993 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
7996 Vinhibit_quit
= oquit
;
7997 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7998 return tool_bar_items_vector
;
8002 /* Process the definition of KEY which is DEF. */
8005 process_tool_bar_item (key
, def
, data
, args
)
8006 Lisp_Object key
, def
, data
;
8010 extern Lisp_Object Qundefined
;
8011 struct gcpro gcpro1
, gcpro2
;
8013 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8017 if (EQ (def
, Qundefined
))
8019 /* If a map has an explicit `undefined' as definition,
8020 discard any previously made item. */
8021 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8023 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8025 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8027 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8028 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
8029 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8030 * sizeof (Lisp_Object
)));
8031 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8036 else if (parse_tool_bar_item (key
, def
))
8037 /* Append a new tool bar item to tool_bar_items_vector. Accept
8038 more than one definition for the same key. */
8039 append_tool_bar_item ();
8045 /* Parse a tool bar item specification ITEM for key KEY and return the
8046 result in tool_bar_item_properties. Value is zero if ITEM is
8049 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8051 CAPTION is the caption of the item, If it's not a string, it is
8052 evaluated to get a string.
8054 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8055 as binding are currently ignored.
8057 The following properties are recognized:
8061 FORM is evaluated and specifies whether the tool bar item is
8062 enabled or disabled.
8066 FORM is evaluated and specifies whether the tool bar item is visible.
8068 - `:filter FUNCTION'
8070 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8071 result is stored as the new binding.
8073 - `:button (TYPE SELECTED)'
8075 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8076 and specifies whether the button is selected (pressed) or not.
8080 IMAGES is either a single image specification or a vector of four
8081 image specifications. See enum tool_bar_item_images.
8083 - `:help HELP-STRING'.
8085 Gives a help string to display for the tool bar item. */
8088 parse_tool_bar_item (key
, item
)
8089 Lisp_Object key
, item
;
8091 /* Access slot with index IDX of vector tool_bar_item_properties. */
8092 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8094 Lisp_Object filter
= Qnil
;
8095 Lisp_Object caption
;
8098 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8099 Rule out items that aren't lists, don't start with
8100 `menu-item' or whose rest following `tool-bar-item' is not a
8103 || !EQ (XCAR (item
), Qmenu_item
)
8104 || (item
= XCDR (item
),
8108 /* Create tool_bar_item_properties vector if necessary. Reset it to
8110 if (VECTORP (tool_bar_item_properties
))
8112 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8116 tool_bar_item_properties
8117 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8120 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8121 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8123 /* Get the caption of the item. If the caption is not a string,
8124 evaluate it to get a string. If we don't get a string, skip this
8126 caption
= XCAR (item
);
8127 if (!STRINGP (caption
))
8129 caption
= menu_item_eval_property (caption
);
8130 if (!STRINGP (caption
))
8133 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8135 /* Give up if rest following the caption is not a list. */
8140 /* Store the binding. */
8141 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8144 /* Ignore cached key binding, if any. */
8145 if (CONSP (item
) && CONSP (XCAR (item
)))
8148 /* Process the rest of the properties. */
8149 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8151 Lisp_Object key
, value
;
8154 value
= XCAR (XCDR (item
));
8156 if (EQ (key
, QCenable
))
8158 /* `:enable FORM'. */
8159 if (!NILP (Venable_disabled_menus_and_buttons
))
8160 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8162 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8164 else if (EQ (key
, QCvisible
))
8166 /* `:visible FORM'. If got a visible property and that
8167 evaluates to nil then ignore this item. */
8168 if (NILP (menu_item_eval_property (value
)))
8171 else if (EQ (key
, QChelp
))
8172 /* `:help HELP-STRING'. */
8173 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8174 else if (EQ (key
, QCfilter
))
8175 /* ':filter FORM'. */
8177 else if (EQ (key
, QCbutton
) && CONSP (value
))
8179 /* `:button (TYPE . SELECTED)'. */
8180 Lisp_Object type
, selected
;
8182 type
= XCAR (value
);
8183 selected
= XCDR (value
);
8184 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8186 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8187 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8190 else if (EQ (key
, QCimage
)
8192 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8193 /* Value is either a single image specification or a vector
8194 of 4 such specifications for the different button states. */
8195 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8198 /* If got a filter apply it on binding. */
8200 PROP (TOOL_BAR_ITEM_BINDING
)
8201 = menu_item_eval_property (list2 (filter
,
8203 PROP (TOOL_BAR_ITEM_BINDING
))));
8205 /* See if the binding is a keymap. Give up if it is. */
8206 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8209 /* Enable or disable selection of item. */
8210 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8211 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8212 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8214 /* Handle radio buttons or toggle boxes. */
8215 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8216 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8217 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8225 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8226 that can be reused. */
8229 init_tool_bar_items (reuse
)
8232 if (VECTORP (reuse
))
8233 tool_bar_items_vector
= reuse
;
8235 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8236 ntool_bar_items
= 0;
8240 /* Append parsed tool bar item properties from
8241 tool_bar_item_properties */
8244 append_tool_bar_item ()
8246 Lisp_Object
*to
, *from
;
8248 /* Enlarge tool_bar_items_vector if necessary. */
8249 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8250 >= XVECTOR (tool_bar_items_vector
)->size
)
8252 Lisp_Object new_vector
;
8253 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
8255 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
8256 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
8257 XVECTOR (new_vector
)->contents
,
8258 old_size
* sizeof (Lisp_Object
));
8259 tool_bar_items_vector
= new_vector
;
8262 /* Append entries from tool_bar_item_properties to the end of
8263 tool_bar_items_vector. */
8264 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8265 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8266 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8267 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8274 /* Read a character using menus based on maps in the array MAPS.
8275 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8276 Return t if we displayed a menu but the user rejected it.
8278 PREV_EVENT is the previous input event, or nil if we are reading
8279 the first event of a key sequence.
8281 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8282 if we used a mouse menu to read the input, or zero otherwise. If
8283 USED_MOUSE_MENU is null, we don't dereference it.
8285 The prompting is done based on the prompt-string of the map
8286 and the strings associated with various map elements.
8288 This can be done with X menus or with menus put in the minibuf.
8289 These are done in different ways, depending on how the input will be read.
8290 Menus using X are done after auto-saving in read-char, getting the input
8291 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8292 and do auto-saving in the inner call of read_char. */
8295 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
8298 Lisp_Object prev_event
;
8299 int *used_mouse_menu
;
8302 register Lisp_Object name
= Qnil
;
8304 if (used_mouse_menu
)
8305 *used_mouse_menu
= 0;
8307 /* Use local over global Menu maps */
8309 if (! menu_prompting
)
8312 /* Optionally disregard all but the global map. */
8313 if (inhibit_local_menu_bar_menus
)
8315 maps
+= (nmaps
- 1);
8319 /* Get the menu name from the first map that has one (a prompt string). */
8320 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8322 name
= Fkeymap_prompt (maps
[mapno
]);
8327 /* If we don't have any menus, just read a character normally. */
8328 if (!STRINGP (name
))
8332 /* If we got to this point via a mouse click,
8333 use a real menu for mouse selection. */
8334 if (EVENT_HAS_PARAMETERS (prev_event
)
8335 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8336 && !EQ (XCAR (prev_event
), Qtool_bar
))
8338 /* Display the menu and get the selection. */
8339 Lisp_Object
*realmaps
8340 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8344 /* Use the maps that are not nil. */
8345 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8346 if (!NILP (maps
[mapno
]))
8347 realmaps
[nmaps1
++] = maps
[mapno
];
8349 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8354 record_menu_key (XCAR (value
));
8356 /* If we got multiple events, unread all but
8358 There is no way to prevent those unread events
8359 from showing up later in last_nonmenu_event.
8360 So turn symbol and integer events into lists,
8361 to indicate that they came from a mouse menu,
8362 so that when present in last_nonmenu_event
8363 they won't confuse things. */
8364 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
8366 record_menu_key (XCAR (tem
));
8367 if (SYMBOLP (XCAR (tem
))
8368 || INTEGERP (XCAR (tem
)))
8369 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8372 /* If we got more than one event, put all but the first
8373 onto this list to be read later.
8374 Return just the first event now. */
8375 Vunread_command_events
8376 = nconc2 (XCDR (value
), Vunread_command_events
);
8377 value
= XCAR (value
);
8379 else if (NILP (value
))
8381 if (used_mouse_menu
)
8382 *used_mouse_menu
= 1;
8385 #endif /* HAVE_MENUS */
8389 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8390 We make this bigger when necessary, and never free it. */
8391 static char *read_char_minibuf_menu_text
;
8392 /* Size of that buffer. */
8393 static int read_char_minibuf_menu_width
;
8396 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8402 register Lisp_Object name
;
8404 /* FIXME: Use the minibuffer's frame width. */
8405 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8408 Lisp_Object rest
, vector
;
8414 if (! menu_prompting
)
8417 /* Make sure we have a big enough buffer for the menu text. */
8418 if (read_char_minibuf_menu_text
== 0)
8420 read_char_minibuf_menu_width
= width
+ 4;
8421 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8423 else if (width
+ 4 > read_char_minibuf_menu_width
)
8425 read_char_minibuf_menu_width
= width
+ 4;
8426 read_char_minibuf_menu_text
8427 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8429 menu
= read_char_minibuf_menu_text
;
8431 /* Get the menu name from the first map that has one (a prompt string). */
8432 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8434 name
= Fkeymap_prompt (maps
[mapno
]);
8439 /* If we don't have any menus, just read a character normally. */
8440 if (!STRINGP (name
))
8443 /* Prompt string always starts with map's prompt, and a space. */
8444 strcpy (menu
, SDATA (name
));
8445 nlength
= SBYTES (name
);
8446 menu
[nlength
++] = ':';
8447 menu
[nlength
++] = ' ';
8450 /* Start prompting at start of first map. */
8454 /* Present the documented bindings, a line at a time. */
8461 Lisp_Object orig_defn_macro
;
8463 /* Loop over elements of map. */
8468 /* If reached end of map, start at beginning of next map. */
8472 /* At end of last map, wrap around to first map if just starting,
8473 or end this line if already have something on it. */
8477 if (notfirst
|| nobindings
) break;
8482 /* Look at the next element of the map. */
8484 elt
= XVECTOR (vector
)->contents
[idx
];
8486 elt
= Fcar_safe (rest
);
8488 if (idx
< 0 && VECTORP (elt
))
8490 /* If we found a dense table in the keymap,
8491 advanced past it, but start scanning its contents. */
8492 rest
= Fcdr_safe (rest
);
8498 /* An ordinary element. */
8499 Lisp_Object event
, tem
;
8503 event
= Fcar_safe (elt
); /* alist */
8504 elt
= Fcdr_safe (elt
);
8508 XSETINT (event
, idx
); /* vector */
8511 /* Ignore the element if it has no prompt string. */
8512 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8514 /* 1 if the char to type matches the string. */
8516 Lisp_Object upcased_event
, downcased_event
;
8517 Lisp_Object desc
= Qnil
;
8519 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8521 upcased_event
= Fupcase (event
);
8522 downcased_event
= Fdowncase (event
);
8523 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8524 || XINT (downcased_event
) == SREF (s
, 0));
8526 desc
= Fsingle_key_description (event
, Qnil
);
8528 #if 0 /* It is redundant to list the equivalent key bindings because
8529 the prefix is what the user has already typed. */
8531 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8533 /* Insert equivalent keybinding. */
8534 s
= concat2 (s
, tem
);
8537 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8538 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8540 /* Insert button prefix. */
8541 Lisp_Object selected
8542 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8543 if (EQ (tem
, QCradio
))
8544 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8546 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8547 s
= concat2 (tem
, s
);
8551 /* If we have room for the prompt string, add it to this line.
8552 If this is the first on the line, always add it. */
8553 if ((SCHARS (s
) + i
+ 2
8554 + (char_matches
? 0 : SCHARS (desc
) + 3))
8560 /* Punctuate between strings. */
8563 strcpy (menu
+ i
, ", ");
8569 /* If the char to type doesn't match the string's
8570 first char, explicitly show what char to type. */
8573 /* Add as much of string as fits. */
8574 thiswidth
= SCHARS (desc
);
8575 if (thiswidth
+ i
> width
)
8576 thiswidth
= width
- i
;
8577 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8579 strcpy (menu
+ i
, " = ");
8583 /* Add as much of string as fits. */
8584 thiswidth
= SCHARS (s
);
8585 if (thiswidth
+ i
> width
)
8586 thiswidth
= width
- i
;
8587 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8593 /* If this element does not fit, end the line now,
8594 and save the element for the next line. */
8595 strcpy (menu
+ i
, "...");
8600 /* Move past this element. */
8601 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8602 /* Handle reaching end of dense table. */
8607 rest
= Fcdr_safe (rest
);
8611 /* Prompt with that and read response. */
8612 message2_nolog (menu
, strlen (menu
),
8613 ! NILP (current_buffer
->enable_multibyte_characters
));
8615 /* Make believe its not a keyboard macro in case the help char
8616 is pressed. Help characters are not recorded because menu prompting
8617 is not used on replay.
8619 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8620 current_kboard
->defining_kbd_macro
= Qnil
;
8622 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8623 while (BUFFERP (obj
));
8624 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8626 if (!INTEGERP (obj
))
8631 if (! EQ (obj
, menu_prompt_more_char
)
8632 && (!INTEGERP (menu_prompt_more_char
)
8633 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8635 if (!NILP (current_kboard
->defining_kbd_macro
))
8636 store_kbd_macro_char (obj
);
8639 /* Help char - go round again */
8643 /* Reading key sequences. */
8645 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8646 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8647 keymap, or nil otherwise. Return the index of the first keymap in
8648 which KEY has any binding, or NMAPS if no map has a binding.
8650 If KEY is a meta ASCII character, treat it like meta-prefix-char
8651 followed by the corresponding non-meta character. Keymaps in
8652 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8655 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8658 NEXT may be the same array as CURRENT. */
8661 follow_key (key
, nmaps
, current
, defs
, next
)
8663 Lisp_Object
*current
, *defs
, *next
;
8666 int i
, first_binding
;
8668 first_binding
= nmaps
;
8669 for (i
= nmaps
- 1; i
>= 0; i
--)
8671 if (! NILP (current
[i
]))
8673 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8674 if (! NILP (defs
[i
]))
8681 /* Given the set of bindings we've found, produce the next set of maps. */
8682 if (first_binding
< nmaps
)
8683 for (i
= 0; i
< nmaps
; i
++)
8684 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8686 return first_binding
;
8689 /* Structure used to keep track of partial application of key remapping
8690 such as Vfunction_key_map and Vkey_translation_map. */
8691 typedef struct keyremap
8693 /* This is the map originally specified for this use. */
8695 /* This is a submap reached by looking up, in PARENT,
8696 the events from START to END. */
8698 /* Positions [START, END) in the key sequence buffer
8699 are the key that we have scanned so far.
8700 Those events are the ones that we will replace
8701 if PAREHT maps them into a key sequence. */
8705 /* Lookup KEY in MAP.
8706 MAP is a keymap mapping keys to key vectors or functions.
8707 If the mapping is a function and DO_FUNCTION is non-zero, then
8708 the function is called with PROMPT as parameter and its return
8709 value is used as the return value of this function (after checking
8710 that it is indeed a vector). */
8713 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8714 Lisp_Object map
, key
, prompt
;
8719 next
= access_keymap (map
, key
, 1, 0, 1);
8721 /* Handle symbol with autoload definition. */
8722 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8723 && CONSP (XSYMBOL (next
)->function
)
8724 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8725 do_autoload (XSYMBOL (next
)->function
, next
);
8727 /* Handle a symbol whose function definition is a keymap
8729 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8730 && (ARRAYP (XSYMBOL (next
)->function
)
8731 || KEYMAPP (XSYMBOL (next
)->function
)))
8732 next
= XSYMBOL (next
)->function
;
8734 /* If the keymap gives a function, not an
8735 array, then call the function with one arg and use
8736 its value instead. */
8737 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8742 next
= call1 (next
, prompt
);
8743 /* If the function returned something invalid,
8744 barf--don't ignore it.
8745 (To ignore it safely, we would need to gcpro a bunch of
8746 other variables.) */
8747 if (! (VECTORP (next
) || STRINGP (next
)))
8748 error ("Function %s returns invalid key sequence", tem
);
8753 /* Do one step of the key remapping used for function-key-map and
8754 key-translation-map:
8755 KEYBUF is the buffer holding the input events.
8756 BUFSIZE is its maximum size.
8757 FKEY is a pointer to the keyremap structure to use.
8758 INPUT is the index of the last element in KEYBUF.
8759 DOIT if non-zero says that the remapping can actually take place.
8760 DIFF is used to return the number of keys added/removed by the remapping.
8761 PARENT is the root of the keymap.
8762 PROMPT is the prompt to use if the remapping happens through a function.
8763 The return value is non-zero if the remapping actually took place. */
8766 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
8767 Lisp_Object
*keybuf
, prompt
;
8769 int input
, doit
, *diff
, bufsize
;
8771 Lisp_Object next
, key
;
8773 key
= keybuf
[fkey
->end
++];
8775 if (KEYMAPP (fkey
->parent
))
8776 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8780 /* If keybuf[fkey->start..fkey->end] is bound in the
8781 map and we're in a position to do the key remapping, replace it with
8782 the binding and restart with fkey->start at the end. */
8783 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8785 int len
= XFASTINT (Flength (next
));
8788 *diff
= len
- (fkey
->end
- fkey
->start
);
8790 if (input
+ *diff
>= bufsize
)
8791 error ("Key sequence too long");
8793 /* Shift the keys that follow fkey->end. */
8795 for (i
= fkey
->end
; i
< input
; i
++)
8796 keybuf
[i
+ *diff
] = keybuf
[i
];
8798 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8799 keybuf
[i
+ *diff
] = keybuf
[i
];
8800 /* Overwrite the old keys with the new ones. */
8801 for (i
= 0; i
< len
; i
++)
8802 keybuf
[fkey
->start
+ i
]
8803 = Faref (next
, make_number (i
));
8805 fkey
->start
= fkey
->end
+= *diff
;
8806 fkey
->map
= fkey
->parent
;
8811 fkey
->map
= get_keymap (next
, 0, 1);
8813 /* If we no longer have a bound suffix, try a new position for
8815 if (!CONSP (fkey
->map
))
8817 fkey
->end
= ++fkey
->start
;
8818 fkey
->map
= fkey
->parent
;
8823 /* Read a sequence of keys that ends with a non prefix character,
8824 storing it in KEYBUF, a buffer of size BUFSIZE.
8826 Return the length of the key sequence stored.
8827 Return -1 if the user rejected a command menu.
8829 Echo starting immediately unless `prompt' is 0.
8831 Where a key sequence ends depends on the currently active keymaps.
8832 These include any minor mode keymaps active in the current buffer,
8833 the current buffer's local map, and the global map.
8835 If a key sequence has no other bindings, we check Vfunction_key_map
8836 to see if some trailing subsequence might be the beginning of a
8837 function key's sequence. If so, we try to read the whole function
8838 key, and substitute its symbolic name into the key sequence.
8840 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8841 `double-' events into similar click events, if that would make them
8842 bound. We try to turn `triple-' events first into `double-' events,
8845 If we get a mouse click in a mode line, vertical divider, or other
8846 non-text area, we treat the click as if it were prefixed by the
8847 symbol denoting that area - `mode-line', `vertical-line', or
8850 If the sequence starts with a mouse click, we read the key sequence
8851 with respect to the buffer clicked on, not the current buffer.
8853 If the user switches frames in the midst of a key sequence, we put
8854 off the switch-frame event until later; the next call to
8855 read_char will return it.
8857 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8858 from the selected window's buffer. */
8861 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
8862 can_return_switch_frame
, fix_current_buffer
)
8863 Lisp_Object
*keybuf
;
8866 int dont_downcase_last
;
8867 int can_return_switch_frame
;
8868 int fix_current_buffer
;
8870 volatile Lisp_Object from_string
;
8871 volatile int count
= SPECPDL_INDEX ();
8873 /* How many keys there are in the current key sequence. */
8876 /* The length of the echo buffer when we started reading, and
8877 the length of this_command_keys when we started reading. */
8878 volatile int echo_start
;
8879 volatile int keys_start
;
8881 /* The number of keymaps we're scanning right now, and the number of
8882 keymaps we have allocated space for. */
8884 volatile int nmaps_allocated
= 0;
8886 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8887 the current keymaps. */
8888 Lisp_Object
*volatile defs
= NULL
;
8890 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8891 in the current keymaps, or nil where it is not a prefix. */
8892 Lisp_Object
*volatile submaps
= NULL
;
8894 /* The local map to start out with at start of key sequence. */
8895 volatile Lisp_Object orig_local_map
;
8897 /* The map from the `keymap' property to start out with at start of
8899 volatile Lisp_Object orig_keymap
;
8901 /* 1 if we have already considered switching to the local-map property
8902 of the place where a mouse click occurred. */
8903 volatile int localized_local_map
= 0;
8905 /* The index in submaps[] of the first keymap that has a binding for
8906 this key sequence. In other words, the lowest i such that
8907 submaps[i] is non-nil. */
8908 volatile int first_binding
;
8909 /* Index of the first key that has no binding.
8910 It is useless to try fkey.start larger than that. */
8911 volatile int first_unbound
;
8913 /* If t < mock_input, then KEYBUF[t] should be read as the next
8916 We use this to recover after recognizing a function key. Once we
8917 realize that a suffix of the current key sequence is actually a
8918 function key's escape sequence, we replace the suffix with the
8919 function key's binding from Vfunction_key_map. Now keybuf
8920 contains a new and different key sequence, so the echo area,
8921 this_command_keys, and the submaps and defs arrays are wrong. In
8922 this situation, we set mock_input to t, set t to 0, and jump to
8923 restart_sequence; the loop will read keys from keybuf up until
8924 mock_input, thus rebuilding the state; and then it will resume
8925 reading characters from the keyboard. */
8926 volatile int mock_input
= 0;
8928 /* If the sequence is unbound in submaps[], then
8929 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8930 and fkey.map is its binding.
8932 These might be > t, indicating that all function key scanning
8933 should hold off until t reaches them. We do this when we've just
8934 recognized a function key, to avoid searching for the function
8935 key's again in Vfunction_key_map. */
8936 volatile keyremap fkey
;
8938 /* Likewise, for key_translation_map. */
8939 volatile keyremap keytran
;
8941 /* If we receive a `switch-frame' or `select-window' event in the middle of
8942 a key sequence, we put it off for later.
8943 While we're reading, we keep the event here. */
8944 volatile Lisp_Object delayed_switch_frame
;
8946 /* See the comment below... */
8947 #if defined (GOBBLE_FIRST_EVENT)
8948 Lisp_Object first_event
;
8951 volatile Lisp_Object original_uppercase
;
8952 volatile int original_uppercase_position
= -1;
8954 /* Gets around Microsoft compiler limitations. */
8957 struct buffer
*starting_buffer
;
8959 /* List of events for which a fake prefix key has been generated. */
8960 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
8962 #if defined (GOBBLE_FIRST_EVENT)
8966 struct gcpro gcpro1
;
8968 GCPRO1 (fake_prefixed_keys
);
8969 raw_keybuf_count
= 0;
8971 last_nonmenu_event
= Qnil
;
8973 delayed_switch_frame
= Qnil
;
8974 fkey
.map
= fkey
.parent
= Vfunction_key_map
;
8975 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
8976 fkey
.start
= fkey
.end
= 0;
8977 keytran
.start
= keytran
.end
= 0;
8982 echo_prompt (prompt
);
8983 else if (cursor_in_echo_area
8984 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8985 && NILP (Fzerop (Vecho_keystrokes
)))
8986 /* This doesn't put in a dash if the echo buffer is empty, so
8987 you don't always see a dash hanging out in the minibuffer. */
8991 /* Record the initial state of the echo area and this_command_keys;
8992 we will need to restore them if we replay a key sequence. */
8994 echo_start
= echo_length ();
8995 keys_start
= this_command_key_count
;
8996 this_single_command_key_start
= keys_start
;
8998 #if defined (GOBBLE_FIRST_EVENT)
8999 /* This doesn't quite work, because some of the things that read_char
9000 does cannot safely be bypassed. It seems too risky to try to make
9003 /* Read the first char of the sequence specially, before setting
9004 up any keymaps, in case a filter runs and switches buffers on us. */
9005 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9007 #endif /* GOBBLE_FIRST_EVENT */
9009 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9010 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9013 /* We jump here when the key sequence has been thoroughly changed, and
9014 we need to rescan it starting from the beginning. When we jump here,
9015 keybuf[0..mock_input] holds the sequence we should reread. */
9018 starting_buffer
= current_buffer
;
9019 first_unbound
= bufsize
+ 1;
9021 /* Build our list of keymaps.
9022 If we recognize a function key and replace its escape sequence in
9023 keybuf with its symbol, or if the sequence starts with a mouse
9024 click and we need to switch buffers, we jump back here to rebuild
9025 the initial keymaps from the current buffer. */
9028 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9030 if (2 > nmaps_allocated
)
9032 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9033 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9034 nmaps_allocated
= 2;
9036 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9037 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
9039 else if (!NILP (Voverriding_local_map
))
9041 if (2 > nmaps_allocated
)
9043 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9044 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9045 nmaps_allocated
= 2;
9047 if (!NILP (Voverriding_local_map
))
9048 submaps
[nmaps
++] = Voverriding_local_map
;
9056 nminor
= current_minor_maps (0, &maps
);
9057 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9059 if (total
> nmaps_allocated
)
9061 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9062 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9063 nmaps_allocated
= total
;
9066 if (!NILP (orig_keymap
))
9067 submaps
[nmaps
++] = orig_keymap
;
9069 bcopy (maps
, (void *) (submaps
+ nmaps
),
9070 nminor
* sizeof (submaps
[0]));
9074 submaps
[nmaps
++] = orig_local_map
;
9076 submaps
[nmaps
++] = current_global_map
;
9078 /* Find an accurate initial value for first_binding. */
9079 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9080 if (! NILP (submaps
[first_binding
]))
9083 /* Start from the beginning in keybuf. */
9086 /* These are no-ops the first time through, but if we restart, they
9087 revert the echo area and this_command_keys to their original state. */
9088 this_command_key_count
= keys_start
;
9089 if (INTERACTIVE
&& t
< mock_input
)
9090 echo_truncate (echo_start
);
9092 /* If the best binding for the current key sequence is a keymap, or
9093 we may be looking at a function key's escape sequence, keep on
9095 while (first_binding
< nmaps
9096 /* Keep reading as long as there's a prefix binding. */
9097 ? !NILP (submaps
[first_binding
])
9098 /* Don't return in the middle of a possible function key sequence,
9099 if the only bindings we found were via case conversion.
9100 Thus, if ESC O a has a function-key-map translation
9101 and ESC o has a binding, don't return after ESC O,
9102 so that we can translate ESC O plus the next character. */
9103 : (fkey
.start
< t
|| keytran
.start
< t
))
9106 int used_mouse_menu
= 0;
9108 /* Where the last real key started. If we need to throw away a
9109 key that has expanded into more than one element of keybuf
9110 (say, a mouse click on the mode line which is being treated
9111 as [mode-line (mouse-...)], then we backtrack to this point
9113 volatile int last_real_key_start
;
9115 /* These variables are analogous to echo_start and keys_start;
9116 while those allow us to restart the entire key sequence,
9117 echo_local_start and keys_local_start allow us to throw away
9119 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
9121 eassert (fkey
.end
== t
|| (fkey
.end
> t
&& fkey
.end
<= mock_input
));
9122 eassert (fkey
.start
<= fkey
.end
);
9123 eassert (keytran
.start
<= keytran
.end
);
9124 /* key-translation-map is applied *after* function-key-map. */
9125 eassert (keytran
.end
<= fkey
.start
);
9127 if (first_unbound
< fkey
.start
&& first_unbound
< keytran
.start
)
9128 { /* The prefix upto first_unbound has no binding and has
9129 no translation left to do either, so we know it's unbound.
9130 If we don't stop now, we risk staying here indefinitely
9131 (if the user keeps entering fkey or keytran prefixes
9132 like C-c ESC ESC ESC ESC ...) */
9134 for (i
= first_unbound
+ 1; i
< t
; i
++)
9135 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9136 mock_input
= t
- first_unbound
- 1;
9137 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9138 fkey
.map
= fkey
.parent
;
9139 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9140 keytran
.map
= keytran
.parent
;
9141 goto replay_sequence
;
9145 error ("Key sequence too long");
9148 echo_local_start
= echo_length ();
9149 keys_local_start
= this_command_key_count
;
9150 local_first_binding
= first_binding
;
9153 /* These are no-ops, unless we throw away a keystroke below and
9154 jumped back up to replay_key; in that case, these restore the
9155 variables to their original state, allowing us to replay the
9157 if (INTERACTIVE
&& t
< mock_input
)
9158 echo_truncate (echo_local_start
);
9159 this_command_key_count
= keys_local_start
;
9160 first_binding
= local_first_binding
;
9162 /* By default, assume each event is "real". */
9163 last_real_key_start
= t
;
9165 /* Does mock_input indicate that we are re-reading a key sequence? */
9169 add_command_key (key
);
9170 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9171 && NILP (Fzerop (Vecho_keystrokes
)))
9175 /* If not, we should actually read a character. */
9180 KBOARD
*interrupted_kboard
= current_kboard
;
9181 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9182 if (setjmp (wrong_kboard_jmpbuf
))
9184 if (!NILP (delayed_switch_frame
))
9186 interrupted_kboard
->kbd_queue
9187 = Fcons (delayed_switch_frame
,
9188 interrupted_kboard
->kbd_queue
);
9189 delayed_switch_frame
= Qnil
;
9192 interrupted_kboard
->kbd_queue
9193 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
9195 /* If the side queue is non-empty, ensure it begins with a
9196 switch-frame, so we'll replay it in the right context. */
9197 if (CONSP (interrupted_kboard
->kbd_queue
)
9198 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
9199 !(EVENT_HAS_PARAMETERS (key
)
9200 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9204 XSETFRAME (frame
, interrupted_frame
);
9205 interrupted_kboard
->kbd_queue
9206 = Fcons (make_lispy_switch_frame (frame
),
9207 interrupted_kboard
->kbd_queue
);
9210 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9211 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9212 goto replay_sequence
;
9215 key
= read_char (NILP (prompt
), nmaps
,
9216 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9217 &used_mouse_menu
, NULL
);
9220 /* read_char returns t when it shows a menu and the user rejects it.
9224 unbind_to (count
, Qnil
);
9229 /* read_char returns -1 at the end of a macro.
9230 Emacs 18 handles this by returning immediately with a
9231 zero, so that's what we'll do. */
9232 if (INTEGERP (key
) && XINT (key
) == -1)
9235 /* The Microsoft C compiler can't handle the goto that
9241 /* If the current buffer has been changed from under us, the
9242 keymap may have changed, so replay the sequence. */
9245 timer_resume_idle ();
9248 /* Reset the current buffer from the selected window
9249 in case something changed the former and not the latter.
9250 This is to be more consistent with the behavior
9251 of the command_loop_1. */
9252 if (fix_current_buffer
)
9254 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9256 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9257 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9260 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9261 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9262 goto replay_sequence
;
9265 /* If we have a quit that was typed in another frame, and
9266 quit_throw_to_read_char switched buffers,
9267 replay to get the right keymap. */
9269 && XINT (key
) == quit_char
9270 && current_buffer
!= starting_buffer
)
9273 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9277 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9278 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9279 goto replay_sequence
;
9284 if (EVENT_HAS_PARAMETERS (key
)
9285 /* Either a `switch-frame' or a `select-window' event. */
9286 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9288 /* If we're at the beginning of a key sequence, and the caller
9289 says it's okay, go ahead and return this event. If we're
9290 in the midst of a key sequence, delay it until the end. */
9291 if (t
> 0 || !can_return_switch_frame
)
9293 delayed_switch_frame
= key
;
9299 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9302 /* Clicks in non-text areas get prefixed by the symbol
9303 in their CHAR-ADDRESS field. For example, a click on
9304 the mode line is prefixed by the symbol `mode-line'.
9306 Furthermore, key sequences beginning with mouse clicks
9307 are read using the keymaps of the buffer clicked on, not
9308 the current buffer. So we may have to switch the buffer
9311 When we turn one event into two events, we must make sure
9312 that neither of the two looks like the original--so that,
9313 if we replay the events, they won't be expanded again.
9314 If not for this, such reexpansion could happen either here
9315 or when user programs play with this-command-keys. */
9316 if (EVENT_HAS_PARAMETERS (key
))
9321 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9322 if (EQ (kind
, Qmouse_click
))
9324 Lisp_Object window
, posn
;
9326 window
= POSN_WINDOW (EVENT_START (key
));
9327 posn
= POSN_POSN (EVENT_START (key
));
9330 || (!NILP (fake_prefixed_keys
)
9331 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9333 /* We're looking a second time at an event for which
9334 we generated a fake prefix key. Set
9335 last_real_key_start appropriately. */
9337 last_real_key_start
= t
- 1;
9340 /* Key sequences beginning with mouse clicks are
9341 read using the keymaps in the buffer clicked on,
9342 not the current buffer. If we're at the
9343 beginning of a key sequence, switch buffers. */
9344 if (last_real_key_start
== 0
9346 && BUFFERP (XWINDOW (window
)->buffer
)
9347 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9349 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9353 /* Arrange to go back to the original buffer once we're
9354 done reading the key sequence. Note that we can't
9355 use save_excursion_{save,restore} here, because they
9356 save point as well as the current buffer; we don't
9357 want to save point, because redisplay may change it,
9358 to accommodate a Fset_window_start or something. We
9359 don't want to do this at the top of the function,
9360 because we may get input from a subprocess which
9361 wants to change the selected window and stuff (say,
9363 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9365 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9367 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9368 orig_local_map
= get_local_map (PT
, current_buffer
,
9370 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9371 goto replay_sequence
;
9374 /* For a mouse click, get the local text-property keymap
9375 of the place clicked on, rather than point. */
9376 if (last_real_key_start
== 0
9377 && CONSP (XCDR (key
))
9378 && ! localized_local_map
)
9380 Lisp_Object map_here
, start
, pos
;
9382 localized_local_map
= 1;
9383 start
= EVENT_START (key
);
9385 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9387 pos
= POSN_BUFFER_POSN (start
);
9389 && XINT (pos
) >= BEGV
9390 && XINT (pos
) <= ZV
)
9392 map_here
= get_local_map (XINT (pos
),
9393 current_buffer
, Qlocal_map
);
9394 if (!EQ (map_here
, orig_local_map
))
9396 orig_local_map
= map_here
;
9397 ++localized_local_map
;
9400 map_here
= get_local_map (XINT (pos
),
9401 current_buffer
, Qkeymap
);
9402 if (!EQ (map_here
, orig_keymap
))
9404 orig_keymap
= map_here
;
9405 ++localized_local_map
;
9408 if (localized_local_map
> 1)
9413 goto replay_sequence
;
9419 /* Expand mode-line and scroll-bar events into two events:
9420 use posn as a fake prefix key. */
9422 && (NILP (fake_prefixed_keys
)
9423 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9425 if (t
+ 1 >= bufsize
)
9426 error ("Key sequence too long");
9429 keybuf
[t
+ 1] = key
;
9432 /* Record that a fake prefix key has been generated
9433 for KEY. Don't modify the event; this would
9434 prevent proper action when the event is pushed
9435 back into unread-command-events. */
9436 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9438 /* If on a mode line string with a local keymap,
9439 reconsider the key sequence with that keymap. */
9440 if (string
= POSN_STRING (EVENT_START (key
)),
9441 (CONSP (string
) && STRINGP (XCAR (string
))))
9443 Lisp_Object pos
, map
, map2
;
9445 pos
= XCDR (string
);
9446 string
= XCAR (string
);
9448 && XINT (pos
) < SCHARS (string
))
9450 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9452 orig_local_map
= map
;
9453 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9456 if (!NILP (map
) || !NILP (map2
))
9457 goto replay_sequence
;
9463 else if (NILP (from_string
)
9464 && (string
= POSN_STRING (EVENT_START (key
)),
9465 (CONSP (string
) && STRINGP (XCAR (string
)))))
9467 /* For a click on a string, i.e. overlay string or a
9468 string displayed via the `display' property,
9469 consider `local-map' and `keymap' properties of
9471 Lisp_Object pos
, map
, map2
;
9473 pos
= XCDR (string
);
9474 string
= XCAR (string
);
9476 && XINT (pos
) < SCHARS (string
))
9478 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9480 orig_local_map
= map
;
9481 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9485 if (!NILP (map
) || !NILP (map2
))
9487 from_string
= string
;
9490 goto replay_sequence
;
9495 else if (CONSP (XCDR (key
))
9496 && CONSP (EVENT_START (key
))
9497 && CONSP (XCDR (EVENT_START (key
))))
9501 posn
= POSN_POSN (EVENT_START (key
));
9502 /* Handle menu-bar events:
9503 insert the dummy prefix event `menu-bar'. */
9504 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9506 if (t
+ 1 >= bufsize
)
9507 error ("Key sequence too long");
9511 /* Zap the position in key, so we know that we've
9512 expanded it, and don't try to do so again. */
9513 POSN_SET_POSN (EVENT_START (key
),
9514 Fcons (posn
, Qnil
));
9517 goto replay_sequence
;
9519 else if (CONSP (posn
))
9521 /* We're looking at the second event of a
9522 sequence which we expanded before. Set
9523 last_real_key_start appropriately. */
9524 if (last_real_key_start
== t
&& t
> 0)
9525 last_real_key_start
= t
- 1;
9530 /* We have finally decided that KEY is something we might want
9532 first_binding
= (follow_key (key
,
9533 nmaps
- first_binding
,
9534 submaps
+ first_binding
,
9535 defs
+ first_binding
,
9536 submaps
+ first_binding
)
9539 /* If KEY wasn't bound, we'll try some fallbacks. */
9540 if (first_binding
< nmaps
)
9541 /* This is needed for the following scenario:
9542 event 0: a down-event that gets dropped by calling replay_key.
9543 event 1: some normal prefix like C-h.
9544 After event 0, first_unbound is 0, after event 1 fkey.start
9545 and keytran.start are both 1, so when we see that C-h is bound,
9546 we need to update first_unbound. */
9547 first_unbound
= max (t
+ 1, first_unbound
);
9552 /* Remember the position to put an upper bound on fkey.start. */
9553 first_unbound
= min (t
, first_unbound
);
9555 head
= EVENT_HEAD (key
);
9556 if (help_char_p (head
) && t
> 0)
9558 read_key_sequence_cmd
= Vprefix_help_command
;
9560 last_nonmenu_event
= key
;
9561 /* The Microsoft C compiler can't handle the goto that
9569 Lisp_Object breakdown
;
9572 breakdown
= parse_modifiers (head
);
9573 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9574 /* Attempt to reduce an unbound mouse event to a simpler
9575 event that is bound:
9576 Drags reduce to clicks.
9577 Double-clicks reduce to clicks.
9578 Triple-clicks reduce to double-clicks, then to clicks.
9579 Down-clicks are eliminated.
9580 Double-downs reduce to downs, then are eliminated.
9581 Triple-downs reduce to double-downs, then to downs,
9582 then are eliminated. */
9583 if (modifiers
& (down_modifier
| drag_modifier
9584 | double_modifier
| triple_modifier
))
9586 while (modifiers
& (down_modifier
| drag_modifier
9587 | double_modifier
| triple_modifier
))
9589 Lisp_Object new_head
, new_click
;
9590 if (modifiers
& triple_modifier
)
9591 modifiers
^= (double_modifier
| triple_modifier
);
9592 else if (modifiers
& double_modifier
)
9593 modifiers
&= ~double_modifier
;
9594 else if (modifiers
& drag_modifier
)
9595 modifiers
&= ~drag_modifier
;
9598 /* Dispose of this `down' event by simply jumping
9599 back to replay_key, to get another event.
9601 Note that if this event came from mock input,
9602 then just jumping back to replay_key will just
9603 hand it to us again. So we have to wipe out any
9606 We could delete keybuf[t] and shift everything
9607 after that to the left by one spot, but we'd also
9608 have to fix up any variable that points into
9609 keybuf, and shifting isn't really necessary
9612 Adding prefixes for non-textual mouse clicks
9613 creates two characters of mock input, and both
9614 must be thrown away. If we're only looking at
9615 the prefix now, we can just jump back to
9616 replay_key. On the other hand, if we've already
9617 processed the prefix, and now the actual click
9618 itself is giving us trouble, then we've lost the
9619 state of the keymaps we want to backtrack to, and
9620 we need to replay the whole sequence to rebuild
9623 Beyond that, only function key expansion could
9624 create more than two keys, but that should never
9625 generate mouse events, so it's okay to zero
9626 mock_input in that case too.
9628 FIXME: The above paragraph seems just plain
9629 wrong, if you consider things like
9630 xterm-mouse-mode. -stef
9632 Isn't this just the most wonderful code ever? */
9634 /* If mock_input > t + 1, the above simplification
9635 will actually end up dropping keys on the floor.
9636 This is probably OK for now, but even
9637 if mock_input <= t + 1, we need to adjust fkey
9639 Typical case [header-line down-mouse-N]:
9640 mock_input = 2, t = 1, fkey.end = 1,
9641 last_real_key_start = 0. */
9642 if (fkey
.end
> last_real_key_start
)
9644 fkey
.end
= fkey
.start
9645 = min (last_real_key_start
, fkey
.start
);
9646 fkey
.map
= fkey
.parent
;
9647 if (keytran
.end
> last_real_key_start
)
9649 keytran
.end
= keytran
.start
9650 = min (last_real_key_start
, keytran
.start
);
9651 keytran
.map
= keytran
.parent
;
9654 if (t
== last_real_key_start
)
9661 mock_input
= last_real_key_start
;
9662 goto replay_sequence
;
9667 = apply_modifiers (modifiers
, XCAR (breakdown
));
9669 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9671 /* Look for a binding for this new key. follow_key
9672 promises that it didn't munge submaps the
9673 last time we called it, since key was unbound. */
9675 = (follow_key (new_click
,
9676 nmaps
- local_first_binding
,
9677 submaps
+ local_first_binding
,
9678 defs
+ local_first_binding
,
9679 submaps
+ local_first_binding
)
9680 + local_first_binding
);
9682 /* If that click is bound, go for it. */
9683 if (first_binding
< nmaps
)
9688 /* Otherwise, we'll leave key set to the drag event. */
9695 /* Normally, last_nonmenu_event gets the previous key we read.
9696 But when a mouse popup menu is being used,
9697 we don't update last_nonmenu_event; it continues to hold the mouse
9698 event that preceded the first level of menu. */
9699 if (!used_mouse_menu
)
9700 last_nonmenu_event
= key
;
9702 /* Record what part of this_command_keys is the current key sequence. */
9703 this_single_command_key_start
= this_command_key_count
- t
;
9705 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
]))
9706 /* There is a binding and it's not a prefix.
9707 There is thus no function-key in this sequence.
9708 Moving fkey.start is important in this case to allow keytran.start
9709 to go over the sequence before we return (since we keep the
9710 invariant that keytran.end <= fkey.start). */
9713 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9716 /* If the sequence is unbound, see if we can hang a function key
9717 off the end of it. */
9718 /* Continue scan from fkey.end until we find a bound suffix. */
9719 while (fkey
.end
< t
)
9721 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9724 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9725 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9726 max (t
, mock_input
),
9727 /* If there's a binding (i.e.
9728 first_binding >= nmaps) we don't want
9729 to apply this function-key-mapping. */
9730 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9735 mock_input
= diff
+ max (t
, mock_input
);
9736 goto replay_sequence
;
9740 /* Look for this sequence in key-translation-map.
9741 Scan from keytran.end until we find a bound suffix. */
9742 while (keytran
.end
< fkey
.start
)
9744 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9747 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9748 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9753 mock_input
= diff
+ max (t
, mock_input
);
9754 /* Adjust the function-key-map counters. */
9758 goto replay_sequence
;
9762 /* If KEY is not defined in any of the keymaps,
9763 and cannot be part of a function key or translation,
9764 and is an upper case letter
9765 use the corresponding lower-case letter instead. */
9766 if (first_binding
>= nmaps
9767 && fkey
.start
>= t
&& keytran
.start
>= t
9769 && ((((XINT (key
) & 0x3ffff)
9770 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
9771 && UPPERCASEP (XINT (key
) & 0x3ffff))
9772 || (XINT (key
) & shift_modifier
)))
9774 Lisp_Object new_key
;
9776 original_uppercase
= key
;
9777 original_uppercase_position
= t
- 1;
9779 if (XINT (key
) & shift_modifier
)
9780 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9782 XSETINT (new_key
, (DOWNCASE (XINT (key
) & 0x3ffff)
9783 | (XINT (key
) & ~0x3ffff)));
9785 /* We have to do this unconditionally, regardless of whether
9786 the lower-case char is defined in the keymaps, because they
9787 might get translated through function-key-map. */
9788 keybuf
[t
- 1] = new_key
;
9789 mock_input
= max (t
, mock_input
);
9791 goto replay_sequence
;
9793 /* If KEY is not defined in any of the keymaps,
9794 and cannot be part of a function key or translation,
9795 and is a shifted function key,
9796 use the corresponding unshifted function key instead. */
9797 if (first_binding
>= nmaps
9798 && fkey
.start
>= t
&& keytran
.start
>= t
9801 Lisp_Object breakdown
;
9804 breakdown
= parse_modifiers (key
);
9805 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9806 if (modifiers
& shift_modifier
)
9808 Lisp_Object new_key
;
9810 original_uppercase
= key
;
9811 original_uppercase_position
= t
- 1;
9813 modifiers
&= ~shift_modifier
;
9814 new_key
= apply_modifiers (modifiers
,
9817 keybuf
[t
- 1] = new_key
;
9818 mock_input
= max (t
, mock_input
);
9819 fkey
.start
= fkey
.end
= 0;
9820 keytran
.start
= keytran
.end
= 0;
9822 goto replay_sequence
;
9828 read_key_sequence_cmd
= (first_binding
< nmaps
9829 ? defs
[first_binding
]
9832 unread_switch_frame
= delayed_switch_frame
;
9833 unbind_to (count
, Qnil
);
9835 /* Don't downcase the last character if the caller says don't.
9836 Don't downcase it if the result is undefined, either. */
9837 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9839 && t
- 1 == original_uppercase_position
)
9840 keybuf
[t
- 1] = original_uppercase
;
9842 /* Occasionally we fabricate events, perhaps by expanding something
9843 according to function-key-map, or by adding a prefix symbol to a
9844 mouse click in the scroll bar or modeline. In this cases, return
9845 the entire generated key sequence, even if we hit an unbound
9846 prefix or a definition before the end. This means that you will
9847 be able to push back the event properly, and also means that
9848 read-key-sequence will always return a logical unit.
9851 for (; t
< mock_input
; t
++)
9853 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9854 && NILP (Fzerop (Vecho_keystrokes
)))
9855 echo_char (keybuf
[t
]);
9856 add_command_key (keybuf
[t
]);
9865 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9866 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9867 The sequence is sufficient to specify a non-prefix command in the
9868 current local and global maps.
9870 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9871 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9872 as a continuation of the previous key.
9874 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9875 convert the last event to lower case. (Normally any upper case event
9876 is converted to lower case if the original event is undefined and the lower
9877 case equivalent is defined.) A non-nil value is appropriate for reading
9878 a key sequence to be defined.
9880 A C-g typed while in this function is treated like any other character,
9881 and `quit-flag' is not set.
9883 If the key sequence starts with a mouse click, then the sequence is read
9884 using the keymaps of the buffer of the window clicked in, not the buffer
9885 of the selected window as normal.
9887 `read-key-sequence' drops unbound button-down events, since you normally
9888 only care about the click or drag events which follow them. If a drag
9889 or multi-click event is unbound, but the corresponding click event would
9890 be bound, `read-key-sequence' turns the event into a click event at the
9891 drag's starting position. This means that you don't have to distinguish
9892 between click and drag, double, or triple events unless you want to.
9894 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9895 lines separating windows, and scroll bars with imaginary keys
9896 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9898 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9899 function will process a switch-frame event if the user switches frames
9900 before typing anything. If the user switches frames in the middle of a
9901 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9902 is nil, then the event will be put off until after the current key sequence.
9904 `read-key-sequence' checks `function-key-map' for function key
9905 sequences, where they wouldn't conflict with ordinary bindings. See
9906 `function-key-map' for more details.
9908 The optional fifth argument COMMAND-LOOP, if non-nil, means
9909 that this key sequence is being read by something that will
9910 read commands one after another. It should be nil if the caller
9911 will read just one key sequence. */)
9912 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9914 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9915 Lisp_Object can_return_switch_frame
, command_loop
;
9917 Lisp_Object keybuf
[30];
9919 struct gcpro gcpro1
;
9920 int count
= SPECPDL_INDEX ();
9923 CHECK_STRING (prompt
);
9926 specbind (Qinput_method_exit_on_first_char
,
9927 (NILP (command_loop
) ? Qt
: Qnil
));
9928 specbind (Qinput_method_use_echo_area
,
9929 (NILP (command_loop
) ? Qt
: Qnil
));
9931 bzero (keybuf
, sizeof keybuf
);
9933 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9935 if (NILP (continue_echo
))
9937 this_command_key_count
= 0;
9938 this_command_key_count_reset
= 0;
9939 this_single_command_key_start
= 0;
9942 #ifdef HAVE_X_WINDOWS
9943 if (display_hourglass_p
)
9944 cancel_hourglass ();
9947 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9948 prompt
, ! NILP (dont_downcase_last
),
9949 ! NILP (can_return_switch_frame
), 0);
9951 #if 0 /* The following is fine for code reading a key sequence and
9952 then proceeding with a lenghty computation, but it's not good
9953 for code reading keys in a loop, like an input method. */
9954 #ifdef HAVE_X_WINDOWS
9955 if (display_hourglass_p
)
9966 return unbind_to (count
, make_event_array (i
, keybuf
));
9969 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
9970 Sread_key_sequence_vector
, 1, 5, 0,
9971 doc
: /* Like `read-key-sequence' but always return a vector. */)
9972 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9974 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9975 Lisp_Object can_return_switch_frame
, command_loop
;
9977 Lisp_Object keybuf
[30];
9979 struct gcpro gcpro1
;
9980 int count
= SPECPDL_INDEX ();
9983 CHECK_STRING (prompt
);
9986 specbind (Qinput_method_exit_on_first_char
,
9987 (NILP (command_loop
) ? Qt
: Qnil
));
9988 specbind (Qinput_method_use_echo_area
,
9989 (NILP (command_loop
) ? Qt
: Qnil
));
9991 bzero (keybuf
, sizeof keybuf
);
9993 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9995 if (NILP (continue_echo
))
9997 this_command_key_count
= 0;
9998 this_command_key_count_reset
= 0;
9999 this_single_command_key_start
= 0;
10002 #ifdef HAVE_X_WINDOWS
10003 if (display_hourglass_p
)
10004 cancel_hourglass ();
10007 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10008 prompt
, ! NILP (dont_downcase_last
),
10009 ! NILP (can_return_switch_frame
), 0);
10011 #ifdef HAVE_X_WINDOWS
10012 if (display_hourglass_p
)
10013 start_hourglass ();
10022 return unbind_to (count
, Fvector (i
, keybuf
));
10025 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10026 doc
: /* Execute CMD as an editor command.
10027 CMD must be a symbol that satisfies the `commandp' predicate.
10028 Optional second arg RECORD-FLAG non-nil
10029 means unconditionally put this command in `command-history'.
10030 Otherwise, that is done only if an arg is read using the minibuffer.
10031 The argument KEYS specifies the value to use instead of (this-command-keys)
10032 when reading the arguments; if it is nil, (this-command-keys) is used.
10033 The argument SPECIAL, if non-nil, means that this command is executing
10034 a special event, so ignore the prefix argument and don't clear it. */)
10035 (cmd
, record_flag
, keys
, special
)
10036 Lisp_Object cmd
, record_flag
, keys
, special
;
10038 register Lisp_Object final
;
10039 register Lisp_Object tem
;
10040 Lisp_Object prefixarg
;
10041 struct backtrace backtrace
;
10042 extern int debug_on_next_call
;
10044 debug_on_next_call
= 0;
10046 if (NILP (special
))
10048 prefixarg
= current_kboard
->Vprefix_arg
;
10049 Vcurrent_prefix_arg
= prefixarg
;
10050 current_kboard
->Vprefix_arg
= Qnil
;
10057 tem
= Fget (cmd
, Qdisabled
);
10058 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10060 tem
= Fsymbol_value (Qdisabled_command_function
);
10062 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10068 final
= Findirect_function (cmd
, Qnil
);
10070 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10072 struct gcpro gcpro1
, gcpro2
;
10074 GCPRO2 (cmd
, prefixarg
);
10075 do_autoload (final
, cmd
);
10082 if (STRINGP (final
) || VECTORP (final
))
10084 /* If requested, place the macro in the command history. For
10085 other sorts of commands, call-interactively takes care of
10087 if (!NILP (record_flag
))
10090 = Fcons (Fcons (Qexecute_kbd_macro
,
10091 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10094 /* Don't keep command history around forever. */
10095 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10097 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10099 XSETCDR (tem
, Qnil
);
10103 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10106 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10108 backtrace
.next
= backtrace_list
;
10109 backtrace_list
= &backtrace
;
10110 backtrace
.function
= &Qcall_interactively
;
10111 backtrace
.args
= &cmd
;
10112 backtrace
.nargs
= 1;
10113 backtrace
.evalargs
= 0;
10114 backtrace
.debug_on_exit
= 0;
10116 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
10118 backtrace_list
= backtrace
.next
;
10126 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10128 doc
: /* Read function name, then read its arguments and call it.
10130 To pass a numeric argument to the command you are invoking with, specify
10131 the numeric argument to this command.
10133 Noninteractively, the argument PREFIXARG is the prefix argument to
10134 give to the command you invoke, if it asks for an argument. */)
10136 Lisp_Object prefixarg
;
10138 Lisp_Object function
;
10140 int saved_last_point_position
;
10141 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10142 Lisp_Object bindings
, value
;
10143 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10144 #ifdef HAVE_X_WINDOWS
10145 /* The call to Fcompleting_read wil start and cancel the hourglass,
10146 but if the hourglass was already scheduled, this means that no
10147 hourglass will be shown for the actual M-x command itself.
10148 So we restart it if it is already scheduled. Note that checking
10149 hourglass_shown_p is not enough, normally the hourglass is not shown,
10150 just scheduled to be shown. */
10151 int hstarted
= hourglass_started ();
10154 saved_keys
= Fvector (this_command_key_count
,
10155 XVECTOR (this_command_keys
)->contents
);
10156 saved_last_point_position_buffer
= last_point_position_buffer
;
10157 saved_last_point_position
= last_point_position
;
10159 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10161 if (EQ (prefixarg
, Qminus
))
10162 strcpy (buf
, "- ");
10163 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
10164 strcpy (buf
, "C-u ");
10165 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
10166 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
10167 else if (INTEGERP (prefixarg
))
10168 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
10170 /* This isn't strictly correct if execute-extended-command
10171 is bound to anything else. Perhaps it should use
10172 this_command_keys? */
10173 strcat (buf
, "M-x ");
10175 /* Prompt with buf, and then read a string, completing from and
10176 restricting to the set of all defined commands. Don't provide
10177 any initial input. Save the command read on the extended-command
10179 function
= Fcompleting_read (build_string (buf
),
10180 Vobarray
, Qcommandp
,
10181 Qt
, Qnil
, Qextended_command_history
, Qnil
,
10184 #ifdef HAVE_X_WINDOWS
10185 if (hstarted
) start_hourglass ();
10188 if (STRINGP (function
) && SCHARS (function
) == 0)
10189 error ("No command name given");
10191 /* Set this_command_keys to the concatenation of saved_keys and
10192 function, followed by a RET. */
10197 this_command_key_count
= 0;
10198 this_command_key_count_reset
= 0;
10199 this_single_command_key_start
= 0;
10201 keys
= XVECTOR (saved_keys
)->contents
;
10202 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10203 add_command_key (keys
[i
]);
10205 for (i
= 0; i
< SCHARS (function
); i
++)
10206 add_command_key (Faref (function
, make_number (i
)));
10208 add_command_key (make_number ('\015'));
10211 last_point_position
= saved_last_point_position
;
10212 last_point_position_buffer
= saved_last_point_position_buffer
;
10216 function
= Fintern (function
, Qnil
);
10217 current_kboard
->Vprefix_arg
= prefixarg
;
10218 Vthis_command
= function
;
10219 real_this_command
= function
;
10221 /* If enabled, show which key runs this command. */
10222 if (!NILP (Vsuggest_key_bindings
)
10223 && NILP (Vexecuting_kbd_macro
)
10224 && SYMBOLP (function
))
10225 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10231 GCPRO2 (bindings
, value
);
10232 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10234 /* If the command has a key binding, print it now. */
10235 if (!NILP (bindings
)
10236 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10239 /* But first wait, and skip the message if there is input. */
10240 Lisp_Object waited
;
10242 /* If this command displayed something in the echo area;
10243 wait a few seconds, then display our suggestion message. */
10244 if (NILP (echo_area_buffer
[0]))
10245 waited
= sit_for (make_number (0), 0, 2);
10246 else if (NUMBERP (Vsuggest_key_bindings
))
10247 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10249 waited
= sit_for (make_number (2), 0, 2);
10251 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10253 Lisp_Object binding
;
10255 int message_p
= push_message ();
10256 int count
= SPECPDL_INDEX ();
10258 record_unwind_protect (pop_message_unwind
, Qnil
);
10259 binding
= Fkey_description (bindings
, Qnil
);
10262 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10265 sprintf (newmessage
, "You can run the command `%s' with %s",
10266 SDATA (SYMBOL_NAME (function
)),
10268 message2_nolog (newmessage
,
10269 strlen (newmessage
),
10270 STRING_MULTIBYTE (binding
));
10271 if (NUMBERP (Vsuggest_key_bindings
))
10272 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10274 waited
= sit_for (make_number (2), 0, 2);
10276 if (!NILP (waited
) && message_p
)
10277 restore_message ();
10279 unbind_to (count
, Qnil
);
10283 RETURN_UNGCPRO (value
);
10287 /* Return nonzero if input events are pending. */
10290 detect_input_pending ()
10292 if (!input_pending
)
10293 get_input_pending (&input_pending
, 0);
10295 return input_pending
;
10298 /* Return nonzero if input events other than mouse movements are
10302 detect_input_pending_ignore_squeezables ()
10304 if (!input_pending
)
10305 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10307 return input_pending
;
10310 /* Return nonzero if input events are pending, and run any pending timers. */
10313 detect_input_pending_run_timers (do_display
)
10316 int old_timers_run
= timers_run
;
10318 if (!input_pending
)
10319 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10321 if (old_timers_run
!= timers_run
&& do_display
)
10323 redisplay_preserve_echo_area (8);
10324 /* The following fixes a bug when using lazy-lock with
10325 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10326 from an idle timer function. The symptom of the bug is that
10327 the cursor sometimes doesn't become visible until the next X
10328 event is processed. --gerd. */
10330 rif
->flush_display (NULL
);
10333 return input_pending
;
10336 /* This is called in some cases before a possible quit.
10337 It cases the next call to detect_input_pending to recompute input_pending.
10338 So calling this function unnecessarily can't do any harm. */
10341 clear_input_pending ()
10346 /* Return nonzero if there are pending requeued events.
10347 This isn't used yet. The hope is to make wait_reading_process_output
10348 call it, and return if it runs Lisp code that unreads something.
10349 The problem is, kbd_buffer_get_event needs to be fixed to know what
10350 to do in that case. It isn't trivial. */
10353 requeued_events_pending_p ()
10355 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10359 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10360 doc
: /* Return t if command input is currently available with no wait.
10361 Actually, the value is nil only if we can be sure that no input is available;
10362 if there is a doubt, the value is t. */)
10365 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10366 || !NILP (Vunread_post_input_method_events
)
10367 || !NILP (Vunread_input_method_events
))
10370 get_input_pending (&input_pending
,
10371 READABLE_EVENTS_DO_TIMERS_NOW
10372 | READABLE_EVENTS_FILTER_EVENTS
);
10373 return input_pending
> 0 ? Qt
: Qnil
;
10376 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10377 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10380 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10383 if (total_keys
< NUM_RECENT_KEYS
)
10384 return Fvector (total_keys
, keys
);
10387 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10388 bcopy (keys
+ recent_keys_index
,
10389 XVECTOR (val
)->contents
,
10390 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10392 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10393 recent_keys_index
* sizeof (Lisp_Object
));
10398 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10399 doc
: /* Return the key sequence that invoked this command.
10400 However, if the command has called `read-key-sequence', it returns
10401 the last key sequence that has been read.
10402 The value is a string or a vector.
10404 See also `this-command-keys-vector'. */)
10407 return make_event_array (this_command_key_count
,
10408 XVECTOR (this_command_keys
)->contents
);
10411 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10412 doc
: /* Return the key sequence that invoked this command, as a vector.
10413 However, if the command has called `read-key-sequence', it returns
10414 the last key sequence that has been read.
10416 See also `this-command-keys'. */)
10419 return Fvector (this_command_key_count
,
10420 XVECTOR (this_command_keys
)->contents
);
10423 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10424 Sthis_single_command_keys
, 0, 0, 0,
10425 doc
: /* Return the key sequence that invoked this command.
10426 More generally, it returns the last key sequence read, either by
10427 the command loop or by `read-key-sequence'.
10428 Unlike `this-command-keys', this function's value
10429 does not include prefix arguments.
10430 The value is always a vector. */)
10433 return Fvector (this_command_key_count
10434 - this_single_command_key_start
,
10435 (XVECTOR (this_command_keys
)->contents
10436 + this_single_command_key_start
));
10439 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10440 Sthis_single_command_raw_keys
, 0, 0, 0,
10441 doc
: /* Return the raw events that were read for this command.
10442 More generally, it returns the last key sequence read, either by
10443 the command loop or by `read-key-sequence'.
10444 Unlike `this-single-command-keys', this function's value
10445 shows the events before all translations (except for input methods).
10446 The value is always a vector. */)
10449 return Fvector (raw_keybuf_count
,
10450 (XVECTOR (raw_keybuf
)->contents
));
10453 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10454 Sreset_this_command_lengths
, 0, 0, 0,
10455 doc
: /* Make the unread events replace the last command and echo.
10456 Used in `universal-argument-other-key'.
10458 `universal-argument-other-key' rereads the event just typed.
10459 It then gets translated through `function-key-map'.
10460 The translated event has to replace the real events,
10461 both in the value of (this-command-keys) and in echoing.
10462 To achieve this, `universal-argument-other-key' calls
10463 `reset-this-command-lengths', which discards the record of reading
10464 these events the first time. */)
10467 this_command_key_count
= before_command_key_count
;
10468 if (this_command_key_count
< this_single_command_key_start
)
10469 this_single_command_key_start
= this_command_key_count
;
10471 echo_truncate (before_command_echo_length
);
10473 /* Cause whatever we put into unread-command-events
10474 to echo as if it were being freshly read from the keyboard. */
10475 this_command_key_count_reset
= 1;
10480 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10481 Sclear_this_command_keys
, 0, 1, 0,
10482 doc
: /* Clear out the vector that `this-command-keys' returns.
10483 Also clear the record of the last 100 events, unless optional arg
10484 KEEP-RECORD is non-nil. */)
10486 Lisp_Object keep_record
;
10490 this_command_key_count
= 0;
10491 this_command_key_count_reset
= 0;
10493 if (NILP (keep_record
))
10495 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10496 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10498 recent_keys_index
= 0;
10503 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10504 doc
: /* Return the current depth in recursive edits. */)
10508 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10512 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10513 "FOpen dribble file: ",
10514 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10515 If FILE is nil, close any open dribble file. */)
10528 file
= Fexpand_file_name (file
, Qnil
);
10529 dribble
= fopen (SDATA (file
), "w");
10531 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10536 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10537 doc
: /* Discard the contents of the terminal input buffer.
10538 Also end any kbd macro being defined. */)
10541 if (!NILP (current_kboard
->defining_kbd_macro
))
10543 /* Discard the last command from the macro. */
10544 Fcancel_kbd_macro_events ();
10548 update_mode_lines
++;
10550 Vunread_command_events
= Qnil
;
10551 unread_command_char
= -1;
10553 discard_tty_input ();
10555 kbd_fetch_ptr
= kbd_store_ptr
;
10561 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10562 doc
: /* Stop Emacs and return to superior process. You can resume later.
10563 If `cannot-suspend' is non-nil, or if the system doesn't support job
10564 control, run a subshell instead.
10566 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10567 to be read as terminal input by Emacs's parent, after suspension.
10569 Before suspending, run the normal hook `suspend-hook'.
10570 After resumption run the normal hook `suspend-resume-hook'.
10572 Some operating systems cannot stop the Emacs process and resume it later.
10573 On such systems, Emacs starts a subshell instead of suspending. */)
10575 Lisp_Object stuffstring
;
10577 int count
= SPECPDL_INDEX ();
10578 int old_height
, old_width
;
10580 struct gcpro gcpro1
;
10582 if (!NILP (stuffstring
))
10583 CHECK_STRING (stuffstring
);
10585 /* Run the functions in suspend-hook. */
10586 if (!NILP (Vrun_hooks
))
10587 call1 (Vrun_hooks
, intern ("suspend-hook"));
10589 GCPRO1 (stuffstring
);
10590 get_frame_size (&old_width
, &old_height
);
10591 reset_sys_modes ();
10592 /* sys_suspend can get an error if it tries to fork a subshell
10593 and the system resources aren't available for that. */
10594 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_sys_modes
,
10596 stuff_buffered_input (stuffstring
);
10597 if (cannot_suspend
)
10601 unbind_to (count
, Qnil
);
10603 /* Check if terminal/window size has changed.
10604 Note that this is not useful when we are running directly
10605 with a window system; but suspend should be disabled in that case. */
10606 get_frame_size (&width
, &height
);
10607 if (width
!= old_width
|| height
!= old_height
)
10608 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10610 /* Run suspend-resume-hook. */
10611 if (!NILP (Vrun_hooks
))
10612 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10618 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10619 Then in any case stuff anything Emacs has read ahead and not used. */
10622 stuff_buffered_input (stuffstring
)
10623 Lisp_Object stuffstring
;
10625 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10626 register unsigned char *p
;
10628 if (STRINGP (stuffstring
))
10630 register int count
;
10632 p
= SDATA (stuffstring
);
10633 count
= SBYTES (stuffstring
);
10634 while (count
-- > 0)
10639 /* Anything we have read ahead, put back for the shell to read. */
10640 /* ?? What should this do when we have multiple keyboards??
10641 Should we ignore anything that was typed in at the "wrong" kboard?
10643 rms: we should stuff everything back into the kboard
10645 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10648 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10649 kbd_fetch_ptr
= kbd_buffer
;
10650 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10651 stuff_char (kbd_fetch_ptr
->code
);
10653 clear_event (kbd_fetch_ptr
);
10657 #endif /* SIGTSTP */
10661 set_waiting_for_input (time_to_clear
)
10662 EMACS_TIME
*time_to_clear
;
10664 input_available_clear_time
= time_to_clear
;
10666 /* Tell interrupt_signal to throw back to read_char, */
10667 waiting_for_input
= 1;
10669 /* If interrupt_signal was called before and buffered a C-g,
10670 make it run again now, to avoid timing error. */
10671 if (!NILP (Vquit_flag
))
10672 quit_throw_to_read_char ();
10676 clear_waiting_for_input ()
10678 /* Tell interrupt_signal not to throw back to read_char, */
10679 waiting_for_input
= 0;
10680 input_available_clear_time
= 0;
10683 /* This routine is called at interrupt level in response to C-g.
10685 If interrupt_input, this is the handler for SIGINT. Otherwise, it
10686 is called from kbd_buffer_store_event, in handling SIGIO or
10689 If `waiting_for_input' is non zero, then unless `echoing' is
10690 nonzero, immediately throw back to read_char.
10692 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10693 eval to throw, when it gets a chance. If quit-flag is already
10694 non-nil, it stops the job right away. */
10697 interrupt_signal (signalnum
) /* If we don't have an argument, */
10698 int signalnum
; /* some compilers complain in signal calls. */
10701 /* Must preserve main program's value of errno. */
10702 int old_errno
= errno
;
10703 struct frame
*sf
= SELECTED_FRAME ();
10705 #if defined (USG) && !defined (POSIX_SIGNALS)
10706 if (!read_socket_hook
&& NILP (Vwindow_system
))
10708 /* USG systems forget handlers when they are used;
10709 must reestablish each time */
10710 signal (SIGINT
, interrupt_signal
);
10711 signal (SIGQUIT
, interrupt_signal
);
10715 SIGNAL_THREAD_CHECK (signalnum
);
10718 if (!NILP (Vquit_flag
)
10719 && (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
)))
10721 /* If SIGINT isn't blocked, don't let us be interrupted by
10722 another SIGINT, it might be harmful due to non-reentrancy
10723 in I/O functions. */
10724 sigblock (sigmask (SIGINT
));
10727 reset_sys_modes ();
10729 #ifdef SIGTSTP /* Support possible in later USG versions */
10731 * On systems which can suspend the current process and return to the original
10732 * shell, this command causes the user to end up back at the shell.
10733 * The "Auto-save" and "Abort" questions are not asked until
10734 * the user elects to return to emacs, at which point he can save the current
10735 * job and either dump core or continue.
10740 if (sys_suspend () == -1)
10742 printf ("Not running as a subprocess;\n");
10743 printf ("you can continue or abort.\n");
10745 #else /* not VMS */
10746 /* Perhaps should really fork an inferior shell?
10747 But that would not provide any way to get back
10748 to the original shell, ever. */
10749 printf ("No support for stopping a process on this operating system;\n");
10750 printf ("you can continue or abort.\n");
10751 #endif /* not VMS */
10752 #endif /* not SIGTSTP */
10754 /* We must remain inside the screen area when the internal terminal
10755 is used. Note that [Enter] is not echoed by dos. */
10758 /* It doesn't work to autosave while GC is in progress;
10759 the code used for auto-saving doesn't cope with the mark bit. */
10760 if (!gc_in_progress
)
10762 printf ("Auto-save? (y or n) ");
10764 if (((c
= getchar ()) & ~040) == 'Y')
10766 Fdo_auto_save (Qt
, Qnil
);
10768 printf ("\r\nAuto-save done");
10769 #else /* not MSDOS */
10770 printf ("Auto-save done\n");
10771 #endif /* not MSDOS */
10773 while (c
!= '\n') c
= getchar ();
10777 /* During GC, it must be safe to reenable quitting again. */
10778 Vinhibit_quit
= Qnil
;
10781 #endif /* not MSDOS */
10782 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10783 printf ("but will instead do a real quit after garbage collection ends\r\n");
10788 printf ("\r\nAbort? (y or n) ");
10789 #else /* not MSDOS */
10791 printf ("Abort (and enter debugger)? (y or n) ");
10792 #else /* not VMS */
10793 printf ("Abort (and dump core)? (y or n) ");
10794 #endif /* not VMS */
10795 #endif /* not MSDOS */
10797 if (((c
= getchar ()) & ~040) == 'Y')
10799 while (c
!= '\n') c
= getchar ();
10801 printf ("\r\nContinuing...\r\n");
10802 #else /* not MSDOS */
10803 printf ("Continuing...\n");
10804 #endif /* not MSDOS */
10811 /* If executing a function that wants to be interrupted out of
10812 and the user has not deferred quitting by binding `inhibit-quit'
10813 then quit right away. */
10814 if (immediate_quit
&& NILP (Vinhibit_quit
))
10816 struct gl_state_s saved
;
10817 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10819 immediate_quit
= 0;
10822 GCPRO4 (saved
.object
, saved
.global_code
,
10823 saved
.current_syntax_table
, saved
.old_prop
);
10824 Fsignal (Qquit
, Qnil
);
10829 /* Else request quit when it's safe */
10833 if (waiting_for_input
&& !echoing
)
10834 quit_throw_to_read_char ();
10839 /* Handle a C-g by making read_char return C-g. */
10842 quit_throw_to_read_char ()
10845 /* Prevent another signal from doing this before we finish. */
10846 clear_waiting_for_input ();
10849 Vunread_command_events
= Qnil
;
10850 unread_command_char
= -1;
10852 #if 0 /* Currently, sit_for is called from read_char without turning
10853 off polling. And that can call set_waiting_for_input.
10854 It seems to be harmless. */
10855 #ifdef POLL_FOR_INPUT
10856 /* May be > 1 if in recursive minibuffer. */
10857 if (poll_suppress_count
== 0)
10861 if (FRAMEP (internal_last_event_frame
)
10862 && !EQ (internal_last_event_frame
, selected_frame
))
10863 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10866 _longjmp (getcjmp
, 1);
10869 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
10870 doc
: /* Set mode of reading keyboard input.
10871 First arg INTERRUPT non-nil means use input interrupts;
10872 nil means use CBREAK mode.
10873 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10874 (no effect except in CBREAK mode).
10875 Third arg META t means accept 8-bit input (for a Meta key).
10876 META nil means ignore the top bit, on the assumption it is parity.
10877 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10878 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10879 See also `current-input-mode'. */)
10880 (interrupt
, flow
, meta
, quit
)
10881 Lisp_Object interrupt
, flow
, meta
, quit
;
10884 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
10885 error ("set-input-mode: QUIT must be an ASCII character");
10887 #ifdef POLL_FOR_INPUT
10892 /* this causes startup screen to be restored and messes with the mouse */
10893 reset_sys_modes ();
10897 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10898 if (read_socket_hook
)
10900 /* When using X, don't give the user a real choice,
10901 because we haven't implemented the mechanisms to support it. */
10902 #ifdef NO_SOCK_SIGIO
10903 interrupt_input
= 0;
10904 #else /* not NO_SOCK_SIGIO */
10905 interrupt_input
= 1;
10906 #endif /* NO_SOCK_SIGIO */
10909 interrupt_input
= !NILP (interrupt
);
10910 #else /* not SIGIO */
10911 interrupt_input
= 0;
10912 #endif /* not SIGIO */
10914 /* Our VMS input only works by interrupts, as of now. */
10916 interrupt_input
= 1;
10919 flow_control
= !NILP (flow
);
10922 else if (EQ (meta
, Qt
))
10927 /* Don't let this value be out of range. */
10928 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
10934 #ifdef POLL_FOR_INPUT
10935 poll_suppress_count
= 1;
10941 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
10942 doc
: /* Return information about the way Emacs currently reads keyboard input.
10943 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10944 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10945 nil, Emacs is using CBREAK mode.
10946 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10947 terminal; this does not apply if Emacs uses interrupt-driven input.
10948 META is t if accepting 8-bit input with 8th bit as Meta flag.
10949 META nil means ignoring the top bit, on the assumption it is parity.
10950 META is neither t nor nil if accepting 8-bit input and using
10951 all 8 bits as the character code.
10952 QUIT is the character Emacs currently uses to quit.
10953 The elements of this list correspond to the arguments of
10954 `set-input-mode'. */)
10957 Lisp_Object val
[4];
10959 val
[0] = interrupt_input
? Qt
: Qnil
;
10960 val
[1] = flow_control
? Qt
: Qnil
;
10961 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
10962 XSETFASTINT (val
[3], quit_char
);
10964 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
10967 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
10968 doc
: /* Return position information for pixel coordinates X and Y.
10969 By default, X and Y are relative to text area of the selected window.
10970 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
10971 If optional fourth arg WHOLE is non-nil, X is relative to the left
10972 edge of the window.
10974 The return value is similar to a mouse click position:
10975 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
10976 IMAGE (DX . DY) (WIDTH . HEIGHT))
10977 The `posn-' functions access elements of such lists. */)
10978 (x
, y
, frame_or_window
, whole
)
10979 Lisp_Object x
, y
, frame_or_window
, whole
;
10984 if (NILP (frame_or_window
))
10985 frame_or_window
= selected_window
;
10987 if (WINDOWP (frame_or_window
))
10991 CHECK_LIVE_WINDOW (frame_or_window
);
10993 w
= XWINDOW (frame_or_window
);
10994 XSETINT (x
, (XINT (x
)
10995 + WINDOW_LEFT_EDGE_X (w
)
10997 ? window_box_left_offset (w
, TEXT_AREA
)
10999 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11000 frame_or_window
= w
->frame
;
11003 CHECK_LIVE_FRAME (frame_or_window
);
11005 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
11008 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11009 doc
: /* Return position information for buffer POS in WINDOW.
11010 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11012 Return nil if position is not visible in window. Otherwise,
11013 the return value is similar to that returned by `event-start' for
11014 a mouse click at the upper left corner of the glyph corresponding
11015 to the given buffer position:
11016 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11017 IMAGE (DX . DY) (WIDTH . HEIGHT))
11018 The `posn-' functions access elements of such lists. */)
11020 Lisp_Object pos
, window
;
11025 window
= selected_window
;
11027 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11030 Lisp_Object x
= XCAR (tem
);
11031 Lisp_Object y
= XCAR (XCDR (tem
));
11033 /* Point invisible due to hscrolling? */
11036 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11044 * Set up a new kboard object with reasonable initial values.
11050 kb
->Voverriding_terminal_local_map
= Qnil
;
11051 kb
->Vlast_command
= Qnil
;
11052 kb
->Vreal_last_command
= Qnil
;
11053 kb
->Vprefix_arg
= Qnil
;
11054 kb
->Vlast_prefix_arg
= Qnil
;
11055 kb
->kbd_queue
= Qnil
;
11056 kb
->kbd_queue_has_data
= 0;
11057 kb
->immediate_echo
= 0;
11058 kb
->echo_string
= Qnil
;
11059 kb
->echo_after_prompt
= -1;
11060 kb
->kbd_macro_buffer
= 0;
11061 kb
->kbd_macro_bufsize
= 0;
11062 kb
->defining_kbd_macro
= Qnil
;
11063 kb
->Vlast_kbd_macro
= Qnil
;
11064 kb
->reference_count
= 0;
11065 kb
->Vsystem_key_alist
= Qnil
;
11066 kb
->system_key_syms
= Qnil
;
11067 kb
->Vdefault_minibuffer_frame
= Qnil
;
11071 * Destroy the contents of a kboard object, but not the object itself.
11072 * We use this just before deleting it, or if we're going to initialize
11073 * it a second time.
11079 if (kb
->kbd_macro_buffer
)
11080 xfree (kb
->kbd_macro_buffer
);
11083 #ifdef MULTI_KBOARD
11085 /* Free KB and memory referenced from it. */
11093 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11096 *kbp
= kb
->next_kboard
;
11098 /* Prevent a dangling reference to KB. */
11099 if (kb
== current_kboard
11100 && FRAMEP (selected_frame
)
11101 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11103 current_kboard
= XFRAME (selected_frame
)->kboard
;
11104 if (current_kboard
== kb
)
11112 #endif /* MULTI_KBOARD */
11117 /* This is correct before outermost invocation of the editor loop */
11118 command_loop_level
= -1;
11119 immediate_quit
= 0;
11120 quit_char
= Ctl ('g');
11121 Vunread_command_events
= Qnil
;
11122 unread_command_char
= -1;
11123 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11125 recent_keys_index
= 0;
11126 kbd_fetch_ptr
= kbd_buffer
;
11127 kbd_store_ptr
= kbd_buffer
;
11128 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11129 do_mouse_tracking
= Qnil
;
11132 interrupt_input_blocked
= 0;
11133 interrupt_input_pending
= 0;
11135 /* This means that command_loop_1 won't try to select anything the first
11137 internal_last_event_frame
= Qnil
;
11138 Vlast_event_frame
= internal_last_event_frame
;
11140 #ifdef MULTI_KBOARD
11141 current_kboard
= initial_kboard
;
11143 wipe_kboard (current_kboard
);
11144 init_kboard (current_kboard
);
11146 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
11148 signal (SIGINT
, interrupt_signal
);
11149 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
11150 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11151 SIGQUIT and we can't tell which one it will give us. */
11152 signal (SIGQUIT
, interrupt_signal
);
11153 #endif /* HAVE_TERMIO */
11155 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11157 if (!noninteractive
)
11158 signal (SIGIO
, input_available_signal
);
11161 /* Use interrupt input by default, if it works and noninterrupt input
11162 has deficiencies. */
11164 #ifdef INTERRUPT_INPUT
11165 interrupt_input
= 1;
11167 interrupt_input
= 0;
11170 /* Our VMS input only works by interrupts, as of now. */
11172 interrupt_input
= 1;
11178 if (keyboard_init_hook
)
11179 (*keyboard_init_hook
) ();
11181 #ifdef POLL_FOR_INPUT
11182 poll_suppress_count
= 1;
11187 /* This type's only use is in syms_of_keyboard, to initialize the
11188 event header symbols and put properties on them. */
11189 struct event_head
{
11195 struct event_head head_table
[] = {
11196 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11197 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11198 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11199 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11200 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11201 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11202 /* `select-window' should be handled just like `switch-frame'
11203 in read_key_sequence. */
11204 {&Qselect_window
, "select-window", &Qswitch_frame
}
11208 syms_of_keyboard ()
11210 Vpre_help_message
= Qnil
;
11211 staticpro (&Vpre_help_message
);
11213 Vlispy_mouse_stem
= build_string ("mouse");
11214 staticpro (&Vlispy_mouse_stem
);
11217 QCimage
= intern (":image");
11218 staticpro (&QCimage
);
11220 staticpro (&Qhelp_echo
);
11221 Qhelp_echo
= intern ("help-echo");
11223 staticpro (&item_properties
);
11224 item_properties
= Qnil
;
11226 staticpro (&tool_bar_item_properties
);
11227 tool_bar_item_properties
= Qnil
;
11228 staticpro (&tool_bar_items_vector
);
11229 tool_bar_items_vector
= Qnil
;
11231 staticpro (&real_this_command
);
11232 real_this_command
= Qnil
;
11234 Qtimer_event_handler
= intern ("timer-event-handler");
11235 staticpro (&Qtimer_event_handler
);
11237 Qdisabled_command_function
= intern ("disabled-command-function");
11238 staticpro (&Qdisabled_command_function
);
11240 Qself_insert_command
= intern ("self-insert-command");
11241 staticpro (&Qself_insert_command
);
11243 Qforward_char
= intern ("forward-char");
11244 staticpro (&Qforward_char
);
11246 Qbackward_char
= intern ("backward-char");
11247 staticpro (&Qbackward_char
);
11249 Qdisabled
= intern ("disabled");
11250 staticpro (&Qdisabled
);
11252 Qundefined
= intern ("undefined");
11253 staticpro (&Qundefined
);
11255 Qpre_command_hook
= intern ("pre-command-hook");
11256 staticpro (&Qpre_command_hook
);
11258 Qpost_command_hook
= intern ("post-command-hook");
11259 staticpro (&Qpost_command_hook
);
11261 Qdeferred_action_function
= intern ("deferred-action-function");
11262 staticpro (&Qdeferred_action_function
);
11264 Qcommand_hook_internal
= intern ("command-hook-internal");
11265 staticpro (&Qcommand_hook_internal
);
11267 Qfunction_key
= intern ("function-key");
11268 staticpro (&Qfunction_key
);
11269 Qmouse_click
= intern ("mouse-click");
11270 staticpro (&Qmouse_click
);
11271 #if defined (WINDOWSNT) || defined (MAC_OS)
11272 Qlanguage_change
= intern ("language-change");
11273 staticpro (&Qlanguage_change
);
11275 Qdrag_n_drop
= intern ("drag-n-drop");
11276 staticpro (&Qdrag_n_drop
);
11278 Qsave_session
= intern ("save-session");
11279 staticpro (&Qsave_session
);
11282 Qmac_apple_event
= intern ("mac-apple-event");
11283 staticpro (&Qmac_apple_event
);
11286 Qmenu_enable
= intern ("menu-enable");
11287 staticpro (&Qmenu_enable
);
11288 Qmenu_alias
= intern ("menu-alias");
11289 staticpro (&Qmenu_alias
);
11290 QCenable
= intern (":enable");
11291 staticpro (&QCenable
);
11292 QCvisible
= intern (":visible");
11293 staticpro (&QCvisible
);
11294 QChelp
= intern (":help");
11295 staticpro (&QChelp
);
11296 QCfilter
= intern (":filter");
11297 staticpro (&QCfilter
);
11298 QCbutton
= intern (":button");
11299 staticpro (&QCbutton
);
11300 QCkeys
= intern (":keys");
11301 staticpro (&QCkeys
);
11302 QCkey_sequence
= intern (":key-sequence");
11303 staticpro (&QCkey_sequence
);
11304 QCtoggle
= intern (":toggle");
11305 staticpro (&QCtoggle
);
11306 QCradio
= intern (":radio");
11307 staticpro (&QCradio
);
11309 Qmode_line
= intern ("mode-line");
11310 staticpro (&Qmode_line
);
11311 Qvertical_line
= intern ("vertical-line");
11312 staticpro (&Qvertical_line
);
11313 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
11314 staticpro (&Qvertical_scroll_bar
);
11315 Qmenu_bar
= intern ("menu-bar");
11316 staticpro (&Qmenu_bar
);
11318 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11319 Qmouse_fixup_help_message
= intern ("mouse-fixup-help-message");
11320 staticpro (&Qmouse_fixup_help_message
);
11323 Qabove_handle
= intern ("above-handle");
11324 staticpro (&Qabove_handle
);
11325 Qhandle
= intern ("handle");
11326 staticpro (&Qhandle
);
11327 Qbelow_handle
= intern ("below-handle");
11328 staticpro (&Qbelow_handle
);
11329 Qup
= intern ("up");
11331 Qdown
= intern ("down");
11332 staticpro (&Qdown
);
11333 Qtop
= intern ("top");
11335 Qbottom
= intern ("bottom");
11336 staticpro (&Qbottom
);
11337 Qend_scroll
= intern ("end-scroll");
11338 staticpro (&Qend_scroll
);
11339 Qratio
= intern ("ratio");
11340 staticpro (&Qratio
);
11342 Qevent_kind
= intern ("event-kind");
11343 staticpro (&Qevent_kind
);
11344 Qevent_symbol_elements
= intern ("event-symbol-elements");
11345 staticpro (&Qevent_symbol_elements
);
11346 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
11347 staticpro (&Qevent_symbol_element_mask
);
11348 Qmodifier_cache
= intern ("modifier-cache");
11349 staticpro (&Qmodifier_cache
);
11351 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
11352 staticpro (&Qrecompute_lucid_menubar
);
11353 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
11354 staticpro (&Qactivate_menubar_hook
);
11356 Qpolling_period
= intern ("polling-period");
11357 staticpro (&Qpolling_period
);
11359 Qinput_method_function
= intern ("input-method-function");
11360 staticpro (&Qinput_method_function
);
11362 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
11363 staticpro (&Qinput_method_exit_on_first_char
);
11364 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
11365 staticpro (&Qinput_method_use_echo_area
);
11367 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11368 Fset (Qinput_method_use_echo_area
, Qnil
);
11370 last_point_position_buffer
= Qnil
;
11371 last_point_position_window
= Qnil
;
11374 struct event_head
*p
;
11376 for (p
= head_table
;
11377 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
11380 *p
->var
= intern (p
->name
);
11381 staticpro (p
->var
);
11382 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11383 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11387 button_down_location
= Fmake_vector (make_number (1), Qnil
);
11388 staticpro (&button_down_location
);
11389 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
11390 staticpro (&mouse_syms
);
11391 wheel_syms
= Fmake_vector (make_number (2), Qnil
);
11392 staticpro (&wheel_syms
);
11396 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11398 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11399 for (i
= 0; i
< len
; i
++)
11400 if (modifier_names
[i
])
11401 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
11402 staticpro (&modifier_symbols
);
11405 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11406 staticpro (&recent_keys
);
11408 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11409 staticpro (&this_command_keys
);
11411 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11412 staticpro (&raw_keybuf
);
11414 Qextended_command_history
= intern ("extended-command-history");
11415 Fset (Qextended_command_history
, Qnil
);
11416 staticpro (&Qextended_command_history
);
11418 accent_key_syms
= Qnil
;
11419 staticpro (&accent_key_syms
);
11421 func_key_syms
= Qnil
;
11422 staticpro (&func_key_syms
);
11424 drag_n_drop_syms
= Qnil
;
11425 staticpro (&drag_n_drop_syms
);
11427 unread_switch_frame
= Qnil
;
11428 staticpro (&unread_switch_frame
);
11430 internal_last_event_frame
= Qnil
;
11431 staticpro (&internal_last_event_frame
);
11433 read_key_sequence_cmd
= Qnil
;
11434 staticpro (&read_key_sequence_cmd
);
11436 menu_bar_one_keymap_changed_items
= Qnil
;
11437 staticpro (&menu_bar_one_keymap_changed_items
);
11439 menu_bar_items_vector
= Qnil
;
11440 staticpro (&menu_bar_items_vector
);
11442 help_form_saved_window_configs
= Qnil
;
11443 staticpro (&help_form_saved_window_configs
);
11445 defsubr (&Scurrent_idle_time
);
11446 defsubr (&Sevent_convert_list
);
11447 defsubr (&Sread_key_sequence
);
11448 defsubr (&Sread_key_sequence_vector
);
11449 defsubr (&Srecursive_edit
);
11450 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11451 defsubr (&Strack_mouse
);
11453 defsubr (&Sinput_pending_p
);
11454 defsubr (&Scommand_execute
);
11455 defsubr (&Srecent_keys
);
11456 defsubr (&Sthis_command_keys
);
11457 defsubr (&Sthis_command_keys_vector
);
11458 defsubr (&Sthis_single_command_keys
);
11459 defsubr (&Sthis_single_command_raw_keys
);
11460 defsubr (&Sreset_this_command_lengths
);
11461 defsubr (&Sclear_this_command_keys
);
11462 defsubr (&Ssuspend_emacs
);
11463 defsubr (&Sabort_recursive_edit
);
11464 defsubr (&Sexit_recursive_edit
);
11465 defsubr (&Srecursion_depth
);
11466 defsubr (&Stop_level
);
11467 defsubr (&Sdiscard_input
);
11468 defsubr (&Sopen_dribble_file
);
11469 defsubr (&Sset_input_mode
);
11470 defsubr (&Scurrent_input_mode
);
11471 defsubr (&Sexecute_extended_command
);
11472 defsubr (&Sposn_at_point
);
11473 defsubr (&Sposn_at_x_y
);
11475 DEFVAR_LISP ("last-command-char", &last_command_char
,
11476 doc
: /* Last input event that was part of a command. */);
11478 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
11479 doc
: /* Last input event that was part of a command. */);
11481 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11482 doc
: /* Last input event in a command, except for mouse menu events.
11483 Mouse menus give back keys that don't look like mouse events;
11484 this variable holds the actual mouse event that led to the menu,
11485 so that you can determine whether the command was run by mouse or not. */);
11487 DEFVAR_LISP ("last-input-char", &last_input_char
,
11488 doc
: /* Last input event. */);
11490 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
11491 doc
: /* Last input event. */);
11493 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11494 doc
: /* List of events to be read as the command input.
11495 These events are processed first, before actual keyboard input.
11496 Events read from this list are not normally added to `this-command-keys',
11497 as they will already have been added once as they were read for the first time.
11498 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11499 Vunread_command_events
= Qnil
;
11501 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11502 doc
: /* If not -1, an object to be read as next command input event. */);
11504 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11505 doc
: /* List of events to be processed as input by input methods.
11506 These events are processed before `unread-command-events'
11507 and actual keyboard input, but are not given to `input-method-function'. */);
11508 Vunread_post_input_method_events
= Qnil
;
11510 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
11511 doc
: /* List of events to be processed as input by input methods.
11512 These events are processed after `unread-command-events', but
11513 before actual keyboard input.
11514 If there's an active input method, the events are given to
11515 `input-method-function'. */);
11516 Vunread_input_method_events
= Qnil
;
11518 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
11519 doc
: /* Meta-prefix character code.
11520 Meta-foo as command input turns into this character followed by foo. */);
11521 XSETINT (meta_prefix_char
, 033);
11523 DEFVAR_KBOARD ("last-command", Vlast_command
,
11524 doc
: /* The last command executed.
11525 Normally a symbol with a function definition, but can be whatever was found
11526 in the keymap, or whatever the variable `this-command' was set to by that
11529 The value `mode-exit' is special; it means that the previous command
11530 read an event that told it to exit, and it did so and unread that event.
11531 In other words, the present command is the event that made the previous
11534 The value `kill-region' is special; it means that the previous command
11535 was a kill command. */);
11537 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11538 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11540 DEFVAR_LISP ("this-command", &Vthis_command
,
11541 doc
: /* The command now being executed.
11542 The command can set this variable; whatever is put here
11543 will be in `last-command' during the following command. */);
11544 Vthis_command
= Qnil
;
11546 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
11547 doc
: /* The command bound to the current key sequence before remapping.
11548 It equals `this-command' if the original command was not remapped through
11549 any of the active keymaps. Otherwise, the value of `this-command' is the
11550 result of looking up the original command in the active keymaps. */);
11551 Vthis_original_command
= Qnil
;
11553 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
11554 doc
: /* *Number of input events between auto-saves.
11555 Zero means disable autosaving due to number of characters typed. */);
11556 auto_save_interval
= 300;
11558 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
11559 doc
: /* *Number of seconds idle time before auto-save.
11560 Zero or nil means disable auto-saving due to idleness.
11561 After auto-saving due to this many seconds of idle time,
11562 Emacs also does a garbage collection if that seems to be warranted. */);
11563 XSETFASTINT (Vauto_save_timeout
, 30);
11565 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11566 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11567 The value may be integer or floating point. */);
11568 Vecho_keystrokes
= make_number (1);
11570 DEFVAR_INT ("polling-period", &polling_period
,
11571 doc
: /* *Interval between polling for input during Lisp execution.
11572 The reason for polling is to make C-g work to stop a running program.
11573 Polling is needed only when using X windows and SIGIO does not work.
11574 Polling is automatically disabled in all other cases. */);
11575 polling_period
= 2;
11577 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
11578 doc
: /* *Maximum time between mouse clicks to make a double-click.
11579 Measured in milliseconds. The value nil means disable double-click
11580 recognition; t means double-clicks have no time limit and are detected
11581 by position only. */);
11582 Vdouble_click_time
= make_number (500);
11584 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
11585 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11586 On window-system frames, value is the number of pixels the mouse may have
11587 moved horizontally or vertically between two clicks to make a double-click.
11588 On non window-system frames, value is interpreted in units of 1/8 characters
11591 This variable is also the threshold for motion of the mouse
11592 to count as a drag. */);
11593 double_click_fuzz
= 3;
11595 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
11596 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11597 inhibit_local_menu_bar_menus
= 0;
11599 DEFVAR_INT ("num-input-keys", &num_input_keys
,
11600 doc
: /* Number of complete key sequences read as input so far.
11601 This includes key sequences read from keyboard macros.
11602 The number is effectively the number of interactive command invocations. */);
11603 num_input_keys
= 0;
11605 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
11606 doc
: /* Number of input events read from the keyboard so far.
11607 This does not include events generated by keyboard macros. */);
11608 num_nonmacro_input_events
= 0;
11610 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
11611 doc
: /* The frame in which the most recently read event occurred.
11612 If the last event came from a keyboard macro, this is set to `macro'. */);
11613 Vlast_event_frame
= Qnil
;
11615 /* This variable is set up in sysdep.c. */
11616 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
11617 doc
: /* The ERASE character as set by the user with stty. */);
11619 DEFVAR_LISP ("help-char", &Vhelp_char
,
11620 doc
: /* Character to recognize as meaning Help.
11621 When it is read, do `(eval help-form)', and display result if it's a string.
11622 If the value of `help-form' is nil, this char can be read normally. */);
11623 XSETINT (Vhelp_char
, Ctl ('H'));
11625 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
11626 doc
: /* List of input events to recognize as meaning Help.
11627 These work just like the value of `help-char' (see that). */);
11628 Vhelp_event_list
= Qnil
;
11630 DEFVAR_LISP ("help-form", &Vhelp_form
,
11631 doc
: /* Form to execute when character `help-char' is read.
11632 If the form returns a string, that string is displayed.
11633 If `help-form' is nil, the help char is not recognized. */);
11636 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
11637 doc
: /* Command to run when `help-char' character follows a prefix key.
11638 This command is used only when there is no actual binding
11639 for that character after that prefix key. */);
11640 Vprefix_help_command
= Qnil
;
11642 DEFVAR_LISP ("top-level", &Vtop_level
,
11643 doc
: /* Form to evaluate when Emacs starts up.
11644 Useful to set before you dump a modified Emacs. */);
11647 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
11648 doc
: /* Translate table for keyboard input, or nil.
11649 If non-nil, the value should be a char-table. Each character read
11650 from the keyboard is looked up in this char-table. If the value found
11651 there is non-nil, then it is used instead of the actual input character.
11653 The value can also be a string or vector, but this is considered obsolete.
11654 If it is a string or vector of length N, character codes N and up are left
11655 untranslated. In a vector, an element which is nil means "no translation".
11657 This is applied to the characters supplied to input methods, not their
11658 output. See also `translation-table-for-input'. */);
11659 Vkeyboard_translate_table
= Qnil
;
11661 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
11662 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11663 \(Even if the operating system has support for stopping a process.\) */);
11664 cannot_suspend
= 0;
11666 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
11667 doc
: /* Non-nil means prompt with menus when appropriate.
11668 This is done when reading from a keymap that has a prompt string,
11669 for elements that have prompt strings.
11670 The menu is displayed on the screen
11671 if X menus were enabled at configuration
11672 time and the previous event was a mouse click prefix key.
11673 Otherwise, menu prompting uses the echo area. */);
11674 menu_prompting
= 1;
11676 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
11677 doc
: /* Character to see next line of menu prompt.
11678 Type this character while in a menu prompt to rotate around the lines of it. */);
11679 XSETINT (menu_prompt_more_char
, ' ');
11681 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
11682 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11683 Emacs applies the modifiers of the character stored here to each keyboard
11684 character it reads. For example, after evaluating the expression
11685 (setq extra-keyboard-modifiers ?\\C-x)
11686 all input characters will have the control modifier applied to them.
11688 Note that the character ?\\C-@, equivalent to the integer zero, does
11689 not count as a control character; rather, it counts as a character
11690 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11691 cancels any modification. */);
11692 extra_keyboard_modifiers
= 0;
11694 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
11695 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11696 The command loop sets this to nil before each command,
11697 and tests the value when the command returns.
11698 Buffer modification stores t in this variable. */);
11699 Vdeactivate_mark
= Qnil
;
11701 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
11702 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
11703 Vcommand_hook_internal
= Qnil
;
11705 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
11706 doc
: /* Normal hook run before each command is executed.
11707 If an unhandled error happens in running this hook,
11708 the hook value is set to nil, since otherwise the error
11709 might happen repeatedly and make Emacs nonfunctional. */);
11710 Vpre_command_hook
= Qnil
;
11712 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
11713 doc
: /* Normal hook run after each command is executed.
11714 If an unhandled error happens in running this hook,
11715 the hook value is set to nil, since otherwise the error
11716 might happen repeatedly and make Emacs nonfunctional. */);
11717 Vpost_command_hook
= Qnil
;
11720 DEFVAR_LISP ("echo-area-clear-hook", ...,
11721 doc
: /* Normal hook run when clearing the echo area. */);
11723 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
11724 staticpro (&Qecho_area_clear_hook
);
11725 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
11727 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
11728 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11729 Vlucid_menu_bar_dirty_flag
= Qnil
;
11731 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
11732 doc
: /* List of menu bar items to move to the end of the menu bar.
11733 The elements of the list are event types that may have menu bar bindings. */);
11734 Vmenu_bar_final_items
= Qnil
;
11736 DEFVAR_KBOARD ("overriding-terminal-local-map",
11737 Voverriding_terminal_local_map
,
11738 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11739 If this variable is non-nil, it is used as a keymap instead of the
11740 buffer's local map, and the minor mode keymaps and text property keymaps.
11741 It also replaces `overriding-local-map'.
11743 This variable is intended to let commands such as `universal-argument'
11744 set up a different keymap for reading the next command. */);
11746 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
11747 doc
: /* Keymap that overrides all other local keymaps.
11748 If this variable is non-nil, it is used as a keymap--replacing the
11749 buffer's local map, the minor mode keymaps, and char property keymaps. */);
11750 Voverriding_local_map
= Qnil
;
11752 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
11753 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11754 Otherwise, the menu bar continues to reflect the buffer's local map
11755 and the minor mode maps regardless of `overriding-local-map'. */);
11756 Voverriding_local_map_menu_flag
= Qnil
;
11758 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
11759 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11760 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
11762 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
11763 doc
: /* *Non-nil means generate motion events for mouse motion. */);
11765 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11766 doc
: /* Alist of system-specific X windows key symbols.
11767 Each element should have the form (N . SYMBOL) where N is the
11768 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11769 and SYMBOL is its name. */);
11771 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
11772 doc
: /* List of deferred actions to be performed at a later time.
11773 The precise format isn't relevant here; we just check whether it is nil. */);
11774 Vdeferred_action_list
= Qnil
;
11776 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
11777 doc
: /* Function to call to handle deferred actions, after each command.
11778 This function is called with no arguments after each command
11779 whenever `deferred-action-list' is non-nil. */);
11780 Vdeferred_action_function
= Qnil
;
11782 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
11783 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
11784 The value can be a length of time to show the message for.
11785 If the value is non-nil and not a number, we wait 2 seconds. */);
11786 Vsuggest_key_bindings
= Qt
;
11788 DEFVAR_LISP ("timer-list", &Vtimer_list
,
11789 doc
: /* List of active absolute time timers in order of increasing time. */);
11790 Vtimer_list
= Qnil
;
11792 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
11793 doc
: /* List of active idle-time timers in order of increasing time. */);
11794 Vtimer_idle_list
= Qnil
;
11796 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
11797 doc
: /* If non-nil, the function that implements the current input method.
11798 It's called with one argument, a printing character that was just read.
11799 \(That means a character with code 040...0176.)
11800 Typically this function uses `read-event' to read additional events.
11801 When it does so, it should first bind `input-method-function' to nil
11802 so it will not be called recursively.
11804 The function should return a list of zero or more events
11805 to be used as input. If it wants to put back some events
11806 to be reconsidered, separately, by the input method,
11807 it can add them to the beginning of `unread-command-events'.
11809 The input method function can find in `input-method-previous-method'
11810 the previous echo area message.
11812 The input method function should refer to the variables
11813 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11814 for guidance on what to do. */);
11815 Vinput_method_function
= Qnil
;
11817 DEFVAR_LISP ("input-method-previous-message",
11818 &Vinput_method_previous_message
,
11819 doc
: /* When `input-method-function' is called, hold the previous echo area message.
11820 This variable exists because `read-event' clears the echo area
11821 before running the input method. It is nil if there was no message. */);
11822 Vinput_method_previous_message
= Qnil
;
11824 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
11825 doc
: /* If non-nil, the function that implements the display of help.
11826 It's called with one argument, the help string to display. */);
11827 Vshow_help_function
= Qnil
;
11829 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
11830 doc
: /* If non-nil, suppress point adjustment after executing a command.
11832 After a command is executed, if point is moved into a region that has
11833 special properties (e.g. composition, display), we adjust point to
11834 the boundary of the region. But, when a command sets this variable to
11835 non-nil, we suppress the point adjustment.
11837 This variable is set to nil before reading a command, and is checked
11838 just after executing the command. */);
11839 Vdisable_point_adjustment
= Qnil
;
11841 DEFVAR_LISP ("global-disable-point-adjustment",
11842 &Vglobal_disable_point_adjustment
,
11843 doc
: /* *If non-nil, always suppress point adjustment.
11845 The default value is nil, in which case, point adjustment are
11846 suppressed only after special commands that set
11847 `disable-point-adjustment' (which see) to non-nil. */);
11848 Vglobal_disable_point_adjustment
= Qnil
;
11850 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
11851 doc
: /* *How long to display an echo-area message when the minibuffer is active.
11852 If the value is not a number, such messages don't time out. */);
11853 Vminibuffer_message_timeout
= make_number (2);
11855 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input
,
11856 doc
: /* If non-nil, any keyboard input throws to this symbol.
11857 The value of that variable is passed to `quit-flag' and later causes a
11858 peculiar kind of quitting. */);
11859 Vthrow_on_input
= Qnil
;
11861 DEFVAR_LISP ("command-error-function", &Vcommand_error_function
,
11862 doc
: /* If non-nil, function to output error messages.
11863 The arguments are the error data, a list of the form
11864 (SIGNALED-CONDITIONS . SIGNAL-DATA)
11865 such as just as `condition-case' would bind its variable to,
11866 the context (a string which normally goes at the start of the message),
11867 and the Lisp function within which the error was signaled. */);
11868 Vcommand_error_function
= Qnil
;
11870 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
11871 &Venable_disabled_menus_and_buttons
,
11872 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
11874 Help functions bind this to allow help on disabled menu items
11875 and tool-bar buttons. */);
11876 Venable_disabled_menus_and_buttons
= Qnil
;
11880 keys_of_keyboard ()
11882 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
11883 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
11884 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
11885 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
11886 initial_define_key (meta_map
, 'x', "execute-extended-command");
11888 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
11889 "handle-delete-frame");
11890 /* Here we used to use `ignore-event' which would simple set prefix-arg to
11891 current-prefix-arg, as is done in `handle-switch-frame'.
11892 But `handle-switch-frame is not run from the special-map.
11893 Commands from that map are run in a special way that automatically
11894 preserves the prefix-arg. Restoring the prefix arg here is not just
11895 redundant but harmful:
11897 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
11898 - after the first prompt, the exit-minibuffer-hook is run which may
11899 iconify a frame and thus push a `iconify-frame' event.
11900 - after running exit-minibuffer-hook, current-prefix-arg is
11901 restored to the non-nil value it had before the prompt.
11902 - we enter the second prompt.
11903 current-prefix-arg is non-nil, prefix-arg is nil.
11904 - before running the first real event, we run the special iconify-frame
11905 event, but we pass the `special' arg to execute-command so
11906 current-prefix-arg and prefix-arg are left untouched.
11907 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
11908 - the next key event will have a spuriously non-nil current-prefix-arg. */
11909 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
11911 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
11913 /* Handling it at such a low-level causes read_key_sequence to get
11914 * confused because it doesn't realize that the current_buffer was
11915 * changed by read_char.
11917 * initial_define_lispy_key (Vspecial_event_map, "select-window",
11918 * "handle-select-window"); */
11919 initial_define_lispy_key (Vspecial_event_map
, "save-session",
11920 "handle-save-session");
11923 /* Mark the pointers in the kboard objects.
11924 Called by the Fgarbage_collector. */
11930 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
11932 if (kb
->kbd_macro_buffer
)
11933 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
11935 mark_object (kb
->Voverriding_terminal_local_map
);
11936 mark_object (kb
->Vlast_command
);
11937 mark_object (kb
->Vreal_last_command
);
11938 mark_object (kb
->Vprefix_arg
);
11939 mark_object (kb
->Vlast_prefix_arg
);
11940 mark_object (kb
->kbd_queue
);
11941 mark_object (kb
->defining_kbd_macro
);
11942 mark_object (kb
->Vlast_kbd_macro
);
11943 mark_object (kb
->Vsystem_key_alist
);
11944 mark_object (kb
->system_key_syms
);
11945 mark_object (kb
->Vdefault_minibuffer_frame
);
11946 mark_object (kb
->echo_string
);
11949 struct input_event
*event
;
11950 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
11952 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
11953 event
= kbd_buffer
;
11954 if (event
->kind
!= SELECTION_REQUEST_EVENT
11955 && event
->kind
!= SELECTION_CLEAR_EVENT
)
11957 mark_object (event
->x
);
11958 mark_object (event
->y
);
11960 mark_object (event
->frame_or_window
);
11961 mark_object (event
->arg
);
11966 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
11967 (do not change this comment) */