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, 2008, 2009, 2010 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 3 of the License, or
11 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
29 #include "termhooks.h"
35 #include "character.h"
37 #include "dispextern.h"
39 #include "intervals.h"
41 #include "blockinput.h"
47 #ifdef HAVE_GTK_AND_PTHREAD
54 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
59 #include <sys/types.h>
68 /* This is to get the definitions of the XK_ symbols. */
75 #endif /* HAVE_NTGUI */
85 /* Variables for blockinput.h: */
87 /* Non-zero if interrupt input is blocked right now. */
88 volatile int interrupt_input_blocked
;
90 /* Nonzero means an input interrupt has arrived
91 during the current critical section. */
92 int interrupt_input_pending
;
94 /* This var should be (interrupt_input_pending || pending_atimers).
95 The QUIT macro checks this instead of interrupt_input_pending and
96 pending_atimers separately, to reduce code size. So, any code that
97 changes interrupt_input_pending or pending_atimers should update
103 #define KBD_BUFFER_SIZE 4096
105 KBOARD
*initial_kboard
;
106 KBOARD
*current_kboard
;
110 /* Non-nil disable property on a command means
111 do not execute it; call disabled-command-function's value instead. */
112 Lisp_Object Qdisabled
, Qdisabled_command_function
;
114 #define NUM_RECENT_KEYS (300)
115 int recent_keys_index
; /* Index for storing next element into recent_keys */
116 int total_keys
; /* Total number of elements stored into recent_keys */
117 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
119 /* Vector holding the key sequence that invoked the current command.
120 It is reused for each command, and it may be longer than the current
121 sequence; this_command_key_count indicates how many elements
122 actually mean something.
123 It's easier to staticpro a single Lisp_Object than an array. */
124 Lisp_Object this_command_keys
;
125 int this_command_key_count
;
127 /* 1 after calling Freset_this_command_lengths.
129 int this_command_key_count_reset
;
131 /* This vector is used as a buffer to record the events that were actually read
132 by read_key_sequence. */
133 Lisp_Object raw_keybuf
;
134 int raw_keybuf_count
;
136 /* Non-nil if the present key sequence was obtained by shift translation. */
137 Lisp_Object Vthis_command_keys_shift_translated
;
139 #define GROW_RAW_KEYBUF \
140 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
141 raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
143 /* Number of elements of this_command_keys
144 that precede this key sequence. */
145 int this_single_command_key_start
;
147 /* Record values of this_command_key_count and echo_length ()
148 before this command was read. */
149 static int before_command_key_count
;
150 static int before_command_echo_length
;
152 extern int minbuf_level
;
154 extern int message_enable_multibyte
;
156 /* If non-nil, the function that implements the display of help.
157 It's called with one argument, the help string to display. */
159 Lisp_Object Vshow_help_function
;
161 /* Nonzero means do menu prompting. */
163 static int menu_prompting
;
165 /* Character to see next line of menu prompt. */
167 static Lisp_Object menu_prompt_more_char
;
169 /* For longjmp to where kbd input is being done. */
171 static jmp_buf getcjmp
;
173 /* True while doing kbd input. */
174 int waiting_for_input
;
176 /* True while displaying for echoing. Delays C-g throwing. */
180 /* Non-null means we can start echoing at the next input pause even
181 though there is something in the echo area. */
183 static struct kboard
*ok_to_echo_at_next_pause
;
185 /* The kboard last echoing, or null for none. Reset to 0 in
186 cancel_echoing. If non-null, and a current echo area message
187 exists, and echo_message_buffer is eq to the current message
188 buffer, we know that the message comes from echo_kboard. */
190 struct kboard
*echo_kboard
;
192 /* The buffer used for echoing. Set in echo_now, reset in
195 Lisp_Object echo_message_buffer
;
197 /* Nonzero means disregard local maps for the menu bar. */
198 static int inhibit_local_menu_bar_menus
;
200 /* Nonzero means C-g should cause immediate error-signal. */
203 /* The user's hook function for outputting an error message. */
204 Lisp_Object Vcommand_error_function
;
206 /* The user's ERASE setting. */
207 Lisp_Object Vtty_erase_char
;
209 /* Character to recognize as the help char. */
210 Lisp_Object Vhelp_char
;
212 /* List of other event types to recognize as meaning "help". */
213 Lisp_Object Vhelp_event_list
;
215 /* Form to execute when help char is typed. */
216 Lisp_Object Vhelp_form
;
218 /* Command to run when the help character follows a prefix key. */
219 Lisp_Object Vprefix_help_command
;
221 /* List of items that should move to the end of the menu bar. */
222 Lisp_Object Vmenu_bar_final_items
;
224 /* Non-nil means show the equivalent key-binding for
225 any M-x command that has one.
226 The value can be a length of time to show the message for.
227 If the value is non-nil and not a number, we wait 2 seconds. */
228 Lisp_Object Vsuggest_key_bindings
;
230 /* How long to display an echo-area message when the minibuffer is active.
231 If the value is not a number, such messages don't time out. */
232 Lisp_Object Vminibuffer_message_timeout
;
234 /* Character that causes a quit. Normally C-g.
236 If we are running on an ordinary terminal, this must be an ordinary
237 ASCII char, since we want to make it our interrupt character.
239 If we are not running on an ordinary terminal, it still needs to be
240 an ordinary ASCII char. This character needs to be recognized in
241 the input interrupt handler. At this point, the keystroke is
242 represented as a struct input_event, while the desired quit
243 character is specified as a lispy event. The mapping from struct
244 input_events to lispy events cannot run in an interrupt handler,
245 and the reverse mapping is difficult for anything but ASCII
248 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
252 extern Lisp_Object current_global_map
;
253 extern int minibuf_level
;
255 /* If non-nil, this is a map that overrides all other local maps. */
256 Lisp_Object Voverriding_local_map
;
258 /* If non-nil, Voverriding_local_map applies to the menu bar. */
259 Lisp_Object Voverriding_local_map_menu_flag
;
261 /* Keymap that defines special misc events that should
262 be processed immediately at a low level. */
263 Lisp_Object Vspecial_event_map
;
265 /* Current depth in recursive edits. */
266 int command_loop_level
;
268 /* Total number of times command_loop has read a key sequence. */
269 EMACS_INT num_input_keys
;
271 /* Last input event read as a command. */
272 Lisp_Object last_command_event
;
274 /* Last input character read as a command, not counting menus
275 reached by the mouse. */
276 Lisp_Object last_nonmenu_event
;
278 /* Last input event read for any purpose. */
279 Lisp_Object last_input_event
;
281 /* If not Qnil, a list of objects to be read as subsequent command input. */
282 Lisp_Object Vunread_command_events
;
284 /* If not Qnil, a list of objects to be read as subsequent command input
285 including input method processing. */
286 Lisp_Object Vunread_input_method_events
;
288 /* If not Qnil, a list of objects to be read as subsequent command input
289 but NOT including input method processing. */
290 Lisp_Object Vunread_post_input_method_events
;
292 /* If not -1, an event to be read as subsequent command input. */
293 EMACS_INT unread_command_char
;
295 /* If not Qnil, this is a switch-frame event which we decided to put
296 off until the end of a key sequence. This should be read as the
297 next command input, after any unread_command_events.
299 read_key_sequence uses this to delay switch-frame events until the
300 end of the key sequence; Fread_char uses it to put off switch-frame
301 events until a non-ASCII event is acceptable as input. */
302 Lisp_Object unread_switch_frame
;
304 /* A mask of extra modifier bits to put into every keyboard char. */
305 EMACS_INT extra_keyboard_modifiers
;
307 /* Char to use as prefix when a meta character is typed in.
308 This is bound on entry to minibuffer in case ESC is changed there. */
310 Lisp_Object meta_prefix_char
;
312 /* Last size recorded for a current buffer which is not a minibuffer. */
313 static int last_non_minibuf_size
;
315 /* Number of idle seconds before an auto-save and garbage collection. */
316 static Lisp_Object Vauto_save_timeout
;
318 /* Total number of times read_char has returned. */
319 int num_input_events
;
321 /* Total number of times read_char has returned, outside of macros. */
322 EMACS_INT num_nonmacro_input_events
;
324 /* Auto-save automatically when this many characters have been typed
325 since the last time. */
327 static EMACS_INT auto_save_interval
;
329 /* Value of num_nonmacro_input_events as of last auto save. */
333 /* The command being executed by the command loop.
334 Commands may set this, and the value set will be copied into
335 current_kboard->Vlast_command instead of the actual command. */
336 Lisp_Object Vthis_command
;
338 /* This is like Vthis_command, except that commands never set it. */
339 Lisp_Object real_this_command
;
341 /* If the lookup of the command returns a binding, the original
342 command is stored in this-original-command. It is nil otherwise. */
343 Lisp_Object Vthis_original_command
;
345 /* The value of point when the last command was started. */
346 int last_point_position
;
348 /* The buffer that was current when the last command was started. */
349 Lisp_Object last_point_position_buffer
;
351 /* The window that was selected when the last command was started. */
352 Lisp_Object last_point_position_window
;
354 /* The frame in which the last input event occurred, or Qmacro if the
355 last event came from a macro. We use this to determine when to
356 generate switch-frame events. This may be cleared by functions
357 like Fselect_frame, to make sure that a switch-frame event is
358 generated by the next character. */
359 Lisp_Object internal_last_event_frame
;
361 /* A user-visible version of the above, intended to allow users to
362 figure out where the last event came from, if the event doesn't
363 carry that information itself (i.e. if it was a character). */
364 Lisp_Object Vlast_event_frame
;
366 /* The timestamp of the last input event we received from the X server.
367 X Windows wants this for selection ownership. */
368 unsigned long last_event_timestamp
;
370 Lisp_Object Qself_insert_command
;
371 Lisp_Object Qforward_char
;
372 Lisp_Object Qbackward_char
;
373 Lisp_Object Qundefined
;
374 Lisp_Object Qtimer_event_handler
;
376 /* read_key_sequence stores here the command definition of the
377 key sequence that it reads. */
378 Lisp_Object read_key_sequence_cmd
;
380 /* Echo unfinished commands after this many seconds of pause. */
381 Lisp_Object Vecho_keystrokes
;
383 /* Form to evaluate (if non-nil) when Emacs is started. */
384 Lisp_Object Vtop_level
;
386 /* If non-nil, this implements the current input method. */
387 Lisp_Object Vinput_method_function
;
388 Lisp_Object Qinput_method_function
;
390 /* When we call Vinput_method_function,
391 this holds the echo area message that was just erased. */
392 Lisp_Object Vinput_method_previous_message
;
394 /* Non-nil means deactivate the mark at end of this command. */
395 Lisp_Object Vdeactivate_mark
;
396 Lisp_Object Qdeactivate_mark
;
398 /* Menu bar specified in Lucid Emacs fashion. */
400 Lisp_Object Vlucid_menu_bar_dirty_flag
;
401 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
403 Lisp_Object Qecho_area_clear_hook
;
405 /* Hooks to run before and after each command. */
406 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
407 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
408 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
410 /* Parent keymap of terminal-local function-key-map instances. */
411 Lisp_Object Vfunction_key_map
;
413 /* Keymap of key translations that can override keymaps. */
414 Lisp_Object Vkey_translation_map
;
416 /* List of deferred actions to be performed at a later time.
417 The precise format isn't relevant here; we just check whether it is nil. */
418 Lisp_Object Vdeferred_action_list
;
420 /* Function to call to handle deferred actions, when there are any. */
421 Lisp_Object Vdeferred_action_function
;
422 Lisp_Object Qdeferred_action_function
;
424 Lisp_Object Qinput_method_exit_on_first_char
;
425 Lisp_Object Qinput_method_use_echo_area
;
427 /* File in which we write all commands we read. */
430 /* Nonzero if input is available. */
433 extern char *pending_malloc_warning
;
435 /* Circular buffer for pre-read keyboard input. */
437 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
439 /* Pointer to next available character in kbd_buffer.
440 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
441 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
442 next available char is in kbd_buffer[0]. */
443 static struct input_event
*kbd_fetch_ptr
;
445 /* Pointer to next place to store character in kbd_buffer. This
446 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
447 character should go in kbd_buffer[0]. */
448 static struct input_event
* volatile kbd_store_ptr
;
450 /* The above pair of variables forms a "queue empty" flag. When we
451 enqueue a non-hook event, we increment kbd_store_ptr. When we
452 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
453 there is input available if the two pointers are not equal.
455 Why not just have a flag set and cleared by the enqueuing and
456 dequeuing functions? Such a flag could be screwed up by interrupts
457 at inopportune times. */
459 /* If this flag is non-nil, we check mouse_moved to see when the
460 mouse moves, and motion events will appear in the input stream.
461 Otherwise, mouse motion is ignored. */
462 Lisp_Object do_mouse_tracking
;
464 /* Symbols to head events. */
465 Lisp_Object Qmouse_movement
;
466 Lisp_Object Qscroll_bar_movement
;
467 Lisp_Object Qswitch_frame
;
468 Lisp_Object Qdelete_frame
;
469 Lisp_Object Qiconify_frame
;
470 Lisp_Object Qmake_frame_visible
;
471 Lisp_Object Qselect_window
;
472 Lisp_Object Qhelp_echo
;
474 extern Lisp_Object Qremap
;
476 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
477 Lisp_Object Qmouse_fixup_help_message
;
480 /* Symbols to denote kinds of events. */
481 Lisp_Object Qfunction_key
;
482 Lisp_Object Qmouse_click
;
483 #if defined (WINDOWSNT)
484 Lisp_Object Qlanguage_change
;
486 Lisp_Object Qdrag_n_drop
;
487 Lisp_Object Qsave_session
;
489 Lisp_Object Qdbus_event
;
491 Lisp_Object Qconfig_changed_event
;
493 /* Lisp_Object Qmouse_movement; - also an event header */
495 /* Properties of event headers. */
496 Lisp_Object Qevent_kind
;
497 Lisp_Object Qevent_symbol_elements
;
499 /* menu item parts */
500 Lisp_Object Qmenu_enable
;
501 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
502 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
503 extern Lisp_Object Qmenu_item
;
505 /* An event header symbol HEAD may have a property named
506 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
507 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
508 mask of modifiers applied to it. If present, this is used to help
509 speed up parse_modifiers. */
510 Lisp_Object Qevent_symbol_element_mask
;
512 /* An unmodified event header BASE may have a property named
513 Qmodifier_cache, which is an alist mapping modifier masks onto
514 modified versions of BASE. If present, this helps speed up
516 Lisp_Object Qmodifier_cache
;
518 /* Symbols to use for parts of windows. */
519 Lisp_Object Qmode_line
;
520 Lisp_Object Qvertical_line
;
521 Lisp_Object Qvertical_scroll_bar
;
522 Lisp_Object Qmenu_bar
;
523 extern Lisp_Object Qleft_margin
, Qright_margin
;
524 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
525 extern Lisp_Object QCmap
;
527 Lisp_Object
recursive_edit_unwind (), command_loop ();
528 Lisp_Object
Fthis_command_keys ();
529 Lisp_Object Qextended_command_history
;
530 EMACS_TIME
timer_check ();
532 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
534 extern char *x_get_keysym_name ();
536 static void record_menu_key ();
537 static int echo_length ();
539 Lisp_Object Qpolling_period
;
541 /* List of absolute timers. Appears in order of next scheduled event. */
542 Lisp_Object Vtimer_list
;
544 /* List of idle time timers. Appears in order of next scheduled event. */
545 Lisp_Object Vtimer_idle_list
;
547 /* Incremented whenever a timer is run. */
550 extern Lisp_Object Vprint_level
, Vprint_length
;
552 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
554 EMACS_TIME
*input_available_clear_time
;
556 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
557 Default is 1 if INTERRUPT_INPUT is defined. */
560 /* Nonzero while interrupts are temporarily deferred during redisplay. */
561 int interrupts_deferred
;
563 /* Allow m- file to inhibit use of FIONREAD. */
564 #ifdef BROKEN_FIONREAD
568 /* We are unable to use interrupts if FIONREAD is not available,
569 so flush SIGIO so we won't try. */
570 #if !defined (FIONREAD)
576 /* If we support a window system, turn on the code to poll periodically
577 to detect C-g. It isn't actually used when doing interrupt input. */
578 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
579 #define POLL_FOR_INPUT
582 /* After a command is executed, if point is moved into a region that
583 has specific properties (e.g. composition, display), we adjust
584 point to the boundary of the region. But, if a command sets this
585 variable to non-nil, we suppress this point adjustment. This
586 variable is set to nil before reading a command. */
588 Lisp_Object Vdisable_point_adjustment
;
590 /* If non-nil, always disable point adjustment. */
592 Lisp_Object Vglobal_disable_point_adjustment
;
594 /* The time when Emacs started being idle. */
596 static EMACS_TIME timer_idleness_start_time
;
598 /* After Emacs stops being idle, this saves the last value
599 of timer_idleness_start_time from when it was idle. */
601 static EMACS_TIME timer_last_idleness_start_time
;
603 /* If non-nil, events produced by disabled menu items and tool-bar
604 buttons are not ignored. Help functions bind this to allow help on
605 those items and buttons. */
606 Lisp_Object Venable_disabled_menus_and_buttons
;
609 /* Global variable declarations. */
611 /* Flags for readable_events. */
612 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
613 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
614 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
616 /* Function for init_keyboard to call with no args (if nonzero). */
617 void (*keyboard_init_hook
) ();
619 static int read_avail_input
P_ ((int));
620 static void get_input_pending
P_ ((int *, int));
621 static int readable_events
P_ ((int));
622 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
623 Lisp_Object
, int *));
624 static Lisp_Object
read_char_x_menu_prompt ();
625 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
627 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
628 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
629 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
630 enum scroll_bar_part
,
631 Lisp_Object
, Lisp_Object
,
634 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
635 Lisp_Object
, char **,
636 Lisp_Object
*, unsigned));
637 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
638 static void save_getcjmp
P_ ((jmp_buf));
639 static void save_getcjmp ();
640 static void restore_getcjmp
P_ ((jmp_buf));
641 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
642 static void clear_event
P_ ((struct input_event
*));
643 static Lisp_Object restore_kboard_configuration
P_ ((Lisp_Object
));
644 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
646 static SIGTYPE
input_available_signal (int signo
);
648 static void handle_interrupt
P_ ((void));
649 static void timer_start_idle
P_ ((void));
650 static void timer_stop_idle
P_ ((void));
651 static void timer_resume_idle
P_ ((void));
652 static SIGTYPE handle_user_signal
P_ ((int));
653 static char *find_user_signal_name
P_ ((int));
654 static int store_user_signal_events
P_ ((void));
656 /* Nonzero means don't try to suspend even if the operating system seems
658 static int cannot_suspend
;
660 extern Lisp_Object Qidentity
, Qonly
;
662 /* Install the string STR as the beginning of the string of echoing,
663 so that it serves as a prompt for the next character.
664 Also start echoing. */
670 current_kboard
->echo_string
= str
;
671 current_kboard
->echo_after_prompt
= SCHARS (str
);
675 /* Add C to the echo string, if echoing is going on.
676 C can be a character, which is printed prettily ("M-C-x" and all that
677 jazz), or a symbol, whose name is printed. */
683 if (current_kboard
->immediate_echo
)
685 int size
= KEY_DESCRIPTION_SIZE
+ 100;
686 char *buffer
= (char *) alloca (size
);
688 Lisp_Object echo_string
;
690 echo_string
= current_kboard
->echo_string
;
692 /* If someone has passed us a composite event, use its head symbol. */
697 ptr
= push_key_description (XINT (c
), ptr
, 1);
699 else if (SYMBOLP (c
))
701 Lisp_Object name
= SYMBOL_NAME (c
);
702 int nbytes
= SBYTES (name
);
704 if (size
- (ptr
- buffer
) < nbytes
)
706 int offset
= ptr
- buffer
;
707 size
= max (2 * size
, size
+ nbytes
);
708 buffer
= (char *) alloca (size
);
709 ptr
= buffer
+ offset
;
712 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
713 STRING_MULTIBYTE (name
), 1);
716 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
719 const char *text
= " (Type ? for further options)";
720 int len
= strlen (text
);
722 if (size
- (ptr
- buffer
) < len
)
724 int offset
= ptr
- buffer
;
726 buffer
= (char *) alloca (size
);
727 ptr
= buffer
+ offset
;
730 bcopy (text
, ptr
, len
);
734 /* Replace a dash from echo_dash with a space, otherwise
735 add a space at the end as a separator between keys. */
736 if (STRINGP (echo_string
)
737 && SCHARS (echo_string
) > 1)
739 Lisp_Object last_char
, prev_char
, idx
;
741 idx
= make_number (SCHARS (echo_string
) - 2);
742 prev_char
= Faref (echo_string
, idx
);
744 idx
= make_number (SCHARS (echo_string
) - 1);
745 last_char
= Faref (echo_string
, idx
);
747 /* We test PREV_CHAR to make sure this isn't the echoing
749 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
750 Faset (echo_string
, idx
, make_number (' '));
752 echo_string
= concat2 (echo_string
, build_string (" "));
754 else if (STRINGP (echo_string
))
755 echo_string
= concat2 (echo_string
, build_string (" "));
757 current_kboard
->echo_string
758 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
764 /* Temporarily add a dash to the end of the echo string if it's not
765 empty, so that it serves as a mini-prompt for the very next character. */
770 /* Do nothing if not echoing at all. */
771 if (NILP (current_kboard
->echo_string
))
774 if (!current_kboard
->immediate_echo
775 && SCHARS (current_kboard
->echo_string
) == 0)
778 /* Do nothing if we just printed a prompt. */
779 if (current_kboard
->echo_after_prompt
780 == SCHARS (current_kboard
->echo_string
))
783 /* Do nothing if we have already put a dash at the end. */
784 if (SCHARS (current_kboard
->echo_string
) > 1)
786 Lisp_Object last_char
, prev_char
, idx
;
788 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
789 prev_char
= Faref (current_kboard
->echo_string
, idx
);
791 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
792 last_char
= Faref (current_kboard
->echo_string
, idx
);
794 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
798 /* Put a dash at the end of the buffer temporarily,
799 but make it go away when the next character is added. */
800 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
805 /* Display the current echo string, and begin echoing if not already
811 if (!current_kboard
->immediate_echo
)
814 current_kboard
->immediate_echo
= 1;
816 for (i
= 0; i
< this_command_key_count
; i
++)
820 /* Set before_command_echo_length to the value that would
821 have been saved before the start of this subcommand in
822 command_loop_1, if we had already been echoing then. */
823 if (i
== this_single_command_key_start
)
824 before_command_echo_length
= echo_length ();
826 c
= XVECTOR (this_command_keys
)->contents
[i
];
827 if (! (EVENT_HAS_PARAMETERS (c
)
828 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
832 /* Set before_command_echo_length to the value that would
833 have been saved before the start of this subcommand in
834 command_loop_1, if we had already been echoing then. */
835 if (this_command_key_count
== this_single_command_key_start
)
836 before_command_echo_length
= echo_length ();
838 /* Put a dash at the end to invite the user to type more. */
843 message3_nolog (current_kboard
->echo_string
,
844 SBYTES (current_kboard
->echo_string
),
845 STRING_MULTIBYTE (current_kboard
->echo_string
));
848 /* Record in what buffer we echoed, and from which kboard. */
849 echo_message_buffer
= echo_area_buffer
[0];
850 echo_kboard
= current_kboard
;
852 if (waiting_for_input
&& !NILP (Vquit_flag
))
853 quit_throw_to_read_char ();
856 /* Turn off echoing, for the start of a new command. */
861 current_kboard
->immediate_echo
= 0;
862 current_kboard
->echo_after_prompt
= -1;
863 current_kboard
->echo_string
= Qnil
;
864 ok_to_echo_at_next_pause
= NULL
;
866 echo_message_buffer
= Qnil
;
869 /* Return the length of the current echo string. */
874 return (STRINGP (current_kboard
->echo_string
)
875 ? SCHARS (current_kboard
->echo_string
)
879 /* Truncate the current echo message to its first LEN chars.
880 This and echo_char get used by read_key_sequence when the user
881 switches frames while entering a key sequence. */
884 echo_truncate (nchars
)
887 if (STRINGP (current_kboard
->echo_string
))
888 current_kboard
->echo_string
889 = Fsubstring (current_kboard
->echo_string
,
890 make_number (0), make_number (nchars
));
891 truncate_echo_area (nchars
);
895 /* Functions for manipulating this_command_keys. */
897 add_command_key (key
)
900 #if 0 /* Not needed after we made Freset_this_command_lengths
901 do the job immediately. */
902 /* If reset-this-command-length was called recently, obey it now.
903 See the doc string of that function for an explanation of why. */
904 if (before_command_restore_flag
)
906 this_command_key_count
= before_command_key_count_1
;
907 if (this_command_key_count
< this_single_command_key_start
)
908 this_single_command_key_start
= this_command_key_count
;
909 echo_truncate (before_command_echo_length_1
);
910 before_command_restore_flag
= 0;
914 if (this_command_key_count
>= ASIZE (this_command_keys
))
915 this_command_keys
= larger_vector (this_command_keys
,
916 2 * ASIZE (this_command_keys
),
919 ASET (this_command_keys
, this_command_key_count
, key
);
920 ++this_command_key_count
;
927 int count
= SPECPDL_INDEX ();
930 if (command_loop_level
> 0)
932 specbind (Qstandard_output
, Qt
);
933 specbind (Qstandard_input
, Qt
);
936 #ifdef HAVE_WINDOW_SYSTEM
937 /* The command loop has started an hourglass timer, so we have to
938 cancel it here, otherwise it will fire because the recursive edit
939 can take some time. Do not check for display_hourglass_p here,
940 because it could already be nil. */
944 /* This function may have been called from a debugger called from
945 within redisplay, for instance by Edebugging a function called
946 from fontification-functions. We want to allow redisplay in
947 the debugging session.
949 The recursive edit is left with a `(throw exit ...)'. The `exit'
950 tag is not caught anywhere in redisplay, i.e. when we leave the
951 recursive edit, the original redisplay leading to the recursive
952 edit will be unwound. The outcome should therefore be safe. */
953 specbind (Qinhibit_redisplay
, Qnil
);
956 val
= command_loop ();
958 Fsignal (Qquit
, Qnil
);
959 /* Handle throw from read_minibuf when using minibuffer
960 while it's active but we're in another window. */
962 xsignal1 (Qerror
, val
);
964 return unbind_to (count
, Qnil
);
967 /* When an auto-save happens, record the "time", and don't do again soon. */
972 last_auto_save
= num_nonmacro_input_events
;
975 /* Make an auto save happen as soon as possible at command level. */
978 force_auto_save_soon ()
980 last_auto_save
= - auto_save_interval
- 1;
982 record_asynch_buffer_change ();
985 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
986 doc
: /* Invoke the editor command loop recursively.
987 To get out of the recursive edit, a command can do `(throw 'exit nil)';
988 that tells this function to return.
989 Alternatively, `(throw 'exit t)' makes this function signal an error.
990 This function is called by the editor initialization to begin editing. */)
993 int count
= SPECPDL_INDEX ();
996 /* If we enter while input is blocked, don't lock up here.
997 This may happen through the debugger during redisplay. */
1001 command_loop_level
++;
1002 update_mode_lines
= 1;
1004 if (command_loop_level
1005 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1006 buffer
= Fcurrent_buffer ();
1010 /* If we leave recursive_edit_1 below with a `throw' for instance,
1011 like it is done in the splash screen display, we have to
1012 make sure that we restore single_kboard as command_loop_1
1013 would have done if it were left normally. */
1014 if (command_loop_level
> 0)
1015 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
1016 record_unwind_protect (recursive_edit_unwind
, buffer
);
1018 recursive_edit_1 ();
1019 return unbind_to (count
, Qnil
);
1023 recursive_edit_unwind (buffer
)
1026 if (BUFFERP (buffer
))
1027 Fset_buffer (buffer
);
1029 command_loop_level
--;
1030 update_mode_lines
= 1;
1035 #if 0 /* These two functions are now replaced with
1036 temporarily_switch_to_single_kboard. */
1040 #if 0 /* Theory: if there's anything in Vunread_command_events,
1041 it will right away be read by read_key_sequence,
1042 and then if we do switch KBOARDS, it will go into the side
1043 queue then. So we don't need to do anything special here -- rms. */
1044 if (CONSP (Vunread_command_events
))
1046 current_kboard
->kbd_queue
1047 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1048 current_kboard
->kbd_queue_has_data
= 1;
1050 Vunread_command_events
= Qnil
;
1055 /* Switch to the single-kboard state, making current_kboard
1056 the only KBOARD from which further input is accepted. */
1059 single_kboard_state ()
1065 /* If we're in single_kboard state for kboard KBOARD,
1069 not_single_kboard_state (kboard
)
1072 if (kboard
== current_kboard
)
1076 /* Maintain a stack of kboards, so other parts of Emacs
1077 can switch temporarily to the kboard of a given frame
1078 and then revert to the previous status. */
1083 struct kboard_stack
*next
;
1086 static struct kboard_stack
*kboard_stack
;
1092 struct kboard_stack
*p
1093 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1095 p
->next
= kboard_stack
;
1096 p
->kboard
= current_kboard
;
1106 struct kboard_stack
*p
= kboard_stack
;
1108 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
1110 if (t
->kboard
== p
->kboard
)
1112 current_kboard
= p
->kboard
;
1119 /* The terminal we remembered has been deleted. */
1120 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
1123 kboard_stack
= p
->next
;
1127 /* Switch to single_kboard mode, making current_kboard the only KBOARD
1128 from which further input is accepted. If F is non-nil, set its
1129 KBOARD as the current keyboard.
1131 This function uses record_unwind_protect to return to the previous
1134 If Emacs is already in single_kboard mode, and F's keyboard is
1135 locked, then this function will throw an errow. */
1138 temporarily_switch_to_single_kboard (f
)
1141 int was_locked
= single_kboard
;
1144 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
1145 /* We can not switch keyboards while in single_kboard mode.
1146 In rare cases, Lisp code may call `recursive-edit' (or
1147 `read-minibuffer' or `y-or-n-p') after it switched to a
1148 locked frame. For example, this is likely to happen
1149 when server.el connects to a new terminal while Emacs is in
1150 single_kboard mode. It is best to throw an error instead
1151 of presenting the user with a frozen screen. */
1152 error ("Terminal %d is locked, cannot read from it",
1153 FRAME_TERMINAL (f
)->id
);
1155 /* This call is unnecessary, but helps
1156 `restore_kboard_configuration' discover if somebody changed
1157 `current_kboard' behind our back. */
1158 push_kboard (current_kboard
);
1161 current_kboard
= FRAME_KBOARD (f
);
1163 record_unwind_protect (restore_kboard_configuration
,
1164 (was_locked
? Qt
: Qnil
));
1167 #if 0 /* This function is not needed anymore. */
1169 record_single_kboard_state ()
1172 push_kboard (current_kboard
);
1173 record_unwind_protect (restore_kboard_configuration
,
1174 (single_kboard
? Qt
: Qnil
));
1179 restore_kboard_configuration (was_locked
)
1180 Lisp_Object was_locked
;
1182 if (NILP (was_locked
))
1186 struct kboard
*prev
= current_kboard
;
1189 /* The pop should not change the kboard. */
1190 if (single_kboard
&& current_kboard
!= prev
)
1197 /* Handle errors that are not handled at inner levels
1198 by printing an error message and returning to the editor command loop. */
1204 Lisp_Object old_level
, old_length
;
1205 char macroerror
[50];
1207 #ifdef HAVE_WINDOW_SYSTEM
1208 if (display_hourglass_p
)
1209 cancel_hourglass ();
1212 if (!NILP (executing_kbd_macro
))
1214 if (executing_kbd_macro_iterations
== 1)
1215 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1217 sprintf (macroerror
, "After %d kbd macro iterations: ",
1218 executing_kbd_macro_iterations
);
1223 Vstandard_output
= Qt
;
1224 Vstandard_input
= Qt
;
1225 Vexecuting_kbd_macro
= Qnil
;
1226 executing_kbd_macro
= Qnil
;
1227 current_kboard
->Vprefix_arg
= Qnil
;
1228 current_kboard
->Vlast_prefix_arg
= Qnil
;
1231 /* Avoid unquittable loop if data contains a circular list. */
1232 old_level
= Vprint_level
;
1233 old_length
= Vprint_length
;
1234 XSETFASTINT (Vprint_level
, 10);
1235 XSETFASTINT (Vprint_length
, 10);
1236 cmd_error_internal (data
, macroerror
);
1237 Vprint_level
= old_level
;
1238 Vprint_length
= old_length
;
1242 Vinhibit_quit
= Qnil
;
1243 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1244 if (command_loop_level
== 0 && minibuf_level
== 0)
1245 any_kboard_state ();
1248 return make_number (0);
1251 /* Take actions on handling an error. DATA is the data that describes
1254 CONTEXT is a C-string containing ASCII characters only which
1255 describes the context in which the error happened. If we need to
1256 generalize CONTEXT to allow multibyte characters, make it a Lisp
1260 cmd_error_internal (data
, context
)
1264 struct frame
*sf
= SELECTED_FRAME ();
1266 /* The immediate context is not interesting for Quits,
1267 since they are asyncronous. */
1268 if (EQ (XCAR (data
), Qquit
))
1269 Vsignaling_function
= Qnil
;
1274 /* Use user's specified output function if any. */
1275 if (!NILP (Vcommand_error_function
))
1276 call3 (Vcommand_error_function
, data
,
1277 context
? build_string (context
) : empty_unibyte_string
,
1278 Vsignaling_function
);
1279 /* If the window system or terminal frame hasn't been initialized
1280 yet, or we're not interactive, write the message to stderr and exit. */
1281 else if (!sf
->glyphs_initialized_p
1282 /* The initial frame is a special non-displaying frame. It
1283 will be current in daemon mode when there are no frames
1284 to display, and in non-daemon mode before the real frame
1285 has finished initializing. If an error is thrown in the
1286 latter case while creating the frame, then the frame
1287 will never be displayed, so the safest thing to do is
1288 write to stderr and quit. In daemon mode, there are
1289 many other potential errors that do not prevent frames
1290 from being created, so continuing as normal is better in
1292 || (!IS_DAEMON
&& FRAME_INITIAL_P (sf
))
1295 print_error_message (data
, Qexternal_debugging_output
,
1296 context
, Vsignaling_function
);
1297 Fterpri (Qexternal_debugging_output
);
1298 Fkill_emacs (make_number (-1));
1302 clear_message (1, 0);
1304 message_log_maybe_newline ();
1307 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1310 Vsignaling_function
= Qnil
;
1313 Lisp_Object
command_loop_1 ();
1314 Lisp_Object
command_loop_2 ();
1315 Lisp_Object
top_level_1 ();
1317 /* Entry to editor-command-loop.
1318 This level has the catches for exiting/returning to editor command loop.
1319 It returns nil to exit recursive edit, t to abort it. */
1324 if (command_loop_level
> 0 || minibuf_level
> 0)
1327 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1328 executing_kbd_macro
= Qnil
;
1334 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1335 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1336 /* Reset single_kboard in case top-level set it while
1337 evaluating an -f option, or we are stuck there for some
1339 any_kboard_state ();
1341 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1342 executing_kbd_macro
= Qnil
;
1344 /* End of file in -batch run causes exit here. */
1350 /* Here we catch errors in execution of commands within the
1351 editing loop, and reenter the editing loop.
1352 When there is an error, cmd_error runs and returns a non-nil
1353 value to us. A value of nil means that command_loop_1 itself
1354 returned due to end of file (or end of kbd macro). */
1359 register Lisp_Object val
;
1362 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1363 while (!NILP (val
));
1371 return Feval (Vtop_level
);
1377 /* On entry to the outer level, run the startup file */
1378 if (!NILP (Vtop_level
))
1379 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1380 else if (!NILP (Vpurify_flag
))
1381 message ("Bare impure Emacs (standard Lisp code not loaded)");
1383 message ("Bare Emacs (standard Lisp code not loaded)");
1387 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1388 doc
: /* Exit all recursive editing levels.
1389 This also exits all active minibuffers. */)
1392 #ifdef HAVE_WINDOW_SYSTEM
1393 if (display_hourglass_p
)
1394 cancel_hourglass ();
1397 /* Unblock input if we enter with input blocked. This may happen if
1398 redisplay traps e.g. during tool-bar update with input blocked. */
1399 while (INPUT_BLOCKED_P
)
1402 return Fthrow (Qtop_level
, Qnil
);
1405 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1406 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1409 if (command_loop_level
> 0 || minibuf_level
> 0)
1410 Fthrow (Qexit
, Qnil
);
1412 error ("No recursive edit is in progress");
1416 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1417 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1420 if (command_loop_level
> 0 || minibuf_level
> 0)
1423 error ("No recursive edit is in progress");
1427 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1429 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1430 of this function. */
1433 tracking_off (old_value
)
1434 Lisp_Object old_value
;
1436 do_mouse_tracking
= old_value
;
1437 if (NILP (old_value
))
1439 /* Redisplay may have been preempted because there was input
1440 available, and it assumes it will be called again after the
1441 input has been processed. If the only input available was
1442 the sort that we have just disabled, then we need to call
1444 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1446 redisplay_preserve_echo_area (6);
1447 get_input_pending (&input_pending
,
1448 READABLE_EVENTS_DO_TIMERS_NOW
);
1454 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1455 doc
: /* Evaluate BODY with mouse movement events enabled.
1456 Within a `track-mouse' form, mouse motion generates input events that
1457 you can read with `read-event'.
1458 Normally, mouse motion is ignored.
1459 usage: (track-mouse BODY...) */)
1463 int count
= SPECPDL_INDEX ();
1466 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1468 do_mouse_tracking
= Qt
;
1470 val
= Fprogn (args
);
1471 return unbind_to (count
, val
);
1474 /* If mouse has moved on some frame, return one of those frames.
1478 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1479 after resizing the tool-bar window. */
1481 int ignore_mouse_drag_p
;
1486 Lisp_Object tail
, frame
;
1488 if (ignore_mouse_drag_p
)
1490 /* ignore_mouse_drag_p = 0; */
1494 FOR_EACH_FRAME (tail
, frame
)
1496 if (XFRAME (frame
)->mouse_moved
)
1497 return XFRAME (frame
);
1503 #endif /* HAVE_MOUSE || HAVE_GPM */
1505 /* This is the actual command reading loop,
1506 sans error-handling encapsulation. */
1508 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1510 void safe_run_hooks
P_ ((Lisp_Object
));
1511 static void adjust_point_for_property
P_ ((int, int));
1513 /* Cancel hourglass from protect_unwind.
1515 #ifdef HAVE_WINDOW_SYSTEM
1517 cancel_hourglass_unwind (arg
)
1520 cancel_hourglass ();
1525 extern int nonundocount
; /* Declared in cmds.c. */
1532 Lisp_Object keybuf
[30];
1534 int prev_modiff
= 0;
1535 struct buffer
*prev_buffer
= NULL
;
1536 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1537 int was_locked
= single_kboard
;
1539 int already_adjusted
= 0;
1541 current_kboard
->Vprefix_arg
= Qnil
;
1542 current_kboard
->Vlast_prefix_arg
= Qnil
;
1543 Vdeactivate_mark
= Qnil
;
1544 waiting_for_input
= 0;
1547 this_command_key_count
= 0;
1548 this_command_key_count_reset
= 0;
1549 this_single_command_key_start
= 0;
1551 if (NILP (Vmemory_full
))
1553 /* Make sure this hook runs after commands that get errors and
1554 throw to top level. */
1555 /* Note that the value cell will never directly contain nil
1556 if the symbol is a local variable. */
1557 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1558 safe_run_hooks (Qpost_command_hook
);
1560 /* If displaying a message, resize the echo area window to fit
1561 that message's size exactly. */
1562 if (!NILP (echo_area_buffer
[0]))
1563 resize_echo_area_exactly ();
1565 if (!NILP (Vdeferred_action_list
))
1566 safe_run_hooks (Qdeferred_action_function
);
1569 /* Do this after running Vpost_command_hook, for consistency. */
1570 current_kboard
->Vlast_command
= Vthis_command
;
1571 current_kboard
->Vreal_last_command
= real_this_command
;
1572 if (!CONSP (last_command_event
))
1573 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1577 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1580 /* Make sure the current window's buffer is selected. */
1581 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1582 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1584 /* Display any malloc warning that just came out. Use while because
1585 displaying one warning can cause another. */
1587 while (pending_malloc_warning
)
1588 display_malloc_warning ();
1590 Vdeactivate_mark
= Qnil
;
1592 /* If minibuffer on and echo area in use,
1593 wait a short time and redraw minibuffer. */
1596 && !NILP (echo_area_buffer
[0])
1597 && EQ (minibuf_window
, echo_area_window
)
1598 && NUMBERP (Vminibuffer_message_timeout
))
1600 /* Bind inhibit-quit to t so that C-g gets read in
1601 rather than quitting back to the minibuffer. */
1602 int count
= SPECPDL_INDEX ();
1603 specbind (Qinhibit_quit
, Qt
);
1605 sit_for (Vminibuffer_message_timeout
, 0, 2);
1607 /* Clear the echo area. */
1609 safe_run_hooks (Qecho_area_clear_hook
);
1611 unbind_to (count
, Qnil
);
1613 /* If a C-g came in before, treat it as input now. */
1614 if (!NILP (Vquit_flag
))
1617 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1622 /* Select the frame that the last event came from. Usually,
1623 switch-frame events will take care of this, but if some lisp
1624 code swallows a switch-frame event, we'll fix things up here.
1625 Is this a good idea? */
1626 if (FRAMEP (internal_last_event_frame
)
1627 && !EQ (internal_last_event_frame
, selected_frame
))
1628 Fselect_frame (internal_last_event_frame
, Qnil
);
1630 /* If it has changed current-menubar from previous value,
1631 really recompute the menubar from the value. */
1632 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1633 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1634 call0 (Qrecompute_lucid_menubar
);
1636 before_command_key_count
= this_command_key_count
;
1637 before_command_echo_length
= echo_length ();
1639 Vthis_command
= Qnil
;
1640 real_this_command
= Qnil
;
1641 Vthis_original_command
= Qnil
;
1642 Vthis_command_keys_shift_translated
= Qnil
;
1644 /* Read next key sequence; i gets its length. */
1645 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1648 /* A filter may have run while we were reading the input. */
1649 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1651 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1652 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1656 /* Now we have read a key sequence of length I,
1657 or else I is 0 and we found end of file. */
1659 if (i
== 0) /* End of file -- happens only in */
1660 return Qnil
; /* a kbd macro, at the end. */
1661 /* -1 means read_key_sequence got a menu that was rejected.
1662 Just loop around and read another command. */
1666 this_command_key_count
= 0;
1667 this_command_key_count_reset
= 0;
1668 this_single_command_key_start
= 0;
1672 last_command_event
= keybuf
[i
- 1];
1674 /* If the previous command tried to force a specific window-start,
1675 forget about that, in case this command moves point far away
1676 from that position. But also throw away beg_unchanged and
1677 end_unchanged information in that case, so that redisplay will
1678 update the whole window properly. */
1679 if (!NILP (XWINDOW (selected_window
)->force_start
))
1682 XWINDOW (selected_window
)->force_start
= Qnil
;
1683 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1684 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1687 cmd
= read_key_sequence_cmd
;
1688 if (!NILP (Vexecuting_kbd_macro
))
1690 if (!NILP (Vquit_flag
))
1692 Vexecuting_kbd_macro
= Qt
;
1693 QUIT
; /* Make some noise. */
1694 /* Will return since macro now empty. */
1698 /* Do redisplay processing after this command except in special
1699 cases identified below. */
1700 prev_buffer
= current_buffer
;
1701 prev_modiff
= MODIFF
;
1702 last_point_position
= PT
;
1703 last_point_position_window
= selected_window
;
1704 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1706 /* By default, we adjust point to a boundary of a region that
1707 has such a property that should be treated intangible
1708 (e.g. composition, display). But, some commands will set
1709 this variable differently. */
1710 Vdisable_point_adjustment
= Qnil
;
1712 /* Process filters and timers may have messed with deactivate-mark.
1713 reset it before we execute the command. */
1714 Vdeactivate_mark
= Qnil
;
1716 /* Remap command through active keymaps */
1717 Vthis_original_command
= cmd
;
1721 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1725 /* Execute the command. */
1727 Vthis_command
= cmd
;
1728 real_this_command
= cmd
;
1729 /* Note that the value cell will never directly contain nil
1730 if the symbol is a local variable. */
1731 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1732 safe_run_hooks (Qpre_command_hook
);
1734 already_adjusted
= 0;
1736 if (NILP (Vthis_command
))
1738 /* nil means key is undefined. */
1739 Lisp_Object keys
= Fvector (i
, keybuf
);
1740 keys
= Fkey_description (keys
, Qnil
);
1742 message_with_string ("%s is undefined", keys
, 0);
1743 current_kboard
->defining_kbd_macro
= Qnil
;
1744 update_mode_lines
= 1;
1745 current_kboard
->Vprefix_arg
= Qnil
;
1749 if (NILP (current_kboard
->Vprefix_arg
))
1751 /* In case we jump to directly_done. */
1752 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1754 /* Recognize some common commands in common situations and
1755 do them directly. */
1756 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
1757 && NILP (Vthis_command_keys_shift_translated
)
1758 && !CONSP (Vtransient_mark_mode
))
1760 struct Lisp_Char_Table
*dp
1761 = window_display_table (XWINDOW (selected_window
));
1762 lose
= FETCH_CHAR (PT_BYTE
);
1764 if (! NILP (Vpost_command_hook
))
1765 /* Put this before calling adjust_point_for_property
1766 so it will only get called once in any case. */
1768 if (current_buffer
== prev_buffer
1769 && last_point_position
!= PT
1770 && NILP (Vdisable_point_adjustment
)
1771 && NILP (Vglobal_disable_point_adjustment
))
1772 adjust_point_for_property (last_point_position
, 0);
1773 already_adjusted
= 1;
1774 if (PT
== last_point_position
+ 1
1776 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1777 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1778 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1779 && (lose
>= 0x20 && lose
< 0x7f)))
1780 : (lose
>= 0x20 && lose
< 0x7f))
1781 /* To extract the case of continuation on
1782 wide-column characters. */
1783 && ASCII_BYTE_P (lose
)
1784 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1786 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1788 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1790 && !windows_or_buffers_changed
1791 && EQ (current_buffer
->selective_display
, Qnil
)
1792 && !detect_input_pending ()
1793 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1794 && NILP (Vexecuting_kbd_macro
))
1795 direct_output_forward_char (1);
1798 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
1799 && NILP (Vthis_command_keys_shift_translated
)
1800 && !CONSP (Vtransient_mark_mode
))
1802 struct Lisp_Char_Table
*dp
1803 = window_display_table (XWINDOW (selected_window
));
1805 lose
= FETCH_CHAR (PT_BYTE
);
1806 if (! NILP (Vpost_command_hook
))
1808 if (current_buffer
== prev_buffer
1809 && last_point_position
!= PT
1810 && NILP (Vdisable_point_adjustment
)
1811 && NILP (Vglobal_disable_point_adjustment
))
1812 adjust_point_for_property (last_point_position
, 0);
1813 already_adjusted
= 1;
1814 if (PT
== last_point_position
- 1
1816 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1817 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1818 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1819 && (lose
>= 0x20 && lose
< 0x7f)))
1820 : (lose
>= 0x20 && lose
< 0x7f))
1821 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1823 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1825 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1827 && !windows_or_buffers_changed
1828 && EQ (current_buffer
->selective_display
, Qnil
)
1829 && !detect_input_pending ()
1830 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1831 && NILP (Vexecuting_kbd_macro
))
1832 direct_output_forward_char (-1);
1835 else if (EQ (Vthis_command
, Qself_insert_command
)
1836 /* Try this optimization only on char keystrokes. */
1837 && NATNUMP (last_command_event
)
1838 && CHAR_VALID_P (XFASTINT (last_command_event
), 0))
1841 = translate_char (Vtranslation_table_for_input
,
1842 XFASTINT (last_command_event
));
1844 if (NILP (Vexecuting_kbd_macro
)
1845 && !EQ (minibuf_window
, selected_window
))
1847 if (!nonundocount
|| nonundocount
>= 20)
1855 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1857 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1859 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1861 || MODIFF
<= SAVE_MODIFF
1862 || windows_or_buffers_changed
1863 || !EQ (current_buffer
->selective_display
, Qnil
)
1864 || detect_input_pending ()
1865 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1866 || !NILP (Vexecuting_kbd_macro
));
1868 value
= internal_self_insert (c
, 0);
1873 frame_make_pointer_invisible ();
1875 if (! NILP (Vpost_command_hook
))
1876 /* Put this before calling adjust_point_for_property
1877 so it will only get called once in any case. */
1880 /* VALUE == 1 when AFTER-CHANGE functions are
1881 installed which is the case most of the time
1882 because FONT-LOCK installs one. */
1883 if (!lose
&& !value
)
1884 direct_output_for_insert (c
);
1889 /* Here for a command that isn't executed directly */
1892 #ifdef HAVE_WINDOW_SYSTEM
1893 int scount
= SPECPDL_INDEX ();
1895 if (display_hourglass_p
1896 && NILP (Vexecuting_kbd_macro
))
1898 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1904 if (NILP (current_kboard
->Vprefix_arg
)) /* FIXME: Why? --Stef */
1906 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1908 #ifdef HAVE_WINDOW_SYSTEM
1909 /* Do not check display_hourglass_p here, because
1910 Fcommand_execute could change it, but we should cancel
1911 hourglass cursor anyway.
1912 But don't cancel the hourglass within a macro
1913 just because a command in the macro finishes. */
1914 if (NILP (Vexecuting_kbd_macro
))
1915 unbind_to (scount
, Qnil
);
1920 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1922 /* Note that the value cell will never directly contain nil
1923 if the symbol is a local variable. */
1924 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1925 safe_run_hooks (Qpost_command_hook
);
1927 /* If displaying a message, resize the echo area window to fit
1928 that message's size exactly. */
1929 if (!NILP (echo_area_buffer
[0]))
1930 resize_echo_area_exactly ();
1932 if (!NILP (Vdeferred_action_list
))
1933 safe_run_hooks (Qdeferred_action_function
);
1935 /* If there is a prefix argument,
1936 1) We don't want Vlast_command to be ``universal-argument''
1937 (that would be dumb), so don't set Vlast_command,
1938 2) we want to leave echoing on so that the prefix will be
1939 echoed as part of this key sequence, so don't call
1941 3) we want to leave this_command_key_count non-zero, so that
1942 read_char will realize that it is re-reading a character, and
1943 not echo it a second time.
1945 If the command didn't actually create a prefix arg,
1946 but is merely a frame event that is transparent to prefix args,
1947 then the above doesn't apply. */
1948 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_event
))
1950 current_kboard
->Vlast_command
= Vthis_command
;
1951 current_kboard
->Vreal_last_command
= real_this_command
;
1952 if (!CONSP (last_command_event
))
1953 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1955 this_command_key_count
= 0;
1956 this_command_key_count_reset
= 0;
1957 this_single_command_key_start
= 0;
1960 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1962 /* In Emacs 22, setting transient-mark-mode to `only' was a
1963 way of turning it on for just one command. This usage is
1964 obsolete, but support it anyway. */
1965 if (EQ (Vtransient_mark_mode
, Qidentity
))
1966 Vtransient_mark_mode
= Qnil
;
1967 else if (EQ (Vtransient_mark_mode
, Qonly
))
1968 Vtransient_mark_mode
= Qidentity
;
1970 if (!NILP (Vdeactivate_mark
))
1971 call0 (Qdeactivate_mark
);
1972 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1973 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1978 if (current_buffer
== prev_buffer
1979 && last_point_position
!= PT
1980 && NILP (Vdisable_point_adjustment
)
1981 && NILP (Vglobal_disable_point_adjustment
))
1983 if (last_point_position
> BEGV
1984 && last_point_position
< ZV
1985 && (composition_adjust_point (last_point_position
,
1986 last_point_position
)
1987 != last_point_position
))
1988 /* The last point was temporarily set within a grapheme
1989 cluster to prevent automatic composition. To recover
1990 the automatic composition, we must update the
1992 windows_or_buffers_changed
++;
1993 if (!already_adjusted
)
1994 adjust_point_for_property (last_point_position
,
1995 MODIFF
!= prev_modiff
);
1998 /* Install chars successfully executed in kbd macro. */
2000 if (!NILP (current_kboard
->defining_kbd_macro
)
2001 && NILP (current_kboard
->Vprefix_arg
))
2002 finalize_kbd_macro_chars ();
2003 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2005 any_kboard_state ();
2010 extern Lisp_Object Qcomposition
, Qdisplay
;
2012 /* Adjust point to a boundary of a region that has such a property
2013 that should be treated intangible. For the moment, we check
2014 `composition', `display' and `invisible' properties.
2015 LAST_PT is the last position of point. */
2017 extern Lisp_Object Qafter_string
, Qbefore_string
;
2018 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
2021 adjust_point_for_property (last_pt
, modified
)
2026 Lisp_Object val
, overlay
, tmp
;
2027 /* When called after buffer modification, we should temporarily
2028 suppress the point adjustment for automatic composition so that a
2029 user can keep inserting another character at point or keep
2030 deleting characters around point. */
2031 int check_composition
= ! modified
, check_display
= 1, check_invisible
= 1;
2034 /* FIXME: cycling is probably not necessary because these properties
2035 can't be usefully combined anyway. */
2036 while (check_composition
|| check_display
|| check_invisible
)
2038 /* FIXME: check `intangible'. */
2039 if (check_composition
2040 && PT
> BEGV
&& PT
< ZV
2041 && (beg
= composition_adjust_point (last_pt
, PT
)) != PT
)
2044 check_display
= check_invisible
= 1;
2046 check_composition
= 0;
2048 && PT
> BEGV
&& PT
< ZV
2049 && !NILP (val
= get_char_property_and_overlay
2050 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
2051 && display_prop_intangible_p (val
)
2052 && (!OVERLAYP (overlay
)
2053 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
2054 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
2055 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
2056 && (beg
< PT
/* && end > PT <- It's always the case. */
2057 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
2060 SET_PT (PT
< last_pt
2061 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
2063 check_composition
= check_invisible
= 1;
2066 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
2068 int inv
, ellipsis
= 0;
2071 /* Find boundaries `beg' and `end' of the invisible area, if any. */
2074 /* FIXME: We should stop if we find a spot between
2075 two runs of `invisible' where inserted text would
2076 be visible. This is important when we have two
2077 invisible boundaries that enclose an area: if the
2078 area is empty, we need this test in order to make
2079 it possible to place point in the middle rather
2080 than skip both boundaries. However, this code
2081 also stops anywhere in a non-sticky text-property,
2082 which breaks (e.g.) Org mode. */
2083 && (val
= get_pos_property (make_number (end
),
2085 TEXT_PROP_MEANS_INVISIBLE (val
))
2087 && !NILP (val
= get_char_property_and_overlay
2088 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
2089 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2091 ellipsis
= ellipsis
|| inv
> 1
2092 || (OVERLAYP (overlay
)
2093 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2094 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2095 tmp
= Fnext_single_char_property_change
2096 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
2097 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
2101 && (val
= get_pos_property (make_number (beg
),
2103 TEXT_PROP_MEANS_INVISIBLE (val
))
2105 && !NILP (val
= get_char_property_and_overlay
2106 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
2107 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
2109 ellipsis
= ellipsis
|| inv
> 1
2110 || (OVERLAYP (overlay
)
2111 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
2112 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
2113 tmp
= Fprevious_single_char_property_change
2114 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
2115 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
2118 /* Move away from the inside area. */
2119 if (beg
< PT
&& end
> PT
)
2121 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
2122 /* We haven't moved yet (so we don't need to fear
2123 infinite-looping) and we were outside the range
2124 before (so either end of the range still corresponds
2125 to a move in the right direction): pretend we moved
2126 less than we actually did, so that we still have
2127 more freedom below in choosing which end of the range
2129 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
2130 /* We either have moved already or the last point
2131 was already in the range: we don't get to choose
2132 which end of the range we have to go to. */
2133 : (PT
< last_pt
? beg
: end
));
2134 check_composition
= check_display
= 1;
2136 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
2137 the point to something other than its argument, due to
2138 point-motion hooks, intangibility, etc. */
2139 xassert (PT
== beg
|| PT
== end
);
2142 /* Pretend the area doesn't exist if the buffer is not
2144 if (!modified
&& !ellipsis
&& beg
< end
)
2146 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
2147 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
2148 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
2149 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
2150 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
2151 /* We've already moved as far as we can. Trying to go
2152 to the other end would mean moving backwards and thus
2153 could lead to an infinite loop. */
2155 else if (val
= get_pos_property (make_number (PT
),
2157 TEXT_PROP_MEANS_INVISIBLE (val
)
2158 && (val
= get_pos_property
2159 (make_number (PT
== beg
? end
: beg
),
2161 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2162 (check_composition
= check_display
= 1,
2163 SET_PT (PT
== beg
? end
: beg
));
2166 check_invisible
= 0;
2170 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2173 safe_run_hooks_1 (hook
)
2176 if (NILP (Vrun_hooks
))
2178 return call1 (Vrun_hooks
, Vinhibit_quit
);
2181 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2184 safe_run_hooks_error (data
)
2187 Lisp_Object args
[3];
2188 args
[0] = build_string ("Error in %s: %s");
2189 args
[1] = Vinhibit_quit
;
2192 return Fset (Vinhibit_quit
, Qnil
);
2195 /* If we get an error while running the hook, cause the hook variable
2196 to be nil. Also inhibit quits, so that C-g won't cause the hook
2197 to mysteriously evaporate. */
2200 safe_run_hooks (hook
)
2203 int count
= SPECPDL_INDEX ();
2204 specbind (Qinhibit_quit
, hook
);
2206 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2208 unbind_to (count
, Qnil
);
2212 /* Number of seconds between polling for input. This is a Lisp
2213 variable that can be bound. */
2215 EMACS_INT polling_period
;
2217 /* Nonzero means polling for input is temporarily suppressed. */
2219 int poll_suppress_count
;
2221 /* Asynchronous timer for polling. */
2223 struct atimer
*poll_timer
;
2226 #ifdef POLL_FOR_INPUT
2228 /* Poll for input, so that we catch a C-g if it comes in. This
2229 function is called from x_make_frame_visible, see comment
2235 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
2236 doing anything dangerous. */
2240 if (interrupt_input_blocked
== 0
2241 && !waiting_for_input
)
2242 read_avail_input (0);
2248 /* Timer callback function for poll_timer. TIMER is equal to
2252 poll_for_input (timer
)
2253 struct atimer
*timer
;
2255 if (poll_suppress_count
== 0)
2258 interrupt_input_pending
= 1;
2259 pending_signals
= 1;
2261 poll_for_input_1 ();
2266 #endif /* POLL_FOR_INPUT */
2268 /* Begin signals to poll for input, if they are appropriate.
2269 This function is called unconditionally from various places. */
2274 #ifdef POLL_FOR_INPUT
2275 /* XXX This condition was (read_socket_hook && !interrupt_input),
2276 but read_socket_hook is not global anymore. Let's pretend that
2278 if (!interrupt_input
)
2280 /* Turn alarm handling on unconditionally. It might have
2281 been turned off in process.c. */
2282 turn_on_atimers (1);
2284 /* If poll timer doesn't exist, are we need one with
2285 a different interval, start a new one. */
2286 if (poll_timer
== NULL
2287 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2289 EMACS_TIME interval
;
2292 cancel_atimer (poll_timer
);
2294 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2295 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2296 poll_for_input
, NULL
);
2299 /* Let the timer's callback function poll for input
2300 if this becomes zero. */
2301 --poll_suppress_count
;
2306 /* Nonzero if we are using polling to handle input asynchronously. */
2309 input_polling_used ()
2311 #ifdef POLL_FOR_INPUT
2312 /* XXX This condition was (read_socket_hook && !interrupt_input),
2313 but read_socket_hook is not global anymore. Let's pretend that
2315 return !interrupt_input
;
2321 /* Turn off polling. */
2326 #ifdef POLL_FOR_INPUT
2327 /* XXX This condition was (read_socket_hook && !interrupt_input),
2328 but read_socket_hook is not global anymore. Let's pretend that
2330 if (!interrupt_input
)
2331 ++poll_suppress_count
;
2335 /* Set the value of poll_suppress_count to COUNT
2336 and start or stop polling accordingly. */
2339 set_poll_suppress_count (count
)
2342 #ifdef POLL_FOR_INPUT
2343 if (count
== 0 && poll_suppress_count
!= 0)
2345 poll_suppress_count
= 1;
2348 else if (count
!= 0 && poll_suppress_count
== 0)
2352 poll_suppress_count
= count
;
2356 /* Bind polling_period to a value at least N.
2357 But don't decrease it. */
2360 bind_polling_period (n
)
2363 #ifdef POLL_FOR_INPUT
2364 int new = polling_period
;
2369 stop_other_atimers (poll_timer
);
2371 specbind (Qpolling_period
, make_number (new));
2372 /* Start a new alarm with the new period. */
2377 /* Apply the control modifier to CHARACTER. */
2383 /* Save the upper bits here. */
2384 int upper
= c
& ~0177;
2386 if (! ASCII_BYTE_P (c
))
2387 return c
|= ctrl_modifier
;
2391 /* Everything in the columns containing the upper-case letters
2392 denotes a control character. */
2393 if (c
>= 0100 && c
< 0140)
2397 /* Set the shift modifier for a control char
2398 made from a shifted letter. But only for letters! */
2399 if (oc
>= 'A' && oc
<= 'Z')
2400 c
|= shift_modifier
;
2403 /* The lower-case letters denote control characters too. */
2404 else if (c
>= 'a' && c
<= 'z')
2407 /* Include the bits for control and shift
2408 only if the basic ASCII code can't indicate them. */
2412 /* Replace the high bits. */
2413 c
|= (upper
& ~ctrl_modifier
);
2418 /* Display the help-echo property of the character after the mouse pointer.
2419 Either show it in the echo area, or call show-help-function to display
2420 it by other means (maybe in a tooltip).
2422 If HELP is nil, that means clear the previous help echo.
2424 If HELP is a string, display that string. If HELP is a function,
2425 call it with OBJECT and POS as arguments; the function should
2426 return a help string or nil for none. For all other types of HELP,
2427 evaluate it to obtain a string.
2429 WINDOW is the window in which the help was generated, if any.
2430 It is nil if not in a window.
2432 If OBJECT is a buffer, POS is the position in the buffer where the
2433 `help-echo' text property was found.
2435 If OBJECT is an overlay, that overlay has a `help-echo' property,
2436 and POS is the position in the overlay's buffer under the mouse.
2438 If OBJECT is a string (an overlay string or a string displayed with
2439 the `display' property). POS is the position in that string under
2442 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2443 echo overwrites a keystroke echo currently displayed in the echo
2446 Note: this function may only be called with HELP nil or a string
2447 from X code running asynchronously. */
2450 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2451 Lisp_Object help
, window
, object
, pos
;
2452 int ok_to_overwrite_keystroke_echo
;
2454 if (!NILP (help
) && !STRINGP (help
))
2456 if (FUNCTIONP (help
))
2458 Lisp_Object args
[4];
2463 help
= safe_call (4, args
);
2466 help
= safe_eval (help
);
2468 if (!STRINGP (help
))
2472 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2473 if (!noninteractive
&& STRINGP (help
))
2475 /* The mouse-fixup-help-message Lisp function can call
2476 mouse_position_hook, which resets the mouse_moved flags.
2477 This causes trouble if we are trying to read a mouse motion
2478 event (i.e., if we are inside a `track-mouse' form), so we
2479 restore the mouse_moved flag. */
2480 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2481 help
= call1 (Qmouse_fixup_help_message
, help
);
2487 if (STRINGP (help
) || NILP (help
))
2489 if (!NILP (Vshow_help_function
))
2490 call1 (Vshow_help_function
, help
);
2491 help_echo_showing_p
= STRINGP (help
);
2497 /* Input of single characters from keyboard */
2499 Lisp_Object
print_help ();
2500 static Lisp_Object
kbd_buffer_get_event ();
2501 static void record_char ();
2503 static Lisp_Object help_form_saved_window_configs
;
2505 read_char_help_form_unwind (Lisp_Object arg
)
2507 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2508 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2509 if (!NILP (window_config
))
2510 Fset_window_configuration (window_config
);
2514 #define STOP_POLLING \
2515 do { if (! polling_stopped_here) stop_polling (); \
2516 polling_stopped_here = 1; } while (0)
2518 #define RESUME_POLLING \
2519 do { if (polling_stopped_here) start_polling (); \
2520 polling_stopped_here = 0; } while (0)
2522 /* read a character from the keyboard; call the redisplay if needed */
2523 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2524 -1 means do not do redisplay, but do do autosaving.
2527 /* The arguments MAPS and NMAPS are for menu prompting.
2528 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2530 PREV_EVENT is the previous input event, or nil if we are reading
2531 the first event of a key sequence (or not reading a key sequence).
2532 If PREV_EVENT is t, that is a "magic" value that says
2533 not to run input methods, but in other respects to act as if
2534 not reading a key sequence.
2536 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2537 if we used a mouse menu to read the input, or zero otherwise. If
2538 USED_MOUSE_MENU is null, we don't dereference it.
2540 Value is -2 when we find input on another keyboard. A second call
2541 to read_char will read it.
2543 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2544 specifying the maximum time to wait until. If no input arrives by
2545 that time, stop waiting and return nil.
2547 Value is t if we showed a menu and the user rejected it. */
2550 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
, end_time
)
2554 Lisp_Object prev_event
;
2555 int *used_mouse_menu
;
2556 EMACS_TIME
*end_time
;
2558 volatile Lisp_Object c
;
2559 int count
, jmpcount
;
2560 jmp_buf local_getcjmp
;
2562 volatile int key_already_recorded
= 0;
2563 Lisp_Object tem
, save
;
2564 volatile Lisp_Object previous_echo_area_message
;
2565 volatile Lisp_Object also_record
;
2566 volatile int reread
;
2567 struct gcpro gcpro1
, gcpro2
;
2568 int polling_stopped_here
= 0;
2569 struct kboard
*orig_kboard
= current_kboard
;
2573 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2574 before_command_key_count
= this_command_key_count
;
2575 before_command_echo_length
= echo_length ();
2578 previous_echo_area_message
= Qnil
;
2580 GCPRO2 (c
, previous_echo_area_message
);
2585 if (CONSP (Vunread_post_input_method_events
))
2587 c
= XCAR (Vunread_post_input_method_events
);
2588 Vunread_post_input_method_events
2589 = XCDR (Vunread_post_input_method_events
);
2591 /* Undo what read_char_x_menu_prompt did when it unread
2592 additional keys returned by Fx_popup_menu. */
2594 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2602 if (unread_command_char
!= -1)
2604 XSETINT (c
, unread_command_char
);
2605 unread_command_char
= -1;
2611 if (CONSP (Vunread_command_events
))
2613 int was_disabled
= 0;
2615 c
= XCAR (Vunread_command_events
);
2616 Vunread_command_events
= XCDR (Vunread_command_events
);
2620 /* Undo what sit-for did when it unread additional keys
2621 inside universal-argument. */
2624 && EQ (XCAR (c
), Qt
))
2630 /* Undo what read_char_x_menu_prompt did when it unread
2631 additional keys returned by Fx_popup_menu. */
2633 && EQ (XCDR (c
), Qdisabled
)
2634 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2640 /* If the queued event is something that used the mouse,
2641 set used_mouse_menu accordingly. */
2643 /* Also check was_disabled so last-nonmenu-event won't return
2644 a bad value when submenus are involved. (Bug#447) */
2645 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
) || was_disabled
))
2646 *used_mouse_menu
= 1;
2648 goto reread_for_input_method
;
2651 if (CONSP (Vunread_input_method_events
))
2653 c
= XCAR (Vunread_input_method_events
);
2654 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2656 /* Undo what read_char_x_menu_prompt did when it unread
2657 additional keys returned by Fx_popup_menu. */
2659 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2663 goto reread_for_input_method
;
2666 this_command_key_count_reset
= 0;
2668 if (!NILP (Vexecuting_kbd_macro
))
2670 /* We set this to Qmacro; since that's not a frame, nobody will
2671 try to switch frames on us, and the selected window will
2674 Since this event came from a macro, it would be misleading to
2675 leave internal_last_event_frame set to wherever the last
2676 real event came from. Normally, a switch-frame event selects
2677 internal_last_event_frame after each command is read, but
2678 events read from a macro should never cause a new frame to be
2680 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2682 /* Exit the macro if we are at the end.
2683 Also, some things replace the macro with t
2684 to force an early exit. */
2685 if (EQ (Vexecuting_kbd_macro
, Qt
)
2686 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2692 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2693 if (STRINGP (Vexecuting_kbd_macro
)
2694 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2695 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2697 executing_kbd_macro_index
++;
2702 if (!NILP (unread_switch_frame
))
2704 c
= unread_switch_frame
;
2705 unread_switch_frame
= Qnil
;
2707 /* This event should make it into this_command_keys, and get echoed
2708 again, so we do not set `reread'. */
2712 /* if redisplay was requested */
2713 if (commandflag
>= 0)
2715 int echo_current
= EQ (echo_message_buffer
, echo_area_buffer
[0]);
2717 /* If there is pending input, process any events which are not
2718 user-visible, such as X selection_request events. */
2720 || detect_input_pending_run_timers (0))
2721 swallow_events (0); /* may clear input_pending */
2723 /* Redisplay if no pending input. */
2724 while (!input_pending
)
2726 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2727 redisplay_preserve_echo_area (5);
2732 /* Normal case: no input arrived during redisplay. */
2735 /* Input arrived and pre-empted redisplay.
2736 Process any events which are not user-visible. */
2738 /* If that cleared input_pending, try again to redisplay. */
2741 /* Prevent the redisplay we just did
2742 from messing up echoing of the input after the prompt. */
2743 if (commandflag
== 0 && echo_current
)
2744 echo_message_buffer
= echo_area_buffer
[0];
2748 /* Message turns off echoing unless more keystrokes turn it on again.
2750 The code in 20.x for the condition was
2752 1. echo_area_glyphs && *echo_area_glyphs
2753 2. && echo_area_glyphs != current_kboard->echobuf
2754 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2756 (1) means there's a current message displayed
2758 (2) means it's not the message from echoing from the current
2761 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2762 is set to a non-null value. This is done in read_char and it is
2763 set to echo_area_glyphs after a call to echo_char. That means
2764 ok_to_echo_at_next_pause is either null or
2765 current_kboard->echobuf with the appropriate current_kboard at
2768 So, condition (3) means in clear text ok_to_echo_at_next_pause
2769 must be either null, or the current message isn't from echoing at
2770 all, or it's from echoing from a different kboard than the
2773 if (/* There currently is something in the echo area. */
2774 !NILP (echo_area_buffer
[0])
2775 && (/* And it's either not from echoing. */
2776 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2777 /* Or it's an echo from a different kboard. */
2778 || echo_kboard
!= current_kboard
2779 /* Or we explicitly allow overwriting whatever there is. */
2780 || ok_to_echo_at_next_pause
== NULL
))
2785 /* Try reading a character via menu prompting in the minibuf.
2786 Try this before the sit-for, because the sit-for
2787 would do the wrong thing if we are supposed to do
2788 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2789 after a mouse event so don't try a minibuf menu. */
2791 if (nmaps
> 0 && INTERACTIVE
2792 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2793 /* Don't bring up a menu if we already have another event. */
2794 && NILP (Vunread_command_events
)
2795 && unread_command_char
< 0
2796 && !detect_input_pending_run_timers (0))
2798 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2800 if (INTEGERP (c
) && XINT (c
) == -2)
2801 return c
; /* wrong_kboard_jmpbuf */
2805 key_already_recorded
= 1;
2810 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2811 We will do that below, temporarily for short sections of code,
2812 when appropriate. local_getcjmp must be in effect
2813 around any call to sit_for or kbd_buffer_get_event;
2814 it *must not* be in effect when we call redisplay. */
2816 jmpcount
= SPECPDL_INDEX ();
2817 if (_setjmp (local_getcjmp
))
2819 /* Handle quits while reading the keyboard. */
2820 /* We must have saved the outer value of getcjmp here,
2821 so restore it now. */
2822 restore_getcjmp (save_jump
);
2823 unbind_to (jmpcount
, Qnil
);
2824 XSETINT (c
, quit_char
);
2825 internal_last_event_frame
= selected_frame
;
2826 Vlast_event_frame
= internal_last_event_frame
;
2827 /* If we report the quit char as an event,
2828 don't do so more than once. */
2829 if (!NILP (Vinhibit_quit
))
2833 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2834 if (kb
!= current_kboard
)
2836 Lisp_Object link
= kb
->kbd_queue
;
2837 /* We shouldn't get here if we were in single-kboard mode! */
2842 while (CONSP (XCDR (link
)))
2844 if (!NILP (XCDR (link
)))
2848 kb
->kbd_queue
= Fcons (c
, Qnil
);
2850 XSETCDR (link
, Fcons (c
, Qnil
));
2851 kb
->kbd_queue_has_data
= 1;
2852 current_kboard
= kb
;
2853 /* This is going to exit from read_char
2854 so we had better get rid of this frame's stuff. */
2856 return make_number (-2); /* wrong_kboard_jmpbuf */
2862 /* Start idle timers if no time limit is supplied. We don't do it
2863 if a time limit is supplied to avoid an infinite recursion in the
2864 situation where an idle timer calls `sit-for'. */
2867 timer_start_idle ();
2869 /* If in middle of key sequence and minibuffer not active,
2870 start echoing if enough time elapses. */
2872 if (minibuf_level
== 0
2874 && !current_kboard
->immediate_echo
2875 && this_command_key_count
> 0
2877 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2878 && NILP (Fzerop (Vecho_keystrokes
))
2879 && (/* No message. */
2880 NILP (echo_area_buffer
[0])
2881 /* Or empty message. */
2882 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2883 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2884 /* Or already echoing from same kboard. */
2885 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2886 /* Or not echoing before and echoing allowed. */
2887 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2889 /* After a mouse event, start echoing right away.
2890 This is because we are probably about to display a menu,
2891 and we don't want to delay before doing so. */
2892 if (EVENT_HAS_PARAMETERS (prev_event
))
2898 save_getcjmp (save_jump
);
2899 restore_getcjmp (local_getcjmp
);
2900 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2901 restore_getcjmp (save_jump
);
2903 && ! CONSP (Vunread_command_events
))
2908 /* Maybe auto save due to number of keystrokes. */
2910 if (commandflag
!= 0
2911 && auto_save_interval
> 0
2912 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2913 && !detect_input_pending_run_timers (0))
2915 Fdo_auto_save (Qnil
, Qnil
);
2916 /* Hooks can actually change some buffers in auto save. */
2920 /* Try reading using an X menu.
2921 This is never confused with reading using the minibuf
2922 because the recursive call of read_char in read_char_minibuf_menu_prompt
2923 does not pass on any keymaps. */
2925 if (nmaps
> 0 && INTERACTIVE
2926 && !NILP (prev_event
)
2927 && EVENT_HAS_PARAMETERS (prev_event
)
2928 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2929 && !EQ (XCAR (prev_event
), Qtool_bar
)
2930 /* Don't bring up a menu if we already have another event. */
2931 && NILP (Vunread_command_events
)
2932 && unread_command_char
< 0)
2934 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2936 /* Now that we have read an event, Emacs is not idle. */
2943 /* Maybe autosave and/or garbage collect due to idleness. */
2945 if (INTERACTIVE
&& NILP (c
))
2947 int delay_level
, buffer_size
;
2949 /* Slow down auto saves logarithmically in size of current buffer,
2950 and garbage collect while we're at it. */
2951 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2952 last_non_minibuf_size
= Z
- BEG
;
2953 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2955 while (buffer_size
> 64)
2956 delay_level
++, buffer_size
-= buffer_size
>> 2;
2957 if (delay_level
< 4) delay_level
= 4;
2958 /* delay_level is 4 for files under around 50k, 7 at 100k,
2959 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2961 /* Auto save if enough time goes by without input. */
2962 if (commandflag
!= 0
2963 && num_nonmacro_input_events
> last_auto_save
2964 && INTEGERP (Vauto_save_timeout
)
2965 && XINT (Vauto_save_timeout
) > 0)
2968 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2970 save_getcjmp (save_jump
);
2971 restore_getcjmp (local_getcjmp
);
2972 tem0
= sit_for (make_number (timeout
), 1, 1);
2973 restore_getcjmp (save_jump
);
2976 && ! CONSP (Vunread_command_events
))
2978 Fdo_auto_save (Qnil
, Qnil
);
2980 /* If we have auto-saved and there is still no input
2981 available, garbage collect if there has been enough
2982 consing going on to make it worthwhile. */
2983 if (!detect_input_pending_run_timers (0)
2984 && consing_since_gc
> gc_cons_threshold
/ 2)
2985 Fgarbage_collect ();
2992 /* Notify the caller if an autosave hook, or a timer, sentinel or
2993 filter in the sit_for calls above have changed the current
2994 kboard. This could happen if they use the minibuffer or start a
2995 recursive edit, like the fancy splash screen in server.el's
2996 filter. If this longjmp wasn't here, read_key_sequence would
2997 interpret the next key sequence using the wrong translation
2998 tables and function keymaps. */
2999 if (NILP (c
) && current_kboard
!= orig_kboard
)
3002 return make_number (-2); /* wrong_kboard_jmpbuf */
3005 /* If this has become non-nil here, it has been set by a timer
3006 or sentinel or filter. */
3007 if (CONSP (Vunread_command_events
))
3009 c
= XCAR (Vunread_command_events
);
3010 Vunread_command_events
= XCDR (Vunread_command_events
);
3013 /* Read something from current KBOARD's side queue, if possible. */
3017 if (current_kboard
->kbd_queue_has_data
)
3019 if (!CONSP (current_kboard
->kbd_queue
))
3021 c
= XCAR (current_kboard
->kbd_queue
);
3022 current_kboard
->kbd_queue
3023 = XCDR (current_kboard
->kbd_queue
);
3024 if (NILP (current_kboard
->kbd_queue
))
3025 current_kboard
->kbd_queue_has_data
= 0;
3026 input_pending
= readable_events (0);
3027 if (EVENT_HAS_PARAMETERS (c
)
3028 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
3029 internal_last_event_frame
= XCAR (XCDR (c
));
3030 Vlast_event_frame
= internal_last_event_frame
;
3034 /* If current_kboard's side queue is empty check the other kboards.
3035 If one of them has data that we have not yet seen here,
3036 switch to it and process the data waiting for it.
3038 Note: if the events queued up for another kboard
3039 have already been seen here, and therefore are not a complete command,
3040 the kbd_queue_has_data field is 0, so we skip that kboard here.
3041 That's to avoid an infinite loop switching between kboards here. */
3042 if (NILP (c
) && !single_kboard
)
3045 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3046 if (kb
->kbd_queue_has_data
)
3048 current_kboard
= kb
;
3049 /* This is going to exit from read_char
3050 so we had better get rid of this frame's stuff. */
3052 return make_number (-2); /* wrong_kboard_jmpbuf */
3060 /* Finally, we read from the main queue,
3061 and if that gives us something we can't use yet, we put it on the
3062 appropriate side queue and try again. */
3071 EMACS_GET_TIME (now
);
3072 if (EMACS_TIME_GE (now
, *end_time
))
3076 /* Actually read a character, waiting if necessary. */
3077 save_getcjmp (save_jump
);
3078 restore_getcjmp (local_getcjmp
);
3080 timer_start_idle ();
3081 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
3082 restore_getcjmp (save_jump
);
3084 if (! NILP (c
) && (kb
!= current_kboard
))
3086 Lisp_Object link
= kb
->kbd_queue
;
3089 while (CONSP (XCDR (link
)))
3091 if (!NILP (XCDR (link
)))
3095 kb
->kbd_queue
= Fcons (c
, Qnil
);
3097 XSETCDR (link
, Fcons (c
, Qnil
));
3098 kb
->kbd_queue_has_data
= 1;
3102 current_kboard
= kb
;
3103 /* This is going to exit from read_char
3104 so we had better get rid of this frame's stuff. */
3106 return make_number (-2);
3110 /* Terminate Emacs in batch mode if at eof. */
3111 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
3112 Fkill_emacs (make_number (1));
3116 /* Add in any extra modifiers, where appropriate. */
3117 if ((extra_keyboard_modifiers
& CHAR_CTL
)
3118 || ((extra_keyboard_modifiers
& 0177) < ' '
3119 && (extra_keyboard_modifiers
& 0177) != 0))
3120 XSETINT (c
, make_ctrl_char (XINT (c
)));
3122 /* Transfer any other modifier bits directly from
3123 extra_keyboard_modifiers to c. Ignore the actual character code
3124 in the low 16 bits of extra_keyboard_modifiers. */
3125 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
3136 if (commandflag
>= 0
3137 && !input_pending
&& !detect_input_pending_run_timers (0))
3145 /* Buffer switch events are only for internal wakeups
3146 so don't show them to the user.
3147 Also, don't record a key if we already did. */
3148 if (BUFFERP (c
) || key_already_recorded
)
3151 /* Process special events within read_char
3152 and loop around to read another event. */
3155 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
3160 struct buffer
*prev_buffer
= current_buffer
;
3161 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3162 int was_locked
= single_kboard
;
3163 int count
= SPECPDL_INDEX ();
3164 record_single_kboard_state ();
3167 last_input_event
= c
;
3168 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_event
), Qt
);
3170 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
3171 /* We stopped being idle for this event; undo that. This
3172 prevents automatic window selection (under
3173 mouse_autoselect_window from acting as a real input event, for
3174 example banishing the mouse under mouse-avoidance-mode. */
3175 timer_resume_idle ();
3177 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3178 /* Resume allowing input from any kboard, if that was true before. */
3180 any_kboard_state ();
3181 unbind_to (count
, Qnil
);
3184 if (current_buffer
!= prev_buffer
)
3186 /* The command may have changed the keymaps. Pretend there
3187 is input in another keyboard and return. This will
3188 recalculate keymaps. */
3189 c
= make_number (-2);
3196 /* Handle things that only apply to characters. */
3199 /* If kbd_buffer_get_event gave us an EOF, return that. */
3203 if ((STRINGP (current_kboard
->Vkeyboard_translate_table
)
3204 && SCHARS (current_kboard
->Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
3205 || (VECTORP (current_kboard
->Vkeyboard_translate_table
)
3206 && XVECTOR (current_kboard
->Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
3207 || (CHAR_TABLE_P (current_kboard
->Vkeyboard_translate_table
)
3211 d
= Faref (current_kboard
->Vkeyboard_translate_table
, c
);
3212 /* nil in keyboard-translate-table means no translation. */
3218 /* If this event is a mouse click in the menu bar,
3219 return just menu-bar for now. Modify the mouse click event
3220 so we won't do this twice, then queue it up. */
3221 if (EVENT_HAS_PARAMETERS (c
)
3223 && CONSP (EVENT_START (c
))
3224 && CONSP (XCDR (EVENT_START (c
))))
3228 posn
= POSN_POSN (EVENT_START (c
));
3229 /* Handle menu-bar events:
3230 insert the dummy prefix event `menu-bar'. */
3231 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
3233 /* Change menu-bar to (menu-bar) as the event "position". */
3234 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
3237 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
3242 /* Store these characters into recent_keys, the dribble file if any,
3243 and the keyboard macro being defined, if any. */
3245 if (! NILP (also_record
))
3246 record_char (also_record
);
3248 /* Wipe the echo area.
3249 But first, if we are about to use an input method,
3250 save the echo area contents for it to refer to. */
3252 && ! NILP (Vinput_method_function
)
3253 && (unsigned) XINT (c
) >= ' '
3254 && (unsigned) XINT (c
) != 127
3255 && (unsigned) XINT (c
) < 256)
3257 previous_echo_area_message
= Fcurrent_message ();
3258 Vinput_method_previous_message
= previous_echo_area_message
;
3261 /* Now wipe the echo area, except for help events which do their
3262 own stuff with the echo area. */
3264 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3265 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3267 if (!NILP (echo_area_buffer
[0]))
3268 safe_run_hooks (Qecho_area_clear_hook
);
3269 clear_message (1, 0);
3272 reread_for_input_method
:
3274 /* Pass this to the input method, if appropriate. */
3276 && ! NILP (Vinput_method_function
)
3277 /* Don't run the input method within a key sequence,
3278 after the first event of the key sequence. */
3279 && NILP (prev_event
)
3280 && (unsigned) XINT (c
) >= ' '
3281 && (unsigned) XINT (c
) != 127
3282 && (unsigned) XINT (c
) < 256)
3285 int key_count
, key_count_reset
;
3286 struct gcpro gcpro1
;
3287 int count
= SPECPDL_INDEX ();
3289 /* Save the echo status. */
3290 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3291 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3292 Lisp_Object saved_echo_string
= current_kboard
->echo_string
;
3293 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3296 if (before_command_restore_flag
)
3298 this_command_key_count
= before_command_key_count_1
;
3299 if (this_command_key_count
< this_single_command_key_start
)
3300 this_single_command_key_start
= this_command_key_count
;
3301 echo_truncate (before_command_echo_length_1
);
3302 before_command_restore_flag
= 0;
3306 /* Save the this_command_keys status. */
3307 key_count
= this_command_key_count
;
3308 key_count_reset
= this_command_key_count_reset
;
3311 keys
= Fcopy_sequence (this_command_keys
);
3316 /* Clear out this_command_keys. */
3317 this_command_key_count
= 0;
3318 this_command_key_count_reset
= 0;
3320 /* Now wipe the echo area. */
3321 if (!NILP (echo_area_buffer
[0]))
3322 safe_run_hooks (Qecho_area_clear_hook
);
3323 clear_message (1, 0);
3326 /* If we are not reading a key sequence,
3327 never use the echo area. */
3330 specbind (Qinput_method_use_echo_area
, Qt
);
3333 /* Call the input method. */
3334 tem
= call1 (Vinput_method_function
, c
);
3336 tem
= unbind_to (count
, tem
);
3338 /* Restore the saved echoing state
3339 and this_command_keys state. */
3340 this_command_key_count
= key_count
;
3341 this_command_key_count_reset
= key_count_reset
;
3343 this_command_keys
= keys
;
3346 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3347 current_kboard
->echo_string
= saved_echo_string
;
3348 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3349 if (saved_immediate_echo
)
3354 /* The input method can return no events. */
3357 /* Bring back the previous message, if any. */
3358 if (! NILP (previous_echo_area_message
))
3359 message_with_string ("%s", previous_echo_area_message
, 0);
3362 /* It returned one event or more. */
3364 Vunread_post_input_method_events
3365 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3370 /* Display help if not echoing. */
3371 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3373 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3374 Lisp_Object help
, object
, position
, window
, tem
;
3376 tem
= Fcdr (XCDR (c
));
3379 window
= Fcar (tem
);
3381 object
= Fcar (tem
);
3383 position
= Fcar (tem
);
3385 show_help_echo (help
, window
, object
, position
, 0);
3387 /* We stopped being idle for this event; undo that. */
3389 timer_resume_idle ();
3393 if ((! reread
|| this_command_key_count
== 0
3394 || this_command_key_count_reset
)
3398 /* Don't echo mouse motion events. */
3399 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3400 && NILP (Fzerop (Vecho_keystrokes
))
3401 && ! (EVENT_HAS_PARAMETERS (c
)
3402 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3405 if (! NILP (also_record
))
3406 echo_char (also_record
);
3407 /* Once we reread a character, echoing can happen
3408 the next time we pause to read a new one. */
3409 ok_to_echo_at_next_pause
= current_kboard
;
3412 /* Record this character as part of the current key. */
3413 add_command_key (c
);
3414 if (! NILP (also_record
))
3415 add_command_key (also_record
);
3418 last_input_event
= c
;
3421 /* Process the help character specially if enabled */
3422 if (!NILP (Vhelp_form
) && help_char_p (c
))
3425 count
= SPECPDL_INDEX ();
3427 help_form_saved_window_configs
3428 = Fcons (Fcurrent_window_configuration (Qnil
),
3429 help_form_saved_window_configs
);
3430 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3432 tem0
= Feval (Vhelp_form
);
3434 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3439 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3440 if (EVENT_HAS_PARAMETERS (c
)
3441 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3442 XSETCAR (help_form_saved_window_configs
, Qnil
);
3444 while (BUFFERP (c
));
3445 /* Remove the help from the frame */
3446 unbind_to (count
, Qnil
);
3449 if (EQ (c
, make_number (040)))
3453 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3454 while (BUFFERP (c
));
3463 /* Record a key that came from a mouse menu.
3464 Record it for echoing, for this-command-keys, and so on. */
3470 /* Wipe the echo area. */
3471 clear_message (1, 0);
3476 before_command_key_count
= this_command_key_count
;
3477 before_command_echo_length
= echo_length ();
3480 /* Don't echo mouse motion events. */
3481 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3482 && NILP (Fzerop (Vecho_keystrokes
)))
3486 /* Once we reread a character, echoing can happen
3487 the next time we pause to read a new one. */
3488 ok_to_echo_at_next_pause
= 0;
3491 /* Record this character as part of the current key. */
3492 add_command_key (c
);
3494 /* Re-reading in the middle of a command */
3495 last_input_event
= c
;
3499 /* Return 1 if should recognize C as "the help character". */
3507 if (EQ (c
, Vhelp_char
))
3509 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3510 if (EQ (c
, XCAR (tail
)))
3515 /* Record the input event C in various ways. */
3523 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3525 /* To avoid filling recent_keys with help-echo and mouse-movement
3526 events, we filter out repeated help-echo events, only store the
3527 first and last in a series of mouse-movement events, and don't
3528 store repeated help-echo events which are only separated by
3529 mouse-movement events. */
3531 Lisp_Object ev1
, ev2
, ev3
;
3534 if ((ix1
= recent_keys_index
- 1) < 0)
3535 ix1
= NUM_RECENT_KEYS
- 1;
3536 ev1
= AREF (recent_keys
, ix1
);
3538 if ((ix2
= ix1
- 1) < 0)
3539 ix2
= NUM_RECENT_KEYS
- 1;
3540 ev2
= AREF (recent_keys
, ix2
);
3542 if ((ix3
= ix2
- 1) < 0)
3543 ix3
= NUM_RECENT_KEYS
- 1;
3544 ev3
= AREF (recent_keys
, ix3
);
3546 if (EQ (XCAR (c
), Qhelp_echo
))
3548 /* Don't record `help-echo' in recent_keys unless it shows some help
3549 message, and a different help than the previously recorded
3551 Lisp_Object help
, last_help
;
3553 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3554 if (!STRINGP (help
))
3556 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3557 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3559 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3560 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3561 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3563 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3564 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3565 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3566 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3569 else if (EQ (XCAR (c
), Qmouse_movement
))
3571 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3572 So additional mouse movement events replace the last element. */
3573 Lisp_Object last_window
, window
;
3575 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3576 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3577 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3578 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3579 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3581 ASET (recent_keys
, ix1
, c
);
3587 store_kbd_macro_char (c
);
3592 ASET (recent_keys
, recent_keys_index
, c
);
3593 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3594 recent_keys_index
= 0;
3596 else if (recorded
< 0)
3598 /* We need to remove one or two events from recent_keys.
3599 To do this, we simply put nil at those events and move the
3600 recent_keys_index backwards over those events. Usually,
3601 users will never see those nil events, as they will be
3602 overwritten by the command keys entered to see recent_keys
3605 while (recorded
++ < 0 && total_keys
> 0)
3607 if (total_keys
< NUM_RECENT_KEYS
)
3609 if (--recent_keys_index
< 0)
3610 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3611 ASET (recent_keys
, recent_keys_index
, Qnil
);
3615 num_nonmacro_input_events
++;
3617 /* Write c to the dribble file. If c is a lispy event, write
3618 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3619 If you, dear reader, have a better idea, you've got the source. :-) */
3625 if (XUINT (c
) < 0x100)
3626 putc (XINT (c
), dribble
);
3628 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3632 Lisp_Object dribblee
;
3634 /* If it's a structured event, take the event header. */
3635 dribblee
= EVENT_HEAD (c
);
3637 if (SYMBOLP (dribblee
))
3639 putc ('<', dribble
);
3640 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3641 SBYTES (SYMBOL_NAME (dribblee
)),
3643 putc ('>', dribble
);
3656 struct buffer
*old
= current_buffer
;
3657 Fprinc (object
, Qnil
);
3658 set_buffer_internal (XBUFFER (Vstandard_output
));
3659 call0 (intern ("help-mode"));
3660 set_buffer_internal (old
);
3664 /* Copy out or in the info on where C-g should throw to.
3665 This is used when running Lisp code from within get_char,
3666 in case get_char is called recursively.
3667 See read_process_output. */
3673 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3677 restore_getcjmp (temp
)
3680 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3683 /* Low level keyboard/mouse input.
3684 kbd_buffer_store_event places events in kbd_buffer, and
3685 kbd_buffer_get_event retrieves them. */
3687 /* Return true if there are any events in the queue that read-char
3688 would return. If this returns false, a read-char would block. */
3690 readable_events (flags
)
3694 /* Check whether a D-Bus message has arrived. */
3695 if (xd_pending_messages () > 0)
3697 #endif /* HAVE_DBUS */
3699 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3702 /* If the buffer contains only FOCUS_IN_EVENT events, and
3703 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3704 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3706 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3707 #ifdef USE_TOOLKIT_SCROLL_BARS
3708 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3712 struct input_event
*event
;
3714 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3721 #ifdef USE_TOOLKIT_SCROLL_BARS
3722 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3724 event
->kind
== FOCUS_IN_EVENT
)
3725 #ifdef USE_TOOLKIT_SCROLL_BARS
3726 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3727 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3728 && event
->part
== scroll_bar_handle
3729 && event
->modifiers
== 0)
3734 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3737 while (event
!= kbd_store_ptr
);
3743 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3744 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3745 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3750 if (current_kboard
->kbd_queue_has_data
)
3756 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3757 if (kb
->kbd_queue_has_data
)
3763 /* Set this for debugging, to have a way to get out */
3767 event_to_kboard (event
)
3768 struct input_event
*event
;
3771 frame
= event
->frame_or_window
;
3773 frame
= XCAR (frame
);
3774 else if (WINDOWP (frame
))
3775 frame
= WINDOW_FRAME (XWINDOW (frame
));
3777 /* There are still some events that don't set this field.
3778 For now, just ignore the problem.
3779 Also ignore dead frames here. */
3780 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3783 return FRAME_KBOARD (XFRAME (frame
));
3787 /* Return the number of slots occupied in kbd_buffer. */
3790 kbd_buffer_nr_stored (void)
3792 return kbd_fetch_ptr
== kbd_store_ptr
3794 : (kbd_fetch_ptr
< kbd_store_ptr
3795 ? kbd_store_ptr
- kbd_fetch_ptr
3796 : ((kbd_buffer
+ KBD_BUFFER_SIZE
) - kbd_fetch_ptr
3797 + (kbd_store_ptr
- kbd_buffer
)));
3799 #endif /* subprocesses */
3801 Lisp_Object Vthrow_on_input
;
3803 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3806 kbd_buffer_store_event (event
)
3807 register struct input_event
*event
;
3809 kbd_buffer_store_event_hold (event
, 0);
3812 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3814 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3815 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3816 Else, if EVENT is a quit event, store the quit event
3817 in HOLD_QUIT, and return (thus ignoring further events).
3819 This is used in read_avail_input to postpone the processing
3820 of the quit event until all subsequent input events have been
3821 parsed (and discarded).
3825 kbd_buffer_store_event_hold (event
, hold_quit
)
3826 register struct input_event
*event
;
3827 struct input_event
*hold_quit
;
3829 if (event
->kind
== NO_EVENT
)
3832 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3835 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3837 register int c
= event
->code
& 0377;
3839 if (event
->modifiers
& ctrl_modifier
)
3840 c
= make_ctrl_char (c
);
3842 c
|= (event
->modifiers
3843 & (meta_modifier
| alt_modifier
3844 | hyper_modifier
| super_modifier
));
3848 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3849 struct input_event
*sp
;
3851 if (single_kboard
&& kb
!= current_kboard
)
3854 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3855 Fcons (make_number (c
), Qnil
));
3856 kb
->kbd_queue_has_data
= 1;
3857 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3859 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3862 if (event_to_kboard (sp
) == kb
)
3864 sp
->kind
= NO_EVENT
;
3865 sp
->frame_or_window
= Qnil
;
3874 bcopy (event
, (char *) hold_quit
, sizeof (*event
));
3878 /* If this results in a quit_char being returned to Emacs as
3879 input, set Vlast_event_frame properly. If this doesn't
3880 get returned to Emacs as an event, the next event read
3881 will set Vlast_event_frame again, so this is safe to do. */
3885 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3887 focus
= event
->frame_or_window
;
3888 internal_last_event_frame
= focus
;
3889 Vlast_event_frame
= focus
;
3892 last_event_timestamp
= event
->timestamp
;
3893 handle_interrupt ();
3897 if (c
&& c
== stop_character
)
3903 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3904 Just ignore the second one. */
3905 else if (event
->kind
== BUFFER_SWITCH_EVENT
3906 && kbd_fetch_ptr
!= kbd_store_ptr
3907 && ((kbd_store_ptr
== kbd_buffer
3908 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3909 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3912 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3913 kbd_store_ptr
= kbd_buffer
;
3915 /* Don't let the very last slot in the buffer become full,
3916 since that would make the two pointers equal,
3917 and that is indistinguishable from an empty buffer.
3918 Discard the event if it would fill the last slot. */
3919 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3921 *kbd_store_ptr
= *event
;
3924 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE
/2 && ! kbd_on_hold_p ())
3926 /* Don't read keyboard input until we have processed kbd_buffer.
3927 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3928 hold_keyboard_input ();
3930 if (!noninteractive
)
3931 signal (SIGIO
, SIG_IGN
);
3935 #endif /* subprocesses */
3938 /* If we're inside while-no-input, and this event qualifies
3939 as input, set quit-flag to cause an interrupt. */
3940 if (!NILP (Vthrow_on_input
)
3941 && event
->kind
!= FOCUS_IN_EVENT
3942 && event
->kind
!= HELP_EVENT
3943 && event
->kind
!= DEICONIFY_EVENT
)
3945 Vquit_flag
= Vthrow_on_input
;
3946 /* If we're inside a function that wants immediate quits,
3948 if (immediate_quit
&& NILP (Vinhibit_quit
))
3958 /* Put an input event back in the head of the event queue. */
3961 kbd_buffer_unget_event (event
)
3962 register struct input_event
*event
;
3964 if (kbd_fetch_ptr
== kbd_buffer
)
3965 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3967 /* Don't let the very last slot in the buffer become full, */
3968 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3971 *kbd_fetch_ptr
= *event
;
3976 /* Generate HELP_EVENT input_events in BUFP which has room for
3977 SIZE events. If there's not enough room in BUFP, ignore this
3980 HELP is the help form.
3982 FRAME is the frame on which the help is generated. OBJECT is the
3983 Lisp object where the help was found (a buffer, a string, an
3984 overlay, or nil if neither from a string nor from a buffer. POS is
3985 the position within OBJECT where the help was found.
3987 Value is the number of input_events generated. */
3990 gen_help_event (help
, frame
, window
, object
, pos
)
3991 Lisp_Object help
, frame
, object
, window
;
3994 struct input_event event
;
3998 event
.kind
= HELP_EVENT
;
3999 event
.frame_or_window
= frame
;
4001 event
.x
= WINDOWP (window
) ? window
: frame
;
4004 kbd_buffer_store_event (&event
);
4008 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
4011 kbd_buffer_store_help_event (frame
, help
)
4012 Lisp_Object frame
, help
;
4014 struct input_event event
;
4016 event
.kind
= HELP_EVENT
;
4017 event
.frame_or_window
= frame
;
4022 kbd_buffer_store_event (&event
);
4026 /* Discard any mouse events in the event buffer by setting them to
4029 discard_mouse_events ()
4031 struct input_event
*sp
;
4032 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
4034 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4037 if (sp
->kind
== MOUSE_CLICK_EVENT
4038 || sp
->kind
== WHEEL_EVENT
4039 || sp
->kind
== HORIZ_WHEEL_EVENT
4041 || sp
->kind
== GPM_CLICK_EVENT
4043 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
4045 sp
->kind
= NO_EVENT
;
4051 /* Return non-zero if there are any real events waiting in the event
4052 buffer, not counting `NO_EVENT's.
4054 If DISCARD is non-zero, discard NO_EVENT events at the front of
4055 the input queue, possibly leaving the input queue empty if there
4056 are no real input events. */
4059 kbd_buffer_events_waiting (discard
)
4062 struct input_event
*sp
;
4064 for (sp
= kbd_fetch_ptr
;
4065 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
4068 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
4075 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
4079 /* Clear input event EVENT. */
4083 struct input_event
*event
;
4085 event
->kind
= NO_EVENT
;
4089 /* Read one event from the event buffer, waiting if necessary.
4090 The value is a Lisp object representing the event.
4091 The value is nil for an event that should be ignored,
4092 or that was handled here.
4093 We always read and discard one event. */
4096 kbd_buffer_get_event (kbp
, used_mouse_menu
, end_time
)
4098 int *used_mouse_menu
;
4099 EMACS_TIME
*end_time
;
4105 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE
/4)
4107 /* Start reading input again, we have processed enough so we can
4108 accept new events again. */
4109 unhold_keyboard_input ();
4111 if (!noninteractive
)
4112 signal (SIGIO
, input_available_signal
);
4116 #endif /* subprocesses */
4119 /* In case we are running as a daemon, only do this before
4120 detaching from the terminal. */
4121 || (IS_DAEMON
&& daemon_pipe
[1] >= 0))
4125 *kbp
= current_kboard
;
4129 /* Wait until there is input available. */
4132 /* Break loop if there's an unread command event. Needed in
4133 moused window autoselection which uses a timer to insert such
4135 if (CONSP (Vunread_command_events
))
4138 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4140 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4141 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4145 /* If the quit flag is set, then read_char will return
4146 quit_char, so that counts as "available input." */
4147 if (!NILP (Vquit_flag
))
4148 quit_throw_to_read_char ();
4150 /* One way or another, wait until input is available; then, if
4151 interrupt handlers have not read it, read it now. */
4154 /* Read D-Bus messages. */
4155 xd_read_queued_messages ();
4156 #endif /* HAVE_DBUS */
4158 /* Note SIGIO has been undef'd if FIONREAD is missing. */
4162 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4164 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4165 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4170 EMACS_TIME duration
;
4171 EMACS_GET_TIME (duration
);
4172 if (EMACS_TIME_GE (duration
, *end_time
))
4173 return Qnil
; /* finished waiting */
4176 EMACS_SUB_TIME (duration
, *end_time
, duration
);
4177 wait_reading_process_output (EMACS_SECS (duration
),
4178 EMACS_USECS (duration
),
4179 -1, 1, Qnil
, NULL
, 0);
4183 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
4185 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
4186 /* Pass 1 for EXPECT since we just waited to have input. */
4187 read_avail_input (1);
4190 if (CONSP (Vunread_command_events
))
4193 first
= XCAR (Vunread_command_events
);
4194 Vunread_command_events
= XCDR (Vunread_command_events
);
4195 *kbp
= current_kboard
;
4199 /* At this point, we know that there is a readable event available
4200 somewhere. If the event queue is empty, then there must be a
4201 mouse movement enabled and available. */
4202 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4204 struct input_event
*event
;
4206 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4210 last_event_timestamp
= event
->timestamp
;
4212 *kbp
= event_to_kboard (event
);
4214 *kbp
= current_kboard
; /* Better than returning null ptr? */
4218 /* These two kinds of events get special handling
4219 and don't actually appear to the command loop.
4220 We return nil for them. */
4221 if (event
->kind
== SELECTION_REQUEST_EVENT
4222 || event
->kind
== SELECTION_CLEAR_EVENT
)
4225 struct input_event copy
;
4227 /* Remove it from the buffer before processing it,
4228 since otherwise swallow_events will see it
4229 and process it again. */
4231 kbd_fetch_ptr
= event
+ 1;
4232 input_pending
= readable_events (0);
4233 x_handle_selection_event (©
);
4235 /* We're getting selection request events, but we don't have
4241 #if defined (HAVE_NS)
4242 else if (event
->kind
== NS_TEXT_EVENT
)
4244 if (event
->code
== KEY_NS_PUT_WORKING_TEXT
)
4245 obj
= Fcons (intern ("ns-put-working-text"), Qnil
);
4247 obj
= Fcons (intern ("ns-unput-working-text"), Qnil
);
4248 kbd_fetch_ptr
= event
+ 1;
4249 if (used_mouse_menu
)
4250 *used_mouse_menu
= 1;
4254 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4255 || defined (HAVE_NS)
4256 else if (event
->kind
== DELETE_WINDOW_EVENT
)
4258 /* Make an event (delete-frame (FRAME)). */
4259 obj
= Fcons (event
->frame_or_window
, Qnil
);
4260 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
4261 kbd_fetch_ptr
= event
+ 1;
4264 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4265 || defined (HAVE_NS)
4266 else if (event
->kind
== ICONIFY_EVENT
)
4268 /* Make an event (iconify-frame (FRAME)). */
4269 obj
= Fcons (event
->frame_or_window
, Qnil
);
4270 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
4271 kbd_fetch_ptr
= event
+ 1;
4273 else if (event
->kind
== DEICONIFY_EVENT
)
4275 /* Make an event (make-frame-visible (FRAME)). */
4276 obj
= Fcons (event
->frame_or_window
, Qnil
);
4277 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
4278 kbd_fetch_ptr
= event
+ 1;
4281 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
4283 /* The value doesn't matter here; only the type is tested. */
4284 XSETBUFFER (obj
, current_buffer
);
4285 kbd_fetch_ptr
= event
+ 1;
4287 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4288 || defined(HAVE_NS) || defined (USE_GTK)
4289 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4291 kbd_fetch_ptr
= event
+ 1;
4292 input_pending
= readable_events (0);
4293 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4294 x_activate_menubar (XFRAME (event
->frame_or_window
));
4297 #if defined (WINDOWSNT)
4298 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4300 /* Make an event (language-change (FRAME CHARSET LCID)). */
4301 obj
= Fcons (event
->frame_or_window
, Qnil
);
4302 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4303 kbd_fetch_ptr
= event
+ 1;
4306 else if (event
->kind
== SAVE_SESSION_EVENT
)
4308 obj
= Fcons (Qsave_session
, Fcons (event
->arg
, Qnil
));
4309 kbd_fetch_ptr
= event
+ 1;
4311 /* Just discard these, by returning nil.
4312 With MULTI_KBOARD, these events are used as placeholders
4313 when we need to randomly delete events from the queue.
4314 (They shouldn't otherwise be found in the buffer,
4315 but on some machines it appears they do show up
4316 even without MULTI_KBOARD.) */
4317 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4318 mouse events during a popup-menu call. */
4319 else if (event
->kind
== NO_EVENT
)
4320 kbd_fetch_ptr
= event
+ 1;
4321 else if (event
->kind
== HELP_EVENT
)
4323 Lisp_Object object
, position
, help
, frame
, window
;
4325 frame
= event
->frame_or_window
;
4326 object
= event
->arg
;
4327 position
= make_number (event
->code
);
4330 clear_event (event
);
4332 kbd_fetch_ptr
= event
+ 1;
4333 if (!WINDOWP (window
))
4335 obj
= Fcons (Qhelp_echo
,
4336 list5 (frame
, help
, window
, object
, position
));
4338 else if (event
->kind
== FOCUS_IN_EVENT
)
4340 /* Notification of a FocusIn event. The frame receiving the
4341 focus is in event->frame_or_window. Generate a
4342 switch-frame event if necessary. */
4343 Lisp_Object frame
, focus
;
4345 frame
= event
->frame_or_window
;
4346 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4350 if (!EQ (frame
, internal_last_event_frame
)
4351 && !EQ (frame
, selected_frame
))
4352 obj
= make_lispy_switch_frame (frame
);
4353 internal_last_event_frame
= frame
;
4354 kbd_fetch_ptr
= event
+ 1;
4357 else if (event
->kind
== DBUS_EVENT
)
4359 obj
= make_lispy_event (event
);
4360 kbd_fetch_ptr
= event
+ 1;
4363 else if (event
->kind
== CONFIG_CHANGED_EVENT
)
4365 obj
= make_lispy_event (event
);
4366 kbd_fetch_ptr
= event
+ 1;
4370 /* If this event is on a different frame, return a switch-frame this
4371 time, and leave the event in the queue for next time. */
4375 frame
= event
->frame_or_window
;
4377 frame
= XCAR (frame
);
4378 else if (WINDOWP (frame
))
4379 frame
= WINDOW_FRAME (XWINDOW (frame
));
4381 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4385 if (! EQ (frame
, internal_last_event_frame
)
4386 && !EQ (frame
, selected_frame
))
4387 obj
= make_lispy_switch_frame (frame
);
4388 internal_last_event_frame
= frame
;
4390 /* If we didn't decide to make a switch-frame event, go ahead
4391 and build a real event from the queue entry. */
4395 obj
= make_lispy_event (event
);
4397 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4398 || defined(HAVE_NS) || defined (USE_GTK)
4399 /* If this was a menu selection, then set the flag to inhibit
4400 writing to last_nonmenu_event. Don't do this if the event
4401 we're returning is (menu-bar), though; that indicates the
4402 beginning of the menu sequence, and we might as well leave
4403 that as the `event with parameters' for this selection. */
4405 && !EQ (event
->frame_or_window
, event
->arg
)
4406 && (event
->kind
== MENU_BAR_EVENT
4407 || event
->kind
== TOOL_BAR_EVENT
))
4408 *used_mouse_menu
= 1;
4411 /* certain system events are non-key events */
4413 && event
->kind
== NS_NONKEY_EVENT
)
4414 *used_mouse_menu
= 1;
4417 /* Wipe out this event, to catch bugs. */
4418 clear_event (event
);
4419 kbd_fetch_ptr
= event
+ 1;
4423 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4424 /* Try generating a mouse motion event. */
4425 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4427 FRAME_PTR f
= some_mouse_moved ();
4428 Lisp_Object bar_window
;
4429 enum scroll_bar_part part
;
4433 *kbp
= current_kboard
;
4434 /* Note that this uses F to determine which terminal to look at.
4435 If there is no valid info, it does not store anything
4436 so x remains nil. */
4439 /* XXX Can f or mouse_position_hook be NULL here? */
4440 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4441 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4442 &part
, &x
, &y
, &time
);
4446 /* Decide if we should generate a switch-frame event. Don't
4447 generate switch-frame events for motion outside of all Emacs
4453 frame
= FRAME_FOCUS_FRAME (f
);
4455 XSETFRAME (frame
, f
);
4457 if (! EQ (frame
, internal_last_event_frame
)
4458 && !EQ (frame
, selected_frame
))
4459 obj
= make_lispy_switch_frame (frame
);
4460 internal_last_event_frame
= frame
;
4463 /* If we didn't decide to make a switch-frame event, go ahead and
4464 return a mouse-motion event. */
4465 if (!NILP (x
) && NILP (obj
))
4466 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4468 #endif /* HAVE_MOUSE || HAVE GPM */
4470 /* We were promised by the above while loop that there was
4471 something for us to read! */
4474 input_pending
= readable_events (0);
4476 Vlast_event_frame
= internal_last_event_frame
;
4481 /* Process any events that are not user-visible,
4482 then return, without reading any user-visible events. */
4485 swallow_events (do_display
)
4490 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4492 struct input_event
*event
;
4494 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4498 last_event_timestamp
= event
->timestamp
;
4500 /* These two kinds of events get special handling
4501 and don't actually appear to the command loop. */
4502 if (event
->kind
== SELECTION_REQUEST_EVENT
4503 || event
->kind
== SELECTION_CLEAR_EVENT
)
4506 struct input_event copy
;
4508 /* Remove it from the buffer before processing it,
4509 since otherwise swallow_events called recursively could see it
4510 and process it again. */
4512 kbd_fetch_ptr
= event
+ 1;
4513 input_pending
= readable_events (0);
4514 x_handle_selection_event (©
);
4516 /* We're getting selection request events, but we don't have
4525 old_timers_run
= timers_run
;
4526 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4528 if (timers_run
!= old_timers_run
&& do_display
)
4529 redisplay_preserve_echo_area (7);
4532 /* Record the start of when Emacs is idle,
4533 for the sake of running idle-time timers. */
4540 /* If we are already in the idle state, do nothing. */
4541 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4544 EMACS_GET_TIME (timer_idleness_start_time
);
4546 timer_last_idleness_start_time
= timer_idleness_start_time
;
4548 /* Mark all idle-time timers as once again candidates for running. */
4549 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4553 timer
= XCAR (timers
);
4555 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4557 XVECTOR (timer
)->contents
[0] = Qnil
;
4561 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4566 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4569 /* Resume idle timer from last idle start time. */
4572 timer_resume_idle ()
4574 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4577 timer_idleness_start_time
= timer_last_idleness_start_time
;
4580 /* This is only for debugging. */
4581 struct input_event last_timer_event
;
4583 /* List of elisp functions to call, delayed because they were generated in
4584 a context where Elisp could not be safely run (e.g. redisplay, signal,
4585 ...). Each element has the form (FUN . ARGS). */
4586 Lisp_Object pending_funcalls
;
4588 extern Lisp_Object Qapply
;
4590 /* Check whether a timer has fired. To prevent larger problems we simply
4591 disregard elements that are not proper timers. Do not make a circular
4592 timer list for the time being.
4594 Returns the time to wait until the next timer fires. If a
4595 timer is triggering now, return zero.
4596 If no timer is active, return -1.
4598 If a timer is ripe, we run it, with quitting turned off.
4599 In that case we return 0 to indicate that a new timer_check_2 call
4605 EMACS_TIME nexttime
;
4606 EMACS_TIME now
, idleness_now
;
4607 Lisp_Object timers
, idle_timers
, chosen_timer
;
4608 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4610 EMACS_SET_SECS (nexttime
, -1);
4611 EMACS_SET_USECS (nexttime
, -1);
4613 /* Always consider the ordinary timers. */
4614 timers
= Vtimer_list
;
4615 /* Consider the idle timers only if Emacs is idle. */
4616 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4617 idle_timers
= Vtimer_idle_list
;
4620 chosen_timer
= Qnil
;
4621 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4623 /* First run the code that was delayed. */
4624 while (CONSP (pending_funcalls
))
4626 Lisp_Object funcall
= XCAR (pending_funcalls
);
4627 pending_funcalls
= XCDR (pending_funcalls
);
4628 safe_call2 (Qapply
, XCAR (funcall
), XCDR (funcall
));
4631 if (CONSP (timers
) || CONSP (idle_timers
))
4633 EMACS_GET_TIME (now
);
4634 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4635 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4638 while (CONSP (timers
) || CONSP (idle_timers
))
4640 Lisp_Object
*vector
;
4641 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4642 EMACS_TIME timer_time
, idle_timer_time
;
4643 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4645 /* Skip past invalid timers and timers already handled. */
4648 timer
= XCAR (timers
);
4649 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4651 timers
= XCDR (timers
);
4654 vector
= XVECTOR (timer
)->contents
;
4656 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4657 || !INTEGERP (vector
[3])
4658 || ! NILP (vector
[0]))
4660 timers
= XCDR (timers
);
4664 if (!NILP (idle_timers
))
4666 timer
= XCAR (idle_timers
);
4667 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4669 idle_timers
= XCDR (idle_timers
);
4672 vector
= XVECTOR (timer
)->contents
;
4674 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4675 || !INTEGERP (vector
[3])
4676 || ! NILP (vector
[0]))
4678 idle_timers
= XCDR (idle_timers
);
4683 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4684 based on the next ordinary timer.
4685 TIMER_DIFFERENCE is the distance in time from NOW to when
4686 this timer becomes ripe (negative if it's already ripe). */
4689 timer
= XCAR (timers
);
4690 vector
= XVECTOR (timer
)->contents
;
4691 EMACS_SET_SECS (timer_time
,
4692 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4693 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4694 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4697 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4698 based on the next idle timer. */
4699 if (!NILP (idle_timers
))
4701 idle_timer
= XCAR (idle_timers
);
4702 vector
= XVECTOR (idle_timer
)->contents
;
4703 EMACS_SET_SECS (idle_timer_time
,
4704 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4705 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4706 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4709 /* Decide which timer is the next timer,
4710 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4711 Also step down the list where we found that timer. */
4713 if (! NILP (timers
) && ! NILP (idle_timers
))
4716 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4717 if (EMACS_TIME_NEG_P (temp
))
4719 chosen_timer
= timer
;
4720 timers
= XCDR (timers
);
4721 difference
= timer_difference
;
4725 chosen_timer
= idle_timer
;
4726 idle_timers
= XCDR (idle_timers
);
4727 difference
= idle_timer_difference
;
4730 else if (! NILP (timers
))
4732 chosen_timer
= timer
;
4733 timers
= XCDR (timers
);
4734 difference
= timer_difference
;
4738 chosen_timer
= idle_timer
;
4739 idle_timers
= XCDR (idle_timers
);
4740 difference
= idle_timer_difference
;
4742 vector
= XVECTOR (chosen_timer
)->contents
;
4744 /* If timer is ripe, run it if it hasn't been run. */
4745 if (EMACS_TIME_NEG_P (difference
)
4746 || (EMACS_SECS (difference
) == 0
4747 && EMACS_USECS (difference
) == 0))
4749 if (NILP (vector
[0]))
4751 int count
= SPECPDL_INDEX ();
4752 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4754 /* Mark the timer as triggered to prevent problems if the lisp
4755 code fails to reschedule it right. */
4758 specbind (Qinhibit_quit
, Qt
);
4760 call1 (Qtimer_event_handler
, chosen_timer
);
4761 Vdeactivate_mark
= old_deactivate_mark
;
4763 unbind_to (count
, Qnil
);
4765 /* Since we have handled the event,
4766 we don't need to tell the caller to wake up and do it. */
4767 /* But the caller must still wait for the next timer, so
4768 return 0 to indicate that. */
4771 EMACS_SET_SECS (nexttime
, 0);
4772 EMACS_SET_USECS (nexttime
, 0);
4775 /* When we encounter a timer that is still waiting,
4776 return the amount of time to wait before it is ripe. */
4783 /* No timers are pending in the future. */
4784 /* Return 0 if we generated an event, and -1 if not. */
4790 /* Check whether a timer has fired. To prevent larger problems we simply
4791 disregard elements that are not proper timers. Do not make a circular
4792 timer list for the time being.
4794 Returns the time to wait until the next timer fires.
4795 If no timer is active, return -1.
4797 As long as any timer is ripe, we run it.
4799 DO_IT_NOW is now ignored. It used to mean that we should
4800 run the timer directly instead of queueing a timer-event.
4801 Now we always run timers directly. */
4804 timer_check (do_it_now
)
4807 EMACS_TIME nexttime
;
4811 nexttime
= timer_check_2 ();
4813 while (EMACS_SECS (nexttime
) == 0 && EMACS_USECS (nexttime
) == 0);
4818 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4819 doc
: /* Return the current length of Emacs idleness, or nil.
4820 The value when Emacs is idle is a list of three integers. The first has
4821 the most significant 16 bits of the seconds, while the second has the least
4822 significant 16 bits. The third integer gives the microsecond count.
4824 The value when Emacs is not idle is nil.
4826 The microsecond count is zero on systems that do not provide
4827 resolution finer than a second. */)
4830 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4832 EMACS_TIME now
, idleness_now
;
4834 EMACS_GET_TIME (now
);
4835 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4837 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4838 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4839 make_number (EMACS_USECS (idleness_now
)));
4845 /* Caches for modify_event_symbol. */
4846 static Lisp_Object accent_key_syms
;
4847 static Lisp_Object func_key_syms
;
4848 static Lisp_Object mouse_syms
;
4849 static Lisp_Object wheel_syms
;
4850 static Lisp_Object drag_n_drop_syms
;
4852 /* This is a list of keysym codes for special "accent" characters.
4853 It parallels lispy_accent_keys. */
4855 static const int lispy_accent_codes
[] =
4857 #ifdef XK_dead_circumflex
4862 #ifdef XK_dead_grave
4867 #ifdef XK_dead_tilde
4872 #ifdef XK_dead_diaeresis
4877 #ifdef XK_dead_macron
4882 #ifdef XK_dead_degree
4887 #ifdef XK_dead_acute
4892 #ifdef XK_dead_cedilla
4897 #ifdef XK_dead_breve
4902 #ifdef XK_dead_ogonek
4907 #ifdef XK_dead_caron
4912 #ifdef XK_dead_doubleacute
4913 XK_dead_doubleacute
,
4917 #ifdef XK_dead_abovedot
4922 #ifdef XK_dead_abovering
4932 #ifdef XK_dead_belowdot
4937 #ifdef XK_dead_voiced_sound
4938 XK_dead_voiced_sound
,
4942 #ifdef XK_dead_semivoiced_sound
4943 XK_dead_semivoiced_sound
,
4959 /* This is a list of Lisp names for special "accent" characters.
4960 It parallels lispy_accent_codes. */
4962 static char *lispy_accent_keys
[] =
4980 "dead-voiced-sound",
4981 "dead-semivoiced-sound",
4987 #define FUNCTION_KEY_OFFSET 0x0
4989 char *lispy_function_keys
[] =
4993 0, /* VK_LBUTTON 0x01 */
4994 0, /* VK_RBUTTON 0x02 */
4995 "cancel", /* VK_CANCEL 0x03 */
4996 0, /* VK_MBUTTON 0x04 */
4998 0, 0, 0, /* 0x05 .. 0x07 */
5000 "backspace", /* VK_BACK 0x08 */
5001 "tab", /* VK_TAB 0x09 */
5003 0, 0, /* 0x0A .. 0x0B */
5005 "clear", /* VK_CLEAR 0x0C */
5006 "return", /* VK_RETURN 0x0D */
5008 0, 0, /* 0x0E .. 0x0F */
5010 0, /* VK_SHIFT 0x10 */
5011 0, /* VK_CONTROL 0x11 */
5012 0, /* VK_MENU 0x12 */
5013 "pause", /* VK_PAUSE 0x13 */
5014 "capslock", /* VK_CAPITAL 0x14 */
5015 "kana", /* VK_KANA/VK_HANGUL 0x15 */
5017 "junja", /* VK_JUNJA 0x17 */
5018 "final", /* VK_FINAL 0x18 */
5019 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
5021 "escape", /* VK_ESCAPE 0x1B */
5022 "convert", /* VK_CONVERT 0x1C */
5023 "non-convert", /* VK_NONCONVERT 0x1D */
5024 "accept", /* VK_ACCEPT 0x1E */
5025 "mode-change", /* VK_MODECHANGE 0x1F */
5026 0, /* VK_SPACE 0x20 */
5027 "prior", /* VK_PRIOR 0x21 */
5028 "next", /* VK_NEXT 0x22 */
5029 "end", /* VK_END 0x23 */
5030 "home", /* VK_HOME 0x24 */
5031 "left", /* VK_LEFT 0x25 */
5032 "up", /* VK_UP 0x26 */
5033 "right", /* VK_RIGHT 0x27 */
5034 "down", /* VK_DOWN 0x28 */
5035 "select", /* VK_SELECT 0x29 */
5036 "print", /* VK_PRINT 0x2A */
5037 "execute", /* VK_EXECUTE 0x2B */
5038 "snapshot", /* VK_SNAPSHOT 0x2C */
5039 "insert", /* VK_INSERT 0x2D */
5040 "delete", /* VK_DELETE 0x2E */
5041 "help", /* VK_HELP 0x2F */
5043 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
5045 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5047 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
5049 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
5051 0, 0, 0, 0, 0, 0, 0, 0, 0,
5052 0, 0, 0, 0, 0, 0, 0, 0, 0,
5053 0, 0, 0, 0, 0, 0, 0, 0,
5055 "lwindow", /* VK_LWIN 0x5B */
5056 "rwindow", /* VK_RWIN 0x5C */
5057 "apps", /* VK_APPS 0x5D */
5060 "kp-0", /* VK_NUMPAD0 0x60 */
5061 "kp-1", /* VK_NUMPAD1 0x61 */
5062 "kp-2", /* VK_NUMPAD2 0x62 */
5063 "kp-3", /* VK_NUMPAD3 0x63 */
5064 "kp-4", /* VK_NUMPAD4 0x64 */
5065 "kp-5", /* VK_NUMPAD5 0x65 */
5066 "kp-6", /* VK_NUMPAD6 0x66 */
5067 "kp-7", /* VK_NUMPAD7 0x67 */
5068 "kp-8", /* VK_NUMPAD8 0x68 */
5069 "kp-9", /* VK_NUMPAD9 0x69 */
5070 "kp-multiply", /* VK_MULTIPLY 0x6A */
5071 "kp-add", /* VK_ADD 0x6B */
5072 "kp-separator", /* VK_SEPARATOR 0x6C */
5073 "kp-subtract", /* VK_SUBTRACT 0x6D */
5074 "kp-decimal", /* VK_DECIMAL 0x6E */
5075 "kp-divide", /* VK_DIVIDE 0x6F */
5076 "f1", /* VK_F1 0x70 */
5077 "f2", /* VK_F2 0x71 */
5078 "f3", /* VK_F3 0x72 */
5079 "f4", /* VK_F4 0x73 */
5080 "f5", /* VK_F5 0x74 */
5081 "f6", /* VK_F6 0x75 */
5082 "f7", /* VK_F7 0x76 */
5083 "f8", /* VK_F8 0x77 */
5084 "f9", /* VK_F9 0x78 */
5085 "f10", /* VK_F10 0x79 */
5086 "f11", /* VK_F11 0x7A */
5087 "f12", /* VK_F12 0x7B */
5088 "f13", /* VK_F13 0x7C */
5089 "f14", /* VK_F14 0x7D */
5090 "f15", /* VK_F15 0x7E */
5091 "f16", /* VK_F16 0x7F */
5092 "f17", /* VK_F17 0x80 */
5093 "f18", /* VK_F18 0x81 */
5094 "f19", /* VK_F19 0x82 */
5095 "f20", /* VK_F20 0x83 */
5096 "f21", /* VK_F21 0x84 */
5097 "f22", /* VK_F22 0x85 */
5098 "f23", /* VK_F23 0x86 */
5099 "f24", /* VK_F24 0x87 */
5101 0, 0, 0, 0, /* 0x88 .. 0x8B */
5102 0, 0, 0, 0, /* 0x8C .. 0x8F */
5104 "kp-numlock", /* VK_NUMLOCK 0x90 */
5105 "scroll", /* VK_SCROLL 0x91 */
5106 /* Not sure where the following block comes from.
5107 Windows headers have NEC and Fujitsu specific keys in
5108 this block, but nothing generic. */
5109 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
5110 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
5111 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
5112 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
5113 "kp-end", /* VK_NUMPAD_END 0x96 */
5114 "kp-home", /* VK_NUMPAD_HOME 0x97 */
5115 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
5116 "kp-up", /* VK_NUMPAD_UP 0x99 */
5117 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
5118 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
5119 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
5120 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
5122 0, 0, /* 0x9E .. 0x9F */
5125 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
5126 * Used only as parameters to GetAsyncKeyState and GetKeyState.
5127 * No other API or message will distinguish left and right keys this way.
5132 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
5133 to enable them selectively, and gives access to a few more functions.
5134 See lispy_multimedia_keys below. */
5135 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
5136 0, 0, 0, /* 0xAD .. 0xAF Volume */
5137 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
5138 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
5140 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
5141 0, 0, 0, 0, 0, 0, 0, 0, 0,
5143 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
5144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5148 "ax", /* VK_OEM_AX 0xE1 */
5149 0, /* VK_OEM_102 0xE2 */
5150 "ico-help", /* VK_ICO_HELP 0xE3 */
5151 "ico-00", /* VK_ICO_00 0xE4 */
5152 0, /* VK_PROCESSKEY 0xE5 */
5153 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
5154 "packet", /* VK_PACKET 0xE7 */
5156 "reset", /* VK_OEM_RESET 0xE9 */
5157 "jump", /* VK_OEM_JUMP 0xEA */
5158 "oem-pa1", /* VK_OEM_PA1 0xEB */
5159 "oem-pa2", /* VK_OEM_PA2 0xEC */
5160 "oem-pa3", /* VK_OEM_PA3 0xED */
5161 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
5162 "cusel", /* VK_OEM_CUSEL 0xEF */
5163 "oem-attn", /* VK_OEM_ATTN 0xF0 */
5164 "finish", /* VK_OEM_FINISH 0xF1 */
5165 "copy", /* VK_OEM_COPY 0xF2 */
5166 "auto", /* VK_OEM_AUTO 0xF3 */
5167 "enlw", /* VK_OEM_ENLW 0xF4 */
5168 "backtab", /* VK_OEM_BACKTAB 0xF5 */
5169 "attn", /* VK_ATTN 0xF6 */
5170 "crsel", /* VK_CRSEL 0xF7 */
5171 "exsel", /* VK_EXSEL 0xF8 */
5172 "ereof", /* VK_EREOF 0xF9 */
5173 "play", /* VK_PLAY 0xFA */
5174 "zoom", /* VK_ZOOM 0xFB */
5175 "noname", /* VK_NONAME 0xFC */
5176 "pa1", /* VK_PA1 0xFD */
5177 "oem_clear", /* VK_OEM_CLEAR 0xFE */
5181 /* Some of these duplicate the "Media keys" on newer keyboards,
5182 but they are delivered to the application in a different way. */
5183 static char *lispy_multimedia_keys
[] =
5191 "browser-favorites",
5228 "toggle-dictate-command",
5234 "media-fast-forward",
5237 "media-channel-down"
5240 #else /* not HAVE_NTGUI */
5242 /* This should be dealt with in XTread_socket now, and that doesn't
5243 depend on the client system having the Kana syms defined. See also
5244 the XK_kana_A case below. */
5247 static char *lispy_kana_keys
[] =
5249 /* X Keysym value */
5250 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
5251 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
5252 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
5253 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
5254 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
5255 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
5256 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
5257 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
5258 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
5259 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
5260 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
5261 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
5262 "kana-i", "kana-u", "kana-e", "kana-o",
5263 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
5264 "prolongedsound", "kana-A", "kana-I", "kana-U",
5265 "kana-E", "kana-O", "kana-KA", "kana-KI",
5266 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
5267 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
5268 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
5269 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
5270 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
5271 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
5272 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
5273 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
5274 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
5275 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
5276 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
5277 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
5279 #endif /* XK_kana_A */
5282 #define FUNCTION_KEY_OFFSET 0xff00
5284 /* You'll notice that this table is arranged to be conveniently
5285 indexed by X Windows keysym values. */
5286 static char *lispy_function_keys
[] =
5288 /* X Keysym value */
5290 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
5291 "backspace", "tab", "linefeed", "clear",
5293 0, 0, 0, "pause", /* 0xff10...1f */
5294 0, 0, 0, 0, 0, 0, 0, "escape",
5296 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
5297 "romaji", "hiragana", "katakana", "hiragana-katakana",
5298 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
5299 "massyo", "kana-lock", "kana-shift", "eisu-shift",
5300 "eisu-toggle", /* 0xff30...3f */
5301 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
5304 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
5305 "down", "prior", "next", "end",
5306 "begin", 0, 0, 0, 0, 0, 0, 0,
5307 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5318 "break", /* 0xff6b */
5321 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5322 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5323 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5324 0, 0, 0, 0, 0, 0, 0, 0,
5325 "kp-tab", /* 0xff89 */
5327 "kp-enter", /* 0xff8d */
5329 "kp-f1", /* 0xff91 */
5333 "kp-home", /* 0xff95 */
5338 "kp-prior", /* kp-page-up */
5339 "kp-next", /* kp-page-down */
5345 0, 0, 0, 0, 0, 0, 0, 0, 0,
5346 "kp-multiply", /* 0xffaa */
5351 "kp-divide", /* 0xffaf */
5352 "kp-0", /* 0xffb0 */
5353 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5356 "kp-equal", /* 0xffbd */
5357 "f1", /* 0xffbe */ /* IsFunctionKey */
5359 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5360 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5361 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5362 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5363 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5364 0, 0, 0, 0, 0, 0, 0, 0,
5365 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5366 0, 0, 0, 0, 0, 0, 0, "delete"
5369 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5370 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5372 static char *iso_lispy_function_keys
[] =
5374 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5375 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5376 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5377 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5378 "iso-lefttab", /* 0xfe20 */
5379 "iso-move-line-up", "iso-move-line-down",
5380 "iso-partial-line-up", "iso-partial-line-down",
5381 "iso-partial-space-left", "iso-partial-space-right",
5382 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5383 "iso-release-margin-left", "iso-release-margin-right",
5384 "iso-release-both-margins",
5385 "iso-fast-cursor-left", "iso-fast-cursor-right",
5386 "iso-fast-cursor-up", "iso-fast-cursor-down",
5387 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5388 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5391 #endif /* not HAVE_NTGUI */
5393 Lisp_Object Vlispy_mouse_stem
;
5395 static char *lispy_wheel_names
[] =
5397 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5400 /* drag-n-drop events are generated when a set of selected files are
5401 dragged from another application and dropped onto an Emacs window. */
5402 static char *lispy_drag_n_drop_names
[] =
5407 /* Scroll bar parts. */
5408 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5409 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5410 Lisp_Object Qtop
, Qratio
;
5412 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5413 Lisp_Object
*scroll_bar_parts
[] = {
5414 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5415 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5418 /* A vector, indexed by button number, giving the down-going location
5419 of currently depressed buttons, both scroll bar and non-scroll bar.
5421 The elements have the form
5422 (BUTTON-NUMBER MODIFIER-MASK . REST)
5423 where REST is the cdr of a position as it would be reported in the event.
5425 The make_lispy_event function stores positions here to tell the
5426 difference between click and drag events, and to store the starting
5427 location to be included in drag events. */
5429 static Lisp_Object button_down_location
;
5431 /* Information about the most recent up-going button event: Which
5432 button, what location, and what time. */
5434 static int last_mouse_button
;
5435 static int last_mouse_x
;
5436 static int last_mouse_y
;
5437 static unsigned long button_down_time
;
5439 /* The maximum time between clicks to make a double-click, or Qnil to
5440 disable double-click detection, or Qt for no time limit. */
5442 Lisp_Object Vdouble_click_time
;
5444 /* Maximum number of pixels the mouse may be moved between clicks
5445 to make a double-click. */
5447 EMACS_INT double_click_fuzz
;
5449 /* The number of clicks in this multiple-click. */
5451 int double_click_count
;
5453 /* Return position of a mouse click or wheel event */
5456 make_lispy_position (f
, x
, y
, time
)
5462 enum window_part part
;
5463 Lisp_Object posn
= Qnil
;
5464 Lisp_Object extra_info
= Qnil
;
5467 /* Set `window' to the window under frame pixel coordinates (x,y) */
5469 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5470 &part
, &wx
, &wy
, 0);
5474 if (WINDOWP (window
))
5476 /* It's a click in window window at frame coordinates (x,y) */
5477 struct window
*w
= XWINDOW (window
);
5478 Lisp_Object string_info
= Qnil
;
5479 int textpos
= -1, rx
= -1, ry
= -1;
5480 int dx
= -1, dy
= -1;
5481 int width
= -1, height
= -1;
5482 Lisp_Object object
= Qnil
;
5484 /* Set event coordinates to window-relative coordinates
5485 for constructing the Lisp event below. */
5489 if (part
== ON_TEXT
)
5491 wx
+= WINDOW_LEFT_MARGIN_WIDTH (w
);
5493 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5495 /* Mode line or header line. Look for a string under
5496 the mouse that may have a `local-map' property. */
5500 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5502 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5503 &object
, &dx
, &dy
, &width
, &height
);
5504 if (STRINGP (string
))
5505 string_info
= Fcons (string
, make_number (charpos
));
5506 if (w
== XWINDOW (selected_window
)
5507 && current_buffer
== XBUFFER (w
->buffer
))
5510 textpos
= XMARKER (w
->pointm
)->charpos
;
5512 else if (part
== ON_VERTICAL_BORDER
)
5514 posn
= Qvertical_line
;
5519 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5524 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5526 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5527 &object
, &dx
, &dy
, &width
, &height
);
5528 if (STRINGP (string
))
5529 string_info
= Fcons (string
, make_number (charpos
));
5530 if (part
== ON_LEFT_MARGIN
)
5533 wx
= window_box_right_offset (w
, TEXT_AREA
) - 1;
5535 else if (part
== ON_LEFT_FRINGE
)
5537 posn
= Qleft_fringe
;
5540 wx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5542 : window_box_width (w
, LEFT_MARGIN_AREA
));
5545 else if (part
== ON_RIGHT_FRINGE
)
5547 posn
= Qright_fringe
;
5550 wx
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5551 + window_box_width (w
, TEXT_AREA
)
5552 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5553 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5559 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5560 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5565 Lisp_Object string2
, object2
= Qnil
;
5566 struct display_pos p
;
5568 int width2
, height2
;
5569 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5570 &object2
, &dx2
, &dy2
,
5572 textpos
= CHARPOS (p
.pos
);
5573 if (rx
< 0) rx
= wx
;
5574 if (ry
< 0) ry
= wy
;
5575 if (dx
< 0) dx
= dx2
;
5576 if (dy
< 0) dy
= dy2
;
5577 if (width
< 0) width
= width2
;
5578 if (height
< 0) height
= height2
;
5582 posn
= make_number (textpos
);
5583 if (STRINGP (string2
))
5584 string_info
= Fcons (string2
,
5585 make_number (CHARPOS (p
.string_pos
)));
5591 #ifdef HAVE_WINDOW_SYSTEM
5592 if (IMAGEP (object
))
5594 Lisp_Object image_map
, hotspot
;
5595 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5597 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5599 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5600 posn
= XCAR (hotspot
);
5605 extra_info
= Fcons (object
,
5606 Fcons (Fcons (make_number (dx
),
5608 Fcons (Fcons (make_number (width
),
5609 make_number (height
)),
5613 extra_info
= Fcons (string_info
,
5614 Fcons (make_number (textpos
),
5615 Fcons (Fcons (make_number (rx
),
5621 XSETFRAME (window
, f
);
5626 XSETFASTINT (*x
, 0);
5627 XSETFASTINT (*y
, 0);
5630 return Fcons (window
,
5632 Fcons (Fcons (*x
, *y
),
5633 Fcons (make_number (time
),
5637 /* Given a struct input_event, build the lisp event which represents
5638 it. If EVENT is 0, build a mouse movement event from the mouse
5639 movement buffer, which should have a movement event in it.
5641 Note that events must be passed to this function in the order they
5642 are received; this function stores the location of button presses
5643 in order to build drag events when the button is released. */
5646 make_lispy_event (event
)
5647 struct input_event
*event
;
5651 switch (SWITCH_ENUM_CAST (event
->kind
))
5653 /* A simple keystroke. */
5654 case ASCII_KEYSTROKE_EVENT
:
5655 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5657 Lisp_Object lispy_c
;
5658 int c
= event
->code
;
5659 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
5662 eassert (c
== event
->code
);
5663 /* Turn ASCII characters into control characters
5665 if (event
->modifiers
& ctrl_modifier
)
5667 c
= make_ctrl_char (c
);
5668 event
->modifiers
&= ~ctrl_modifier
;
5672 /* Add in the other modifier bits. The shift key was taken care
5673 of by the X code. */
5674 c
|= (event
->modifiers
5675 & (meta_modifier
| alt_modifier
5676 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5677 /* Distinguish Shift-SPC from SPC. */
5678 if ((event
->code
) == 040
5679 && event
->modifiers
& shift_modifier
)
5680 c
|= shift_modifier
;
5681 button_down_time
= 0;
5682 XSETFASTINT (lispy_c
, c
);
5687 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5688 except that they are non-key events (last-nonmenu-event is nil). */
5689 case NS_NONKEY_EVENT
:
5692 /* A function key. The symbol may need to have modifier prefixes
5694 case NON_ASCII_KEYSTROKE_EVENT
:
5695 button_down_time
= 0;
5697 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5698 if (event
->code
== lispy_accent_codes
[i
])
5699 return modify_event_symbol (i
,
5701 Qfunction_key
, Qnil
,
5702 lispy_accent_keys
, &accent_key_syms
,
5703 (sizeof (lispy_accent_keys
)
5704 / sizeof (lispy_accent_keys
[0])));
5708 if (event
->code
>= 0x400 && event
->code
< 0x500)
5709 return modify_event_symbol (event
->code
- 0x400,
5710 event
->modifiers
& ~shift_modifier
,
5711 Qfunction_key
, Qnil
,
5712 lispy_kana_keys
, &func_key_syms
,
5713 (sizeof (lispy_kana_keys
)
5714 / sizeof (lispy_kana_keys
[0])));
5715 #endif /* XK_kana_A */
5718 #ifdef ISO_FUNCTION_KEY_OFFSET
5719 if (event
->code
< FUNCTION_KEY_OFFSET
5720 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5721 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5723 Qfunction_key
, Qnil
,
5724 iso_lispy_function_keys
, &func_key_syms
,
5725 (sizeof (iso_lispy_function_keys
)
5726 / sizeof (iso_lispy_function_keys
[0])));
5729 /* Handle system-specific or unknown keysyms. */
5730 if (event
->code
& (1 << 28)
5731 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5732 || (event
->code
- FUNCTION_KEY_OFFSET
5733 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5734 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5736 /* We need to use an alist rather than a vector as the cache
5737 since we can't make a vector long enuf. */
5738 if (NILP (current_kboard
->system_key_syms
))
5739 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5740 return modify_event_symbol (event
->code
,
5743 current_kboard
->Vsystem_key_alist
,
5744 0, ¤t_kboard
->system_key_syms
,
5748 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5750 Qfunction_key
, Qnil
,
5751 lispy_function_keys
, &func_key_syms
,
5752 (sizeof (lispy_function_keys
)
5753 / sizeof (lispy_function_keys
[0])));
5756 case MULTIMEDIA_KEY_EVENT
:
5757 if (event
->code
< (sizeof (lispy_multimedia_keys
)
5758 / sizeof (lispy_multimedia_keys
[0]))
5759 && event
->code
> 0 && lispy_multimedia_keys
[event
->code
])
5761 return modify_event_symbol (event
->code
, event
->modifiers
,
5762 Qfunction_key
, Qnil
,
5763 lispy_multimedia_keys
, &func_key_syms
,
5764 (sizeof (lispy_multimedia_keys
)
5765 / sizeof (lispy_multimedia_keys
[0])));
5771 /* A mouse click. Figure out where it is, decide whether it's
5772 a press, click or drag, and build the appropriate structure. */
5773 case MOUSE_CLICK_EVENT
:
5774 #ifndef USE_TOOLKIT_SCROLL_BARS
5775 case SCROLL_BAR_CLICK_EVENT
:
5778 int button
= event
->code
;
5780 Lisp_Object position
;
5781 Lisp_Object
*start_pos_ptr
;
5782 Lisp_Object start_pos
;
5786 /* Build the position as appropriate for this mouse click. */
5787 if (event
->kind
== MOUSE_CLICK_EVENT
)
5789 struct frame
*f
= XFRAME (event
->frame_or_window
);
5790 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5794 /* Ignore mouse events that were made on frame that
5795 have been deleted. */
5796 if (! FRAME_LIVE_P (f
))
5799 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5800 /* EVENT->x and EVENT->y are frame-relative pixel
5801 coordinates at this place. Under old redisplay, COLUMN
5802 and ROW are set to frame relative glyph coordinates
5803 which are then used to determine whether this click is
5804 in a menu (non-toolkit version). */
5805 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5806 &column
, &row
, NULL
, 1);
5808 /* In the non-toolkit version, clicks on the menu bar
5809 are ordinary button events in the event buffer.
5810 Distinguish them, and invoke the menu.
5812 (In the toolkit version, the toolkit handles the menu bar
5813 and Emacs doesn't know about it until after the user
5814 makes a selection.) */
5815 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5816 && (event
->modifiers
& down_modifier
))
5818 Lisp_Object items
, item
;
5823 /* Activate the menu bar on the down event. If the
5824 up event comes in before the menu code can deal with it,
5826 if (! (event
->modifiers
& down_modifier
))
5830 /* Find the menu bar item under `column'. */
5832 items
= FRAME_MENU_BAR_ITEMS (f
);
5833 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5835 Lisp_Object pos
, string
;
5836 string
= AREF (items
, i
+ 1);
5837 pos
= AREF (items
, i
+ 3);
5840 if (column
>= XINT (pos
)
5841 && column
< XINT (pos
) + SCHARS (string
))
5843 item
= AREF (items
, i
);
5848 /* ELisp manual 2.4b says (x y) are window relative but
5849 code says they are frame-relative. */
5851 = Fcons (event
->frame_or_window
,
5853 Fcons (Fcons (event
->x
, event
->y
),
5854 Fcons (make_number (event
->timestamp
),
5857 return Fcons (item
, Fcons (position
, Qnil
));
5859 #endif /* not USE_X_TOOLKIT && not USE_GTK && not HAVE_NS */
5861 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5864 #ifndef USE_TOOLKIT_SCROLL_BARS
5867 /* It's a scrollbar click. */
5869 Lisp_Object portion_whole
;
5872 window
= event
->frame_or_window
;
5873 portion_whole
= Fcons (event
->x
, event
->y
);
5874 part
= *scroll_bar_parts
[(int) event
->part
];
5878 Fcons (Qvertical_scroll_bar
,
5879 Fcons (portion_whole
,
5880 Fcons (make_number (event
->timestamp
),
5881 Fcons (part
, Qnil
)))));
5883 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5885 if (button
>= ASIZE (button_down_location
))
5887 button_down_location
= larger_vector (button_down_location
,
5889 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5892 start_pos_ptr
= &AREF (button_down_location
, button
);
5893 start_pos
= *start_pos_ptr
;
5894 *start_pos_ptr
= Qnil
;
5897 /* On window-system frames, use the value of
5898 double-click-fuzz as is. On other frames, interpret it
5899 as a multiple of 1/8 characters. */
5903 if (WINDOWP (event
->frame_or_window
))
5904 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5905 else if (FRAMEP (event
->frame_or_window
))
5906 f
= XFRAME (event
->frame_or_window
);
5910 if (FRAME_WINDOW_P (f
))
5911 fuzz
= double_click_fuzz
;
5913 fuzz
= double_click_fuzz
/ 8;
5915 is_double
= (button
== last_mouse_button
5916 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5917 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5918 && button_down_time
!= 0
5919 && (EQ (Vdouble_click_time
, Qt
)
5920 || (INTEGERP (Vdouble_click_time
)
5921 && ((int)(event
->timestamp
- button_down_time
)
5922 < XINT (Vdouble_click_time
)))));
5925 last_mouse_button
= button
;
5926 last_mouse_x
= XINT (event
->x
);
5927 last_mouse_y
= XINT (event
->y
);
5929 /* If this is a button press, squirrel away the location, so
5930 we can decide later whether it was a click or a drag. */
5931 if (event
->modifiers
& down_modifier
)
5935 double_click_count
++;
5936 event
->modifiers
|= ((double_click_count
> 2)
5941 double_click_count
= 1;
5942 button_down_time
= event
->timestamp
;
5943 *start_pos_ptr
= Fcopy_alist (position
);
5944 ignore_mouse_drag_p
= 0;
5947 /* Now we're releasing a button - check the co-ordinates to
5948 see if this was a click or a drag. */
5949 else if (event
->modifiers
& up_modifier
)
5951 /* If we did not see a down before this up, ignore the up.
5952 Probably this happened because the down event chose a
5953 menu item. It would be an annoyance to treat the
5954 release of the button that chose the menu item as a
5957 if (!CONSP (start_pos
))
5960 event
->modifiers
&= ~up_modifier
;
5961 #if 0 /* Formerly we treated an up with no down as a click event. */
5962 if (!CONSP (start_pos
))
5963 event
->modifiers
|= click_modifier
;
5968 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5970 /* The third element of every position
5971 should be the (x,y) pair. */
5972 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5974 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5976 xdiff
= XINT (event
->x
) - XINT (XCAR (down
));
5977 ydiff
= XINT (event
->y
) - XINT (XCDR (down
));
5980 if (ignore_mouse_drag_p
)
5982 event
->modifiers
|= click_modifier
;
5983 ignore_mouse_drag_p
= 0;
5985 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5986 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5987 /* Maybe the mouse has moved a lot, caused scrolling, and
5988 eventually ended up at the same screen position (but
5989 not buffer position) in which case it is a drag, not
5991 /* FIXME: OTOH if the buffer position has changed
5992 because of a timer or process filter rather than
5993 because of mouse movement, it should be considered as
5994 a click. But mouse-drag-region completely ignores
5995 this case and it hasn't caused any real problem, so
5996 it's probably OK to ignore it as well. */
5997 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5998 /* Mouse hasn't moved (much). */
5999 event
->modifiers
|= click_modifier
;
6002 button_down_time
= 0;
6003 event
->modifiers
|= drag_modifier
;
6006 /* Don't check is_double; treat this as multiple
6007 if the down-event was multiple. */
6008 if (double_click_count
> 1)
6009 event
->modifiers
|= ((double_click_count
> 2)
6015 /* Every mouse event should either have the down_modifier or
6016 the up_modifier set. */
6020 /* Get the symbol we should use for the mouse click. */
6023 head
= modify_event_symbol (button
,
6025 Qmouse_click
, Vlispy_mouse_stem
,
6028 XVECTOR (mouse_syms
)->size
);
6029 if (event
->modifiers
& drag_modifier
)
6034 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
6037 Fcons (make_number (double_click_count
),
6047 case HORIZ_WHEEL_EVENT
:
6049 Lisp_Object position
;
6052 /* Build the position as appropriate for this mouse click. */
6053 struct frame
*f
= XFRAME (event
->frame_or_window
);
6055 /* Ignore wheel events that were made on frame that have been
6057 if (! FRAME_LIVE_P (f
))
6060 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6063 /* Set double or triple modifiers to indicate the wheel speed. */
6065 /* On window-system frames, use the value of
6066 double-click-fuzz as is. On other frames, interpret it
6067 as a multiple of 1/8 characters. */
6073 if (WINDOWP (event
->frame_or_window
))
6074 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
6075 else if (FRAMEP (event
->frame_or_window
))
6076 f
= XFRAME (event
->frame_or_window
);
6080 if (FRAME_WINDOW_P (f
))
6081 fuzz
= double_click_fuzz
;
6083 fuzz
= double_click_fuzz
/ 8;
6085 if (event
->modifiers
& up_modifier
)
6087 /* Emit a wheel-up event. */
6088 event
->modifiers
&= ~up_modifier
;
6091 else if (event
->modifiers
& down_modifier
)
6093 /* Emit a wheel-down event. */
6094 event
->modifiers
&= ~down_modifier
;
6098 /* Every wheel event should either have the down_modifier or
6099 the up_modifier set. */
6102 if (event
->kind
== HORIZ_WHEEL_EVENT
)
6105 is_double
= (last_mouse_button
== - (1 + symbol_num
)
6106 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
6107 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
6108 && button_down_time
!= 0
6109 && (EQ (Vdouble_click_time
, Qt
)
6110 || (INTEGERP (Vdouble_click_time
)
6111 && ((int)(event
->timestamp
- button_down_time
)
6112 < XINT (Vdouble_click_time
)))));
6115 double_click_count
++;
6116 event
->modifiers
|= ((double_click_count
> 2)
6122 double_click_count
= 1;
6123 event
->modifiers
|= click_modifier
;
6126 button_down_time
= event
->timestamp
;
6127 /* Use a negative value to distinguish wheel from mouse button. */
6128 last_mouse_button
= - (1 + symbol_num
);
6129 last_mouse_x
= XINT (event
->x
);
6130 last_mouse_y
= XINT (event
->y
);
6132 /* Get the symbol we should use for the wheel event. */
6133 head
= modify_event_symbol (symbol_num
,
6139 ASIZE (wheel_syms
));
6142 if (event
->modifiers
& (double_modifier
| triple_modifier
))
6145 Fcons (make_number (double_click_count
),
6154 #ifdef USE_TOOLKIT_SCROLL_BARS
6156 /* We don't have down and up events if using toolkit scroll bars,
6157 so make this always a click event. Store in the `part' of
6158 the Lisp event a symbol which maps to the following actions:
6160 `above_handle' page up
6161 `below_handle' page down
6165 `bottom' bottom of buffer
6166 `handle' thumb has been dragged.
6167 `end-scroll' end of interaction with scroll bar
6169 The incoming input_event contains in its `part' member an
6170 index of type `enum scroll_bar_part' which we can use as an
6171 index in scroll_bar_parts to get the appropriate symbol. */
6173 case SCROLL_BAR_CLICK_EVENT
:
6175 Lisp_Object position
, head
, window
, portion_whole
, part
;
6177 window
= event
->frame_or_window
;
6178 portion_whole
= Fcons (event
->x
, event
->y
);
6179 part
= *scroll_bar_parts
[(int) event
->part
];
6183 Fcons (Qvertical_scroll_bar
,
6184 Fcons (portion_whole
,
6185 Fcons (make_number (event
->timestamp
),
6186 Fcons (part
, Qnil
)))));
6188 /* Always treat scroll bar events as clicks. */
6189 event
->modifiers
|= click_modifier
;
6190 event
->modifiers
&= ~up_modifier
;
6192 if (event
->code
>= ASIZE (mouse_syms
))
6193 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
6195 /* Get the symbol we should use for the mouse click. */
6196 head
= modify_event_symbol (event
->code
,
6201 XVECTOR (mouse_syms
)->size
);
6202 return Fcons (head
, Fcons (position
, Qnil
));
6205 #endif /* USE_TOOLKIT_SCROLL_BARS */
6207 case DRAG_N_DROP_EVENT
:
6210 Lisp_Object head
, position
;
6213 f
= XFRAME (event
->frame_or_window
);
6216 /* Ignore mouse events that were made on frames that
6217 have been deleted. */
6218 if (! FRAME_LIVE_P (f
))
6221 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6224 head
= modify_event_symbol (0, event
->modifiers
,
6226 lispy_drag_n_drop_names
,
6227 &drag_n_drop_syms
, 1);
6233 #endif /* HAVE_MOUSE */
6235 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
6236 || defined(HAVE_NS) || defined (USE_GTK)
6237 case MENU_BAR_EVENT
:
6238 if (EQ (event
->arg
, event
->frame_or_window
))
6239 /* This is the prefix key. We translate this to
6240 `(menu_bar)' because the code in keyboard.c for menu
6241 events, which we use, relies on this. */
6242 return Fcons (Qmenu_bar
, Qnil
);
6246 case SELECT_WINDOW_EVENT
:
6247 /* Make an event (select-window (WINDOW)). */
6248 return Fcons (Qselect_window
,
6249 Fcons (Fcons (event
->frame_or_window
, Qnil
),
6252 case TOOL_BAR_EVENT
:
6253 if (EQ (event
->arg
, event
->frame_or_window
))
6254 /* This is the prefix key. We translate this to
6255 `(tool_bar)' because the code in keyboard.c for tool bar
6256 events, which we use, relies on this. */
6257 return Fcons (Qtool_bar
, Qnil
);
6258 else if (SYMBOLP (event
->arg
))
6259 return apply_modifiers (event
->modifiers
, event
->arg
);
6262 case USER_SIGNAL_EVENT
:
6263 /* A user signal. */
6265 char *name
= find_user_signal_name (event
->code
);
6268 return intern (name
);
6271 case SAVE_SESSION_EVENT
:
6272 return Qsave_session
;
6277 return Fcons (Qdbus_event
, event
->arg
);
6279 #endif /* HAVE_DBUS */
6281 case CONFIG_CHANGED_EVENT
:
6282 return Fcons (Qconfig_changed_event
,
6284 Fcons (event
->frame_or_window
, Qnil
)));
6286 case GPM_CLICK_EVENT
:
6288 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
6289 Lisp_Object head
, position
;
6290 Lisp_Object
*start_pos_ptr
;
6291 Lisp_Object start_pos
;
6292 int button
= event
->code
;
6294 if (button
>= ASIZE (button_down_location
))
6296 button_down_location
= larger_vector (button_down_location
,
6298 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
6301 start_pos_ptr
= &AREF (button_down_location
, button
);
6302 start_pos
= *start_pos_ptr
;
6304 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6307 if (event
->modifiers
& down_modifier
)
6308 *start_pos_ptr
= Fcopy_alist (position
);
6309 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
6311 if (!CONSP (start_pos
))
6313 event
->modifiers
&= ~up_modifier
;
6316 head
= modify_event_symbol (button
,
6318 Qmouse_click
, Vlispy_mouse_stem
,
6321 XVECTOR (mouse_syms
)->size
);
6323 if (event
->modifiers
& drag_modifier
)
6328 else if (event
->modifiers
& double_modifier
)
6331 Fcons (make_number (2),
6333 else if (event
->modifiers
& triple_modifier
)
6336 Fcons (make_number (3),
6343 #endif /* HAVE_GPM */
6345 /* The 'kind' field of the event is something we don't recognize. */
6351 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6354 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
6356 Lisp_Object bar_window
;
6357 enum scroll_bar_part part
;
6361 /* Is it a scroll bar movement? */
6362 if (frame
&& ! NILP (bar_window
))
6364 Lisp_Object part_sym
;
6366 part_sym
= *scroll_bar_parts
[(int) part
];
6367 return Fcons (Qscroll_bar_movement
,
6368 (Fcons (Fcons (bar_window
,
6369 Fcons (Qvertical_scroll_bar
,
6370 Fcons (Fcons (x
, y
),
6371 Fcons (make_number (time
),
6377 /* Or is it an ordinary mouse movement? */
6380 Lisp_Object position
;
6382 position
= make_lispy_position (frame
, &x
, &y
, time
);
6384 return Fcons (Qmouse_movement
,
6390 #endif /* HAVE_MOUSE || HAVE GPM */
6392 /* Construct a switch frame event. */
6394 make_lispy_switch_frame (frame
)
6397 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6400 /* Manipulating modifiers. */
6402 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6404 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6405 SYMBOL's name of the end of the modifiers; the string from this
6406 position is the unmodified symbol name.
6408 This doesn't use any caches. */
6411 parse_modifiers_uncached (symbol
, modifier_end
)
6419 CHECK_SYMBOL (symbol
);
6422 name
= SYMBOL_NAME (symbol
);
6424 for (i
= 0; i
+2 <= SBYTES (name
); )
6426 int this_mod_end
= 0;
6429 /* See if the name continues with a modifier word.
6430 Check that the word appears, but don't check what follows it.
6431 Set this_mod and this_mod_end to record what we find. */
6433 switch (SREF (name
, i
))
6435 #define SINGLE_LETTER_MOD(BIT) \
6436 (this_mod_end = i + 1, this_mod = BIT)
6439 SINGLE_LETTER_MOD (alt_modifier
);
6443 SINGLE_LETTER_MOD (ctrl_modifier
);
6447 SINGLE_LETTER_MOD (hyper_modifier
);
6451 SINGLE_LETTER_MOD (meta_modifier
);
6455 SINGLE_LETTER_MOD (shift_modifier
);
6459 SINGLE_LETTER_MOD (super_modifier
);
6462 #undef SINGLE_LETTER_MOD
6464 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6465 if (i + LEN + 1 <= SBYTES (name) \
6466 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6468 this_mod_end = i + LEN; \
6473 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6474 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6475 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6479 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6481 #undef MULTI_LETTER_MOD
6485 /* If we found no modifier, stop looking for them. */
6486 if (this_mod_end
== 0)
6489 /* Check there is a dash after the modifier, so that it
6490 really is a modifier. */
6491 if (this_mod_end
>= SBYTES (name
)
6492 || SREF (name
, this_mod_end
) != '-')
6495 /* This modifier is real; look for another. */
6496 modifiers
|= this_mod
;
6497 i
= this_mod_end
+ 1;
6500 /* Should we include the `click' modifier? */
6501 if (! (modifiers
& (down_modifier
| drag_modifier
6502 | double_modifier
| triple_modifier
))
6503 && i
+ 7 == SBYTES (name
)
6504 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
6505 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6506 modifiers
|= click_modifier
;
6508 if (! (modifiers
& (double_modifier
| triple_modifier
))
6509 && i
+ 6 < SBYTES (name
)
6510 && strncmp (SDATA (name
) + i
, "wheel-", 6) == 0)
6511 modifiers
|= click_modifier
;
6519 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6520 prepended to the string BASE[0..BASE_LEN-1].
6521 This doesn't use any caches. */
6523 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
6526 int base_len
, base_len_byte
;
6528 /* Since BASE could contain nulls, we can't use intern here; we have
6529 to use Fintern, which expects a genuine Lisp_String, and keeps a
6532 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6538 /* Only the event queue may use the `up' modifier; it should always
6539 be turned into a click or drag event before presented to lisp code. */
6540 if (modifiers
& up_modifier
)
6543 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6544 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6545 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6546 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6547 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6548 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6549 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6550 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6551 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6552 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6553 /* The click modifier is denoted by the absence of other modifiers. */
6557 mod_len
= p
- new_mods
;
6561 Lisp_Object new_name
;
6563 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6564 mod_len
+ base_len_byte
);
6565 bcopy (new_mods
, SDATA (new_name
), mod_len
);
6566 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
6568 return Fintern (new_name
, Qnil
);
6573 static const char *modifier_names
[] =
6575 "up", "down", "drag", "click", "double", "triple", 0, 0,
6576 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6577 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6579 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6581 static Lisp_Object modifier_symbols
;
6583 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6585 lispy_modifier_list (modifiers
)
6588 Lisp_Object modifier_list
;
6591 modifier_list
= Qnil
;
6592 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6593 if (modifiers
& (1<<i
))
6594 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6597 return modifier_list
;
6601 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6602 where UNMODIFIED is the unmodified form of SYMBOL,
6603 MASK is the set of modifiers present in SYMBOL's name.
6604 This is similar to parse_modifiers_uncached, but uses the cache in
6605 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6606 Qevent_symbol_elements property. */
6608 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6611 parse_modifiers (symbol
)
6614 Lisp_Object elements
;
6616 if (INTEGERP (symbol
))
6617 return (Fcons (make_number (KEY_TO_CHAR (symbol
)),
6618 Fcons (make_number (XINT (symbol
) & CHAR_MODIFIER_MASK
),
6620 else if (!SYMBOLP (symbol
))
6623 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6624 if (CONSP (elements
))
6629 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6630 Lisp_Object unmodified
;
6633 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6634 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6637 if (modifiers
& ~INTMASK
)
6639 XSETFASTINT (mask
, modifiers
);
6640 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6642 /* Cache the parsing results on SYMBOL. */
6643 Fput (symbol
, Qevent_symbol_element_mask
,
6645 Fput (symbol
, Qevent_symbol_elements
,
6646 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6648 /* Since we know that SYMBOL is modifiers applied to unmodified,
6649 it would be nice to put that in unmodified's cache.
6650 But we can't, since we're not sure that parse_modifiers is
6657 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers
,
6658 Sevent_symbol_parse_modifiers
, 1, 1, 0,
6659 doc
: /* Parse the event symbol. For internal use. */)
6663 /* Fill the cache if needed. */
6664 parse_modifiers (symbol
);
6665 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6666 and use the Lispier representation stored on Qevent_symbol_elements
6668 return Fget (symbol
, Qevent_symbol_elements
);
6671 /* Apply the modifiers MODIFIERS to the symbol BASE.
6672 BASE must be unmodified.
6674 This is like apply_modifiers_uncached, but uses BASE's
6675 Qmodifier_cache property, if present. It also builds
6676 Qevent_symbol_elements properties, since it has that info anyway.
6678 apply_modifiers copies the value of BASE's Qevent_kind property to
6679 the modified symbol. */
6681 apply_modifiers (modifiers
, base
)
6685 Lisp_Object cache
, index
, entry
, new_symbol
;
6687 /* Mask out upper bits. We don't know where this value's been. */
6688 modifiers
&= INTMASK
;
6690 if (INTEGERP (base
))
6691 return make_number (XINT (base
) | modifiers
);
6693 /* The click modifier never figures into cache indices. */
6694 cache
= Fget (base
, Qmodifier_cache
);
6695 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6696 entry
= assq_no_quit (index
, cache
);
6699 new_symbol
= XCDR (entry
);
6702 /* We have to create the symbol ourselves. */
6703 new_symbol
= apply_modifiers_uncached (modifiers
,
6704 SDATA (SYMBOL_NAME (base
)),
6705 SCHARS (SYMBOL_NAME (base
)),
6706 SBYTES (SYMBOL_NAME (base
)));
6708 /* Add the new symbol to the base's cache. */
6709 entry
= Fcons (index
, new_symbol
);
6710 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6712 /* We have the parsing info now for free, so we could add it to
6714 XSETFASTINT (index, modifiers);
6715 Fput (new_symbol, Qevent_symbol_element_mask,
6716 Fcons (base, Fcons (index, Qnil)));
6717 Fput (new_symbol, Qevent_symbol_elements,
6718 Fcons (base, lispy_modifier_list (modifiers)));
6719 Sadly, this is only correct if `base' is indeed a base event,
6720 which is not necessarily the case. -stef */
6723 /* Make sure this symbol is of the same kind as BASE.
6725 You'd think we could just set this once and for all when we
6726 intern the symbol above, but reorder_modifiers may call us when
6727 BASE's property isn't set right; we can't assume that just
6728 because it has a Qmodifier_cache property it must have its
6729 Qevent_kind set right as well. */
6730 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6734 kind
= Fget (base
, Qevent_kind
);
6736 Fput (new_symbol
, Qevent_kind
, kind
);
6743 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6744 return a symbol with the modifiers placed in the canonical order.
6745 Canonical order is alphabetical, except for down and drag, which
6746 always come last. The 'click' modifier is never written out.
6748 Fdefine_key calls this to make sure that (for example) C-M-foo
6749 and M-C-foo end up being equivalent in the keymap. */
6752 reorder_modifiers (symbol
)
6755 /* It's hopefully okay to write the code this way, since everything
6756 will soon be in caches, and no consing will be done at all. */
6759 parsed
= parse_modifiers (symbol
);
6760 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6765 /* For handling events, we often want to produce a symbol whose name
6766 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6767 to some base, like the name of a function key or mouse button.
6768 modify_event_symbol produces symbols of this sort.
6770 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6771 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6774 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6775 into symbol names, or a string specifying a name stem used to
6776 construct a symbol name or the form `STEM-N', where N is the decimal
6777 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6778 non-nil; otherwise NAME_TABLE is used.
6780 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6781 persist between calls to modify_event_symbol that it can use to
6782 store a cache of the symbols it's generated for this NAME_TABLE
6783 before. The object stored there may be a vector or an alist.
6785 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6787 MODIFIERS is a set of modifier bits (as given in struct input_events)
6788 whose prefixes should be applied to the symbol name.
6790 SYMBOL_KIND is the value to be placed in the event_kind property of
6791 the returned symbol.
6793 The symbols we create are supposed to have an
6794 `event-symbol-elements' property, which lists the modifiers present
6795 in the symbol's name. */
6798 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6799 name_table
, symbol_table
, table_size
)
6802 Lisp_Object symbol_kind
;
6803 Lisp_Object name_alist_or_stem
;
6805 Lisp_Object
*symbol_table
;
6806 unsigned int table_size
;
6809 Lisp_Object symbol_int
;
6811 /* Get rid of the "vendor-specific" bit here. */
6812 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6814 /* Is this a request for a valid symbol? */
6815 if (symbol_num
< 0 || symbol_num
>= table_size
)
6818 if (CONSP (*symbol_table
))
6819 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6821 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6822 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6823 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6824 we've never used that symbol before. */
6827 if (! VECTORP (*symbol_table
)
6828 || XVECTOR (*symbol_table
)->size
!= table_size
)
6832 XSETFASTINT (size
, table_size
);
6833 *symbol_table
= Fmake_vector (size
, Qnil
);
6836 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6839 /* Have we already used this symbol before? */
6842 /* No; let's create it. */
6843 if (CONSP (name_alist_or_stem
))
6844 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6845 else if (STRINGP (name_alist_or_stem
))
6847 int len
= SBYTES (name_alist_or_stem
);
6848 char *buf
= (char *) alloca (len
+ 50);
6849 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6850 (long) XINT (symbol_int
) + 1);
6851 value
= intern (buf
);
6853 else if (name_table
!= 0 && name_table
[symbol_num
])
6854 value
= intern (name_table
[symbol_num
]);
6856 #ifdef HAVE_WINDOW_SYSTEM
6859 char *name
= x_get_keysym_name (symbol_num
);
6861 value
= intern (name
);
6868 sprintf (buf
, "key-%d", symbol_num
);
6869 value
= intern (buf
);
6872 if (CONSP (*symbol_table
))
6873 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6875 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6877 /* Fill in the cache entries for this symbol; this also
6878 builds the Qevent_symbol_elements property, which the user
6880 apply_modifiers (modifiers
& click_modifier
, value
);
6881 Fput (value
, Qevent_kind
, symbol_kind
);
6884 /* Apply modifiers to that symbol. */
6885 return apply_modifiers (modifiers
, value
);
6888 /* Convert a list that represents an event type,
6889 such as (ctrl meta backspace), into the usual representation of that
6890 event type as a number or a symbol. */
6892 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6893 doc
: /* Convert the event description list EVENT-DESC to an event type.
6894 EVENT-DESC should contain one base event type (a character or symbol)
6895 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6896 drag, down, double or triple). The base must be last.
6897 The return value is an event type (a character or symbol) which
6898 has the same base event type and all the specified modifiers. */)
6900 Lisp_Object event_desc
;
6908 while (CONSP (rest
))
6916 /* Given a symbol, see if it is a modifier name. */
6917 if (SYMBOLP (elt
) && CONSP (rest
))
6918 this = parse_solitary_modifier (elt
);
6922 else if (!NILP (base
))
6923 error ("Two bases given in one event");
6929 /* Let the symbol A refer to the character A. */
6930 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6931 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6933 if (INTEGERP (base
))
6935 /* Turn (shift a) into A. */
6936 if ((modifiers
& shift_modifier
) != 0
6937 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6939 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6940 modifiers
&= ~shift_modifier
;
6943 /* Turn (control a) into C-a. */
6944 if (modifiers
& ctrl_modifier
)
6945 return make_number ((modifiers
& ~ctrl_modifier
)
6946 | make_ctrl_char (XINT (base
)));
6948 return make_number (modifiers
| XINT (base
));
6950 else if (SYMBOLP (base
))
6951 return apply_modifiers (modifiers
, base
);
6954 error ("Invalid base event");
6959 /* Try to recognize SYMBOL as a modifier name.
6960 Return the modifier flag bit, or 0 if not recognized. */
6963 parse_solitary_modifier (Lisp_Object symbol
)
6965 Lisp_Object name
= SYMBOL_NAME (symbol
);
6967 switch (SREF (name
, 0))
6969 #define SINGLE_LETTER_MOD(BIT) \
6970 if (SBYTES (name) == 1) \
6973 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6974 if (LEN == SBYTES (name) \
6975 && ! strncmp (SDATA (name), NAME, LEN)) \
6979 SINGLE_LETTER_MOD (alt_modifier
);
6983 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6987 SINGLE_LETTER_MOD (ctrl_modifier
);
6991 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6992 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6996 SINGLE_LETTER_MOD (hyper_modifier
);
7000 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
7004 SINGLE_LETTER_MOD (meta_modifier
);
7008 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
7012 SINGLE_LETTER_MOD (shift_modifier
);
7016 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
7017 MULTI_LETTER_MOD (super_modifier
, "super", 5);
7018 SINGLE_LETTER_MOD (super_modifier
);
7022 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
7023 MULTI_LETTER_MOD (down_modifier
, "down", 4);
7024 MULTI_LETTER_MOD (double_modifier
, "double", 6);
7028 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
7031 #undef SINGLE_LETTER_MOD
7032 #undef MULTI_LETTER_MOD
7038 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
7039 Such a list is not valid as an event,
7040 but it can be a Lucid-style event type list. */
7043 lucid_event_type_list_p (object
)
7048 if (! CONSP (object
))
7051 if (EQ (XCAR (object
), Qhelp_echo
)
7052 || EQ (XCAR (object
), Qvertical_line
)
7053 || EQ (XCAR (object
), Qmode_line
)
7054 || EQ (XCAR (object
), Qheader_line
))
7057 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
7061 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
7068 /* Store into *addr a value nonzero if terminal input chars are available.
7069 Serves the purpose of ioctl (0, FIONREAD, addr)
7070 but works even if FIONREAD does not exist.
7071 (In fact, this may actually read some input.)
7073 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
7074 timer events that are ripe.
7075 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
7076 events (FOCUS_IN_EVENT).
7077 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
7078 movements and toolkit scroll bar thumb drags. */
7081 get_input_pending (addr
, flags
)
7085 /* First of all, have we already counted some input? */
7086 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
7088 /* If input is being read as it arrives, and we have none, there is none. */
7089 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
7092 /* Try to read some input and see how much we get. */
7094 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
7097 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
7100 gobble_input (expected
)
7104 if (interrupt_input
)
7107 mask
= sigblock (sigmask (SIGIO
));
7108 read_avail_input (expected
);
7112 #ifdef POLL_FOR_INPUT
7113 /* XXX This condition was (read_socket_hook && !interrupt_input),
7114 but read_socket_hook is not global anymore. Let's pretend that
7116 if (!interrupt_input
&& poll_suppress_count
== 0)
7119 mask
= sigblock (sigmask (SIGALRM
));
7120 read_avail_input (expected
);
7126 read_avail_input (expected
);
7129 /* Put a BUFFER_SWITCH_EVENT in the buffer
7130 so that read_key_sequence will notice the new current buffer. */
7133 record_asynch_buffer_change ()
7135 struct input_event event
;
7139 event
.kind
= BUFFER_SWITCH_EVENT
;
7140 event
.frame_or_window
= Qnil
;
7144 /* We don't need a buffer-switch event unless Emacs is waiting for input.
7145 The purpose of the event is to make read_key_sequence look up the
7146 keymaps again. If we aren't in read_key_sequence, we don't need one,
7147 and the event could cause trouble by messing up (input-pending-p). */
7148 tem
= Fwaiting_for_user_input_p ();
7152 /* We never need these events if we have no asynchronous subprocesses. */
7156 /* Make sure no interrupt happens while storing the event. */
7158 if (interrupt_input
)
7161 mask
= sigblock (sigmask (SIGIO
));
7162 kbd_buffer_store_event (&event
);
7169 kbd_buffer_store_event (&event
);
7174 /* Read any terminal input already buffered up by the system
7175 into the kbd_buffer, but do not wait.
7177 EXPECTED should be nonzero if the caller knows there is some input.
7179 Returns the number of keyboard chars read, or -1 meaning
7180 this is a bad time to try to read input. */
7183 read_avail_input (expected
)
7190 /* Store pending user signal events, if any. */
7191 if (store_user_signal_events ())
7194 /* Loop through the available terminals, and call their input hooks. */
7198 struct terminal
*next
= t
->next_terminal
;
7200 if (t
->read_socket_hook
)
7203 struct input_event hold_quit
;
7205 EVENT_INIT (hold_quit
);
7206 hold_quit
.kind
= NO_EVENT
;
7208 /* No need for FIONREAD or fcntl; just say don't wait. */
7209 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
7215 if (nr
== -1) /* Not OK to read input now. */
7219 else if (nr
== -2) /* Non-transient error. */
7221 /* The terminal device terminated; it should be closed. */
7223 /* Kill Emacs if this was our last terminal. */
7224 if (!terminal_list
->next_terminal
)
7225 /* Formerly simply reported no input, but that
7226 sometimes led to a failure of Emacs to terminate.
7227 SIGHUP seems appropriate if we can't reach the
7229 /* ??? Is it really right to send the signal just to
7230 this process rather than to the whole process
7231 group? Perhaps on systems with FIONREAD Emacs is
7232 alone in its group. */
7233 kill (getpid (), SIGHUP
);
7235 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
7238 XSETTERMINAL (tmp
, t
);
7239 Fdelete_terminal (tmp
, Qnoelisp
);
7243 if (hold_quit
.kind
!= NO_EVENT
)
7244 kbd_buffer_store_event (&hold_quit
);
7253 frame_make_pointer_visible ();
7259 decode_keyboard_code (struct tty_display_info
*tty
,
7260 struct coding_system
*coding
,
7261 unsigned char *buf
, int nbytes
)
7263 unsigned char *src
= buf
;
7264 const unsigned char *p
;
7269 if (tty
->meta_key
!= 2)
7270 for (i
= 0; i
< nbytes
; i
++)
7272 if (coding
->carryover_bytes
> 0)
7274 src
= alloca (coding
->carryover_bytes
+ nbytes
);
7275 memcpy (src
, coding
->carryover
, coding
->carryover_bytes
);
7276 memcpy (src
+ coding
->carryover_bytes
, buf
, nbytes
);
7277 nbytes
+= coding
->carryover_bytes
;
7279 coding
->destination
= alloca (nbytes
* 4);
7280 coding
->dst_bytes
= nbytes
* 4;
7281 decode_coding_c_string (coding
, src
, nbytes
, Qnil
);
7282 if (coding
->produced_char
== 0)
7284 for (i
= 0, p
= coding
->destination
; i
< coding
->produced_char
; i
++)
7286 struct input_event buf
;
7289 buf
.code
= STRING_CHAR_ADVANCE (p
);
7290 buf
.kind
= (ASCII_CHAR_P (buf
.code
)
7291 ? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7292 /* See the comment in tty_read_avail_input. */
7293 buf
.frame_or_window
= tty
->top_frame
;
7295 kbd_buffer_store_event (&buf
);
7299 /* This is the tty way of reading available input.
7301 Note that each terminal device has its own `struct terminal' object,
7302 and so this function is called once for each individual termcap
7303 terminal. The first parameter indicates which terminal to read from. */
7306 tty_read_avail_input (struct terminal
*terminal
,
7308 struct input_event
*hold_quit
)
7310 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
7311 the kbd_buffer can really hold. That may prevent loss
7312 of characters on some systems when input is stuffed at us. */
7313 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
7315 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
7318 int buffer_free
= KBD_BUFFER_SIZE
- kbd_buffer_nr_stored () - 1;
7320 if (kbd_on_hold_p () || buffer_free
<= 0)
7322 #endif /* subprocesses */
7324 if (!terminal
->name
) /* Don't read from a dead terminal. */
7327 if (terminal
->type
!= output_termcap
7328 && terminal
->type
!= output_msdos_raw
)
7331 /* XXX I think the following code should be moved to separate hook
7332 functions in system-dependent files. */
7335 #else /* not WINDOWSNT */
7336 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
7340 return 0; /* The terminal is suspended. */
7343 n_to_read
= dos_keysns ();
7347 cbuf
[0] = dos_keyread ();
7350 #else /* not MSDOS */
7355 struct input_event hold_quit
;
7356 int gpm
, fd
= gpm_fd
;
7358 EVENT_INIT (hold_quit
);
7359 hold_quit
.kind
= NO_EVENT
;
7361 /* gpm==1 if event received.
7362 gpm==0 if the GPM daemon has closed the connection, in which case
7363 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
7364 we save it in `fd' so close_gpm can remove it from the
7366 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
7367 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
7368 nread
+= handle_one_term_event (tty
, &event
, &hold_quit
);
7371 /* Presumably the GPM daemon has closed the connection. */
7373 if (hold_quit
.kind
!= NO_EVENT
)
7374 kbd_buffer_store_event (&hold_quit
);
7378 #endif /* HAVE_GPM */
7380 /* Determine how many characters we should *try* to read. */
7382 /* Find out how much input is available. */
7383 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
7385 if (! noninteractive
)
7386 return -2; /* Close this terminal. */
7392 if (n_to_read
> sizeof cbuf
)
7393 n_to_read
= sizeof cbuf
;
7394 #else /* no FIONREAD */
7395 #if defined (USG) || defined(CYGWIN)
7396 /* Read some input if available, but don't wait. */
7397 n_to_read
= sizeof cbuf
;
7398 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
7405 /* Don't read more than we can store. */
7406 if (n_to_read
> buffer_free
)
7407 n_to_read
= buffer_free
;
7408 #endif /* subprocesses */
7410 /* Now read; for one reason or another, this will not block.
7411 NREAD is set to the number of chars read. */
7414 nread
= emacs_read (fileno (tty
->input
), cbuf
, n_to_read
);
7415 /* POSIX infers that processes which are not in the session leader's
7416 process group won't get SIGHUP's at logout time. BSDI adheres to
7417 this part standard and returns -1 from read (0) with errno==EIO
7418 when the control tty is taken away.
7419 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7420 if (nread
== -1 && errno
== EIO
)
7421 return -2; /* Close this terminal. */
7422 #if defined (AIX) && defined (_BSD)
7423 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7424 This looks incorrect, but it isn't, because _BSD causes
7425 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7426 and that causes a value other than 0 when there is no input. */
7428 return -2; /* Close this terminal. */
7432 /* We used to retry the read if it was interrupted.
7433 But this does the wrong thing when O_NDELAY causes
7434 an EAGAIN error. Does anybody know of a situation
7435 where a retry is actually needed? */
7437 nread
< 0 && (errno
== EAGAIN
7451 #if defined (USG) || defined (CYGWIN)
7452 fcntl (fileno (tty
->input
), F_SETFL
, 0);
7453 #endif /* USG or CYGWIN */
7454 #endif /* no FIONREAD */
7459 #endif /* not MSDOS */
7460 #endif /* not WINDOWSNT */
7462 if (TERMINAL_KEYBOARD_CODING (terminal
)->common_flags
7463 & CODING_REQUIRE_DECODING_MASK
)
7465 struct coding_system
*coding
= TERMINAL_KEYBOARD_CODING (terminal
);
7468 /* Decode the key sequence except for those with meta
7470 for (i
= from
= 0; ; i
++)
7471 if (i
== nread
|| (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80)))
7473 struct input_event buf
;
7475 decode_keyboard_code (tty
, coding
, cbuf
+ from
, i
- from
);
7480 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7481 buf
.modifiers
= meta_modifier
;
7482 buf
.code
= cbuf
[i
] & ~0x80;
7483 /* See the comment below. */
7484 buf
.frame_or_window
= tty
->top_frame
;
7486 kbd_buffer_store_event (&buf
);
7492 for (i
= 0; i
< nread
; i
++)
7494 struct input_event buf
;
7496 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7498 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7499 buf
.modifiers
= meta_modifier
;
7500 if (tty
->meta_key
!= 2)
7504 /* Set the frame corresponding to the active tty. Note that the
7505 value of selected_frame is not reliable here, redisplay tends
7506 to temporarily change it. */
7507 buf
.frame_or_window
= tty
->top_frame
;
7510 kbd_buffer_store_event (&buf
);
7511 /* Don't look at input that follows a C-g too closely.
7512 This reduces lossage due to autorepeat on C-g. */
7513 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7514 && buf
.code
== quit_char
)
7522 handle_async_input ()
7524 interrupt_input_pending
= 0;
7526 pending_signals
= pending_atimers
;
7528 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
7529 doing anything dangerous. */
7536 nread
= read_avail_input (1);
7537 /* -1 means it's not ok to read the input now.
7538 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7539 0 means there was no keyboard input available. */
7549 process_pending_signals ()
7551 if (interrupt_input_pending
)
7552 handle_async_input ();
7553 do_pending_atimers ();
7556 #ifdef SIGIO /* for entire page */
7557 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7560 input_available_signal (signo
)
7563 /* Must preserve main program's value of errno. */
7564 int old_errno
= errno
;
7565 #if defined (USG) && !defined (POSIX_SIGNALS)
7566 /* USG systems forget handlers when they are used;
7567 must reestablish each time */
7568 signal (signo
, input_available_signal
);
7571 SIGNAL_THREAD_CHECK (signo
);
7574 interrupt_input_pending
= 1;
7575 pending_signals
= 1;
7578 if (input_available_clear_time
)
7579 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7582 handle_async_input ();
7589 /* Send ourselves a SIGIO.
7591 This function exists so that the UNBLOCK_INPUT macro in
7592 blockinput.h can have some way to take care of input we put off
7593 dealing with, without assuming that every file which uses
7594 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7596 reinvoke_input_signal ()
7599 handle_async_input ();
7605 /* User signal events. */
7607 struct user_signal_info
7609 /* Signal number. */
7612 /* Name of the signal. */
7615 /* Number of pending signals. */
7618 struct user_signal_info
*next
;
7621 /* List of user signals. */
7622 static struct user_signal_info
*user_signals
= NULL
;
7625 add_user_signal (sig
, name
)
7629 struct user_signal_info
*p
;
7631 for (p
= user_signals
; p
; p
= p
->next
)
7633 /* Already added. */
7636 p
= xmalloc (sizeof (struct user_signal_info
));
7638 p
->name
= xstrdup (name
);
7640 p
->next
= user_signals
;
7643 signal (sig
, handle_user_signal
);
7647 handle_user_signal (sig
)
7650 int old_errno
= errno
;
7651 struct user_signal_info
*p
;
7653 #if defined (USG) && !defined (POSIX_SIGNALS)
7654 /* USG systems forget handlers when they are used;
7655 must reestablish each time */
7656 signal (sig
, handle_user_signal
);
7659 SIGNAL_THREAD_CHECK (sig
);
7661 for (p
= user_signals
; p
; p
= p
->next
)
7666 if (interrupt_input
)
7667 kill (getpid (), SIGIO
);
7671 /* Tell wait_reading_process_output that it needs to wake
7672 up and look around. */
7673 if (input_available_clear_time
)
7674 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7683 find_user_signal_name (sig
)
7686 struct user_signal_info
*p
;
7688 for (p
= user_signals
; p
; p
= p
->next
)
7696 store_user_signal_events ()
7698 struct user_signal_info
*p
;
7699 struct input_event buf
;
7702 for (p
= user_signals
; p
; p
= p
->next
)
7703 if (p
->npending
> 0)
7709 bzero (&buf
, sizeof buf
);
7710 buf
.kind
= USER_SIGNAL_EVENT
;
7711 buf
.frame_or_window
= selected_frame
;
7713 nstored
+= p
->npending
;
7715 mask
= sigblock (sigmask (p
->sig
));
7719 kbd_buffer_store_event (&buf
);
7722 while (p
->npending
> 0);
7730 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
7731 static Lisp_Object menu_bar_one_keymap_changed_items
;
7733 /* These variables hold the vector under construction within
7734 menu_bar_items and its subroutines, and the current index
7735 for storing into that vector. */
7736 static Lisp_Object menu_bar_items_vector
;
7737 static int menu_bar_items_index
;
7739 /* Return a vector of menu items for a menu bar, appropriate
7740 to the current buffer. Each item has three elements in the vector:
7743 OLD is an old vector we can optionally reuse, or nil. */
7746 menu_bar_items (old
)
7749 /* The number of keymaps we're scanning right now, and the number of
7750 keymaps we have allocated space for. */
7753 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7754 in the current keymaps, or nil where it is not a prefix. */
7757 Lisp_Object def
, tail
;
7766 /* In order to build the menus, we need to call the keymap
7767 accessors. They all call QUIT. But this function is called
7768 during redisplay, during which a quit is fatal. So inhibit
7769 quitting while building the menus.
7770 We do this instead of specbind because (1) errors will clear it anyway
7771 and (2) this avoids risk of specpdl overflow. */
7772 oquit
= Vinhibit_quit
;
7776 menu_bar_items_vector
= old
;
7778 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7779 menu_bar_items_index
= 0;
7781 /* Build our list of keymaps.
7782 If we recognize a function key and replace its escape sequence in
7783 keybuf with its symbol, or if the sequence starts with a mouse
7784 click and we need to switch buffers, we jump back here to rebuild
7785 the initial keymaps from the current buffer. */
7789 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7790 if (!NILP (Voverriding_local_map_menu_flag
))
7792 /* Yes, use them (if non-nil) as well as the global map. */
7793 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7795 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7796 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7797 if (!NILP (Voverriding_local_map
))
7798 maps
[nmaps
++] = Voverriding_local_map
;
7802 /* No, so use major and minor mode keymaps and keymap property.
7803 Note that menu-bar bindings in the local-map and keymap
7804 properties may not work reliable, as they are only
7805 recognized when the menu-bar (or mode-line) is updated,
7806 which does not normally happen after every command. */
7809 nminor
= current_minor_maps (NULL
, &tmaps
);
7810 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7812 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7813 maps
[nmaps
++] = tem
;
7814 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7816 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7818 maps
[nmaps
++] = current_global_map
;
7821 /* Look up in each map the dummy prefix key `menu-bar'. */
7825 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7826 if (!NILP (maps
[mapno
]))
7828 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7832 menu_bar_one_keymap_changed_items
= Qnil
;
7833 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7837 /* Move to the end those items that should be at the end. */
7839 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7842 int end
= menu_bar_items_index
;
7844 for (i
= 0; i
< end
; i
+= 4)
7845 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7847 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7848 /* Move the item at index I to the end,
7849 shifting all the others forward. */
7850 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7851 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7852 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7853 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7855 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7856 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7857 (end
- i
- 4) * sizeof (Lisp_Object
));
7858 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7859 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7860 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7861 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7866 /* Add nil, nil, nil, nil at the end. */
7867 i
= menu_bar_items_index
;
7868 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7869 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7870 /* Add this item. */
7871 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7872 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7873 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7874 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7875 menu_bar_items_index
= i
;
7877 Vinhibit_quit
= oquit
;
7878 return menu_bar_items_vector
;
7881 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7882 If there's already an item for KEY, add this DEF to it. */
7884 Lisp_Object item_properties
;
7887 menu_bar_item (key
, item
, dummy1
, dummy2
)
7888 Lisp_Object key
, item
, dummy1
;
7891 struct gcpro gcpro1
;
7895 if (EQ (item
, Qundefined
))
7897 /* If a map has an explicit `undefined' as definition,
7898 discard any previously made menu bar item. */
7900 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7901 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7903 if (menu_bar_items_index
> i
+ 4)
7904 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7905 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7906 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7907 menu_bar_items_index
-= 4;
7911 /* If this keymap has already contributed to this KEY,
7912 don't contribute to it a second time. */
7913 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7914 if (!NILP (tem
) || NILP (item
))
7917 menu_bar_one_keymap_changed_items
7918 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7920 /* We add to menu_bar_one_keymap_changed_items before doing the
7921 parse_menu_item, so that if it turns out it wasn't a menu item,
7922 it still correctly hides any further menu item. */
7924 i
= parse_menu_item (item
, 1);
7929 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7931 /* Find any existing item for this KEY. */
7932 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7933 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7936 /* If we did not find this KEY, add it at the end. */
7937 if (i
== menu_bar_items_index
)
7939 /* If vector is too small, get a bigger one. */
7940 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7941 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7942 /* Add this item. */
7943 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7944 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7945 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7946 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7947 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7948 menu_bar_items_index
= i
;
7950 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7954 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7955 /* If the new and the old items are not both keymaps,
7956 the lookup will only find `item'. */
7957 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7958 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7962 /* This is used as the handler when calling menu_item_eval_property. */
7964 menu_item_eval_property_1 (arg
)
7967 /* If we got a quit from within the menu computation,
7968 quit all the way out of it. This takes care of C-] in the debugger. */
7969 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7970 Fsignal (Qquit
, Qnil
);
7975 /* Evaluate an expression and return the result (or nil if something
7976 went wrong). Used to evaluate dynamic parts of menu items. */
7978 menu_item_eval_property (sexpr
)
7981 int count
= SPECPDL_INDEX ();
7983 specbind (Qinhibit_redisplay
, Qt
);
7984 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7985 menu_item_eval_property_1
);
7986 return unbind_to (count
, val
);
7989 /* This function parses a menu item and leaves the result in the
7990 vector item_properties.
7991 ITEM is a key binding, a possible menu item.
7992 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7994 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7995 parse_menu_item returns true if the item is a menu item and false
7999 parse_menu_item (item
, inmenubar
)
8003 Lisp_Object def
, tem
, item_string
, start
;
8005 Lisp_Object keyhint
;
8014 /* Create item_properties vector if necessary. */
8015 if (NILP (item_properties
))
8017 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
8019 /* Initialize optional entries. */
8020 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
8021 ASET (item_properties
, i
, Qnil
);
8022 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
8024 /* Save the item here to protect it from GC. */
8025 ASET (item_properties
, ITEM_PROPERTY_ITEM
, item
);
8027 item_string
= XCAR (item
);
8031 if (STRINGP (item_string
))
8033 /* Old format menu item. */
8034 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
8036 /* Maybe help string. */
8037 if (CONSP (item
) && STRINGP (XCAR (item
)))
8039 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
8044 /* Maybe an obsolete key binding cache. */
8045 if (CONSP (item
) && CONSP (XCAR (item
))
8046 && (NILP (XCAR (XCAR (item
)))
8047 || VECTORP (XCAR (XCAR (item
)))))
8050 /* This is the real definition--the function to run. */
8051 ASET (item_properties
, ITEM_PROPERTY_DEF
, item
);
8053 /* Get enable property, if any. */
8056 tem
= Fget (item
, Qmenu_enable
);
8057 if (!NILP (Venable_disabled_menus_and_buttons
))
8058 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
8059 else if (!NILP (tem
))
8060 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
8063 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
8065 /* New format menu item. */
8066 ASET (item_properties
, ITEM_PROPERTY_NAME
, XCAR (item
));
8067 start
= XCDR (item
);
8070 /* We have a real binding. */
8071 ASET (item_properties
, ITEM_PROPERTY_DEF
, XCAR (start
));
8073 item
= XCDR (start
);
8074 /* Is there an obsolete cache list with key equivalences. */
8075 if (CONSP (item
) && CONSP (XCAR (item
)))
8078 /* Parse properties. */
8079 while (CONSP (item
) && CONSP (XCDR (item
)))
8084 if (EQ (tem
, QCenable
))
8086 if (!NILP (Venable_disabled_menus_and_buttons
))
8087 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
8089 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, XCAR (item
));
8091 else if (EQ (tem
, QCvisible
))
8093 /* If got a visible property and that evaluates to nil
8094 then ignore this item. */
8095 tem
= menu_item_eval_property (XCAR (item
));
8099 else if (EQ (tem
, QChelp
))
8100 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
8101 else if (EQ (tem
, QCfilter
))
8103 else if (EQ (tem
, QCkey_sequence
))
8106 if (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
))
8107 /* Be GC protected. Set keyhint to item instead of tem. */
8110 else if (EQ (tem
, QCkeys
))
8113 if (CONSP (tem
) || STRINGP (tem
))
8114 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, tem
);
8116 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
8121 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8123 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
8125 ASET (item_properties
, ITEM_PROPERTY_TYPE
, type
);
8131 else if (inmenubar
|| !NILP (start
))
8135 return 0; /* not a menu item */
8137 /* If item string is not a string, evaluate it to get string.
8138 If we don't get a string, skip this item. */
8139 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
8140 if (!(STRINGP (item_string
)))
8142 item_string
= menu_item_eval_property (item_string
);
8143 if (!STRINGP (item_string
))
8145 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
8148 /* If got a filter apply it on definition. */
8149 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
8152 def
= menu_item_eval_property (list2 (XCAR (filter
),
8153 list2 (Qquote
, def
)));
8155 ASET (item_properties
, ITEM_PROPERTY_DEF
, def
);
8158 /* Enable or disable selection of item. */
8159 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
8162 tem
= menu_item_eval_property (tem
);
8163 if (inmenubar
&& NILP (tem
))
8164 return 0; /* Ignore disabled items in menu bar. */
8165 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
8168 /* If we got no definition, this item is just unselectable text which
8169 is OK in a submenu but not in the menubar. */
8171 return (inmenubar
? 0 : 1);
8173 /* See if this is a separate pane or a submenu. */
8174 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
8175 tem
= get_keymap (def
, 0, 1);
8176 /* For a subkeymap, just record its details and exit. */
8179 ASET (item_properties
, ITEM_PROPERTY_MAP
, tem
);
8180 ASET (item_properties
, ITEM_PROPERTY_DEF
, tem
);
8184 /* At the top level in the menu bar, do likewise for commands also.
8185 The menu bar does not display equivalent key bindings anyway.
8186 ITEM_PROPERTY_DEF is already set up properly. */
8190 { /* This is a command. See if there is an equivalent key binding. */
8191 Lisp_Object keyeq
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
8193 /* The previous code preferred :key-sequence to :keys, so we
8194 preserve this behavior. */
8195 if (STRINGP (keyeq
) && !CONSP (keyhint
))
8196 keyeq
= Fsubstitute_command_keys (keyeq
);
8199 Lisp_Object prefix
= keyeq
;
8200 Lisp_Object keys
= Qnil
;
8204 def
= XCAR (prefix
);
8205 prefix
= XCDR (prefix
);
8208 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
8210 if (CONSP (keyhint
) && !NILP (XCAR (keyhint
)))
8212 keys
= XCAR (keyhint
);
8213 tem
= Fkey_binding (keys
, Qnil
, Qnil
, Qnil
);
8215 /* We have a suggested key. Is it bound to the command? */
8218 /* If the command is an alias for another
8219 (such as lmenu.el set it up), check if the
8220 original command matches the cached command. */
8221 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
8226 keys
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qnil
);
8230 tem
= Fkey_description (keys
, Qnil
);
8233 if (STRINGP (XCAR (prefix
)))
8234 tem
= concat2 (XCAR (prefix
), tem
);
8235 if (STRINGP (XCDR (prefix
)))
8236 tem
= concat2 (tem
, XCDR (prefix
));
8238 keyeq
= concat2 (build_string (" "), tem
);
8239 /* keyeq = concat3(build_string(" ("),tem,build_string(")")); */
8245 /* If we have an equivalent key binding, use that. */
8246 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, keyeq
);
8249 /* Include this when menu help is implemented.
8250 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
8251 if (!(NILP (tem) || STRINGP (tem)))
8253 tem = menu_item_eval_property (tem);
8256 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
8260 /* Handle radio buttons or toggle boxes. */
8261 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
8263 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
8264 menu_item_eval_property (tem
));
8271 /***********************************************************************
8273 ***********************************************************************/
8275 /* A vector holding tool bar items while they are parsed in function
8276 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
8279 static Lisp_Object tool_bar_items_vector
;
8281 /* A vector holding the result of parse_tool_bar_item. Layout is like
8282 the one for a single item in tool_bar_items_vector. */
8284 static Lisp_Object tool_bar_item_properties
;
8286 /* Next free index in tool_bar_items_vector. */
8288 static int ntool_bar_items
;
8290 /* The symbols `tool-bar', `:image' and `:rtl'. */
8292 extern Lisp_Object Qtool_bar
;
8293 Lisp_Object QCimage
;
8296 /* Function prototypes. */
8298 static void init_tool_bar_items
P_ ((Lisp_Object
));
8299 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
8300 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
8301 static void append_tool_bar_item
P_ ((void));
8304 /* Return a vector of tool bar items for keymaps currently in effect.
8305 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
8306 tool bar items found. */
8309 tool_bar_items (reuse
, nitems
)
8320 /* In order to build the menus, we need to call the keymap
8321 accessors. They all call QUIT. But this function is called
8322 during redisplay, during which a quit is fatal. So inhibit
8323 quitting while building the menus. We do this instead of
8324 specbind because (1) errors will clear it anyway and (2) this
8325 avoids risk of specpdl overflow. */
8326 oquit
= Vinhibit_quit
;
8329 /* Initialize tool_bar_items_vector and protect it from GC. */
8330 init_tool_bar_items (reuse
);
8332 /* Build list of keymaps in maps. Set nmaps to the number of maps
8335 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8336 if (!NILP (Voverriding_local_map_menu_flag
))
8338 /* Yes, use them (if non-nil) as well as the global map. */
8339 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
8341 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8342 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8343 if (!NILP (Voverriding_local_map
))
8344 maps
[nmaps
++] = Voverriding_local_map
;
8348 /* No, so use major and minor mode keymaps and keymap property.
8349 Note that tool-bar bindings in the local-map and keymap
8350 properties may not work reliable, as they are only
8351 recognized when the tool-bar (or mode-line) is updated,
8352 which does not normally happen after every command. */
8355 nminor
= current_minor_maps (NULL
, &tmaps
);
8356 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
8358 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
8359 maps
[nmaps
++] = tem
;
8360 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
8362 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
8365 /* Add global keymap at the end. */
8366 maps
[nmaps
++] = current_global_map
;
8368 /* Process maps in reverse order and look up in each map the prefix
8370 for (i
= nmaps
- 1; i
>= 0; --i
)
8371 if (!NILP (maps
[i
]))
8375 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
8377 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
8380 Vinhibit_quit
= oquit
;
8381 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
8382 return tool_bar_items_vector
;
8386 /* Process the definition of KEY which is DEF. */
8389 process_tool_bar_item (key
, def
, data
, args
)
8390 Lisp_Object key
, def
, data
;
8394 extern Lisp_Object Qundefined
;
8395 struct gcpro gcpro1
, gcpro2
;
8397 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8401 if (EQ (def
, Qundefined
))
8403 /* If a map has an explicit `undefined' as definition,
8404 discard any previously made item. */
8405 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8407 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8409 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8411 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8412 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
8413 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8414 * sizeof (Lisp_Object
)));
8415 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8420 else if (parse_tool_bar_item (key
, def
))
8421 /* Append a new tool bar item to tool_bar_items_vector. Accept
8422 more than one definition for the same key. */
8423 append_tool_bar_item ();
8429 /* Parse a tool bar item specification ITEM for key KEY and return the
8430 result in tool_bar_item_properties. Value is zero if ITEM is
8433 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8435 CAPTION is the caption of the item, If it's not a string, it is
8436 evaluated to get a string.
8438 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8439 as binding are currently ignored.
8441 The following properties are recognized:
8445 FORM is evaluated and specifies whether the tool bar item is
8446 enabled or disabled.
8450 FORM is evaluated and specifies whether the tool bar item is visible.
8452 - `:filter FUNCTION'
8454 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8455 result is stored as the new binding.
8457 - `:button (TYPE SELECTED)'
8459 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8460 and specifies whether the button is selected (pressed) or not.
8464 IMAGES is either a single image specification or a vector of four
8465 image specifications. See enum tool_bar_item_images.
8467 - `:help HELP-STRING'.
8469 Gives a help string to display for the tool bar item. */
8472 parse_tool_bar_item (key
, item
)
8473 Lisp_Object key
, item
;
8475 /* Access slot with index IDX of vector tool_bar_item_properties. */
8476 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8478 Lisp_Object filter
= Qnil
;
8479 Lisp_Object caption
;
8482 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8483 Rule out items that aren't lists, don't start with
8484 `menu-item' or whose rest following `tool-bar-item' is not a
8487 || !EQ (XCAR (item
), Qmenu_item
)
8488 || (item
= XCDR (item
),
8492 /* Create tool_bar_item_properties vector if necessary. Reset it to
8494 if (VECTORP (tool_bar_item_properties
))
8496 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8500 tool_bar_item_properties
8501 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8504 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8505 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8507 /* Get the caption of the item. If the caption is not a string,
8508 evaluate it to get a string. If we don't get a string, skip this
8510 caption
= XCAR (item
);
8511 if (!STRINGP (caption
))
8513 caption
= menu_item_eval_property (caption
);
8514 if (!STRINGP (caption
))
8517 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8519 /* Give up if rest following the caption is not a list. */
8524 /* Store the binding. */
8525 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8528 /* Ignore cached key binding, if any. */
8529 if (CONSP (item
) && CONSP (XCAR (item
)))
8532 /* Process the rest of the properties. */
8533 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8535 Lisp_Object key
, value
;
8538 value
= XCAR (XCDR (item
));
8540 if (EQ (key
, QCenable
))
8542 /* `:enable FORM'. */
8543 if (!NILP (Venable_disabled_menus_and_buttons
))
8544 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8546 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8548 else if (EQ (key
, QCvisible
))
8550 /* `:visible FORM'. If got a visible property and that
8551 evaluates to nil then ignore this item. */
8552 if (NILP (menu_item_eval_property (value
)))
8555 else if (EQ (key
, QChelp
))
8556 /* `:help HELP-STRING'. */
8557 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8558 else if (EQ (key
, QCfilter
))
8559 /* ':filter FORM'. */
8561 else if (EQ (key
, QCbutton
) && CONSP (value
))
8563 /* `:button (TYPE . SELECTED)'. */
8564 Lisp_Object type
, selected
;
8566 type
= XCAR (value
);
8567 selected
= XCDR (value
);
8568 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8570 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8571 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8574 else if (EQ (key
, QCimage
)
8576 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8577 /* Value is either a single image specification or a vector
8578 of 4 such specifications for the different button states. */
8579 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8580 else if (EQ (key
, Qrtl
))
8582 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8585 /* If got a filter apply it on binding. */
8587 PROP (TOOL_BAR_ITEM_BINDING
)
8588 = menu_item_eval_property (list2 (filter
,
8590 PROP (TOOL_BAR_ITEM_BINDING
))));
8592 /* See if the binding is a keymap. Give up if it is. */
8593 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8596 /* Enable or disable selection of item. */
8597 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8598 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8599 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8601 /* Handle radio buttons or toggle boxes. */
8602 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8603 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8604 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8612 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8613 that can be reused. */
8616 init_tool_bar_items (reuse
)
8619 if (VECTORP (reuse
))
8620 tool_bar_items_vector
= reuse
;
8622 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8623 ntool_bar_items
= 0;
8627 /* Append parsed tool bar item properties from
8628 tool_bar_item_properties */
8631 append_tool_bar_item ()
8633 Lisp_Object
*to
, *from
;
8635 /* Enlarge tool_bar_items_vector if necessary. */
8636 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8637 >= XVECTOR (tool_bar_items_vector
)->size
)
8638 tool_bar_items_vector
8639 = larger_vector (tool_bar_items_vector
,
8640 2 * XVECTOR (tool_bar_items_vector
)->size
, Qnil
);
8642 /* Append entries from tool_bar_item_properties to the end of
8643 tool_bar_items_vector. */
8644 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8645 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8646 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8647 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8654 /* Read a character using menus based on maps in the array MAPS.
8655 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8656 Return t if we displayed a menu but the user rejected it.
8658 PREV_EVENT is the previous input event, or nil if we are reading
8659 the first event of a key sequence.
8661 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8662 if we used a mouse menu to read the input, or zero otherwise. If
8663 USED_MOUSE_MENU is null, we don't dereference it.
8665 The prompting is done based on the prompt-string of the map
8666 and the strings associated with various map elements.
8668 This can be done with X menus or with menus put in the minibuf.
8669 These are done in different ways, depending on how the input will be read.
8670 Menus using X are done after auto-saving in read-char, getting the input
8671 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8672 and do auto-saving in the inner call of read_char. */
8675 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
8678 Lisp_Object prev_event
;
8679 int *used_mouse_menu
;
8683 if (used_mouse_menu
)
8684 *used_mouse_menu
= 0;
8686 /* Use local over global Menu maps */
8688 if (! menu_prompting
)
8691 /* Optionally disregard all but the global map. */
8692 if (inhibit_local_menu_bar_menus
)
8694 maps
+= (nmaps
- 1);
8699 /* If we got to this point via a mouse click,
8700 use a real menu for mouse selection. */
8701 if (EVENT_HAS_PARAMETERS (prev_event
)
8702 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8703 && !EQ (XCAR (prev_event
), Qtool_bar
))
8705 /* Display the menu and get the selection. */
8706 Lisp_Object
*realmaps
8707 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8711 /* Use the maps that are not nil. */
8712 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8713 if (!NILP (maps
[mapno
]))
8714 realmaps
[nmaps1
++] = maps
[mapno
];
8716 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8721 record_menu_key (XCAR (value
));
8723 /* If we got multiple events, unread all but
8725 There is no way to prevent those unread events
8726 from showing up later in last_nonmenu_event.
8727 So turn symbol and integer events into lists,
8728 to indicate that they came from a mouse menu,
8729 so that when present in last_nonmenu_event
8730 they won't confuse things. */
8731 for (tem
= XCDR (value
); CONSP (tem
); tem
= XCDR (tem
))
8733 record_menu_key (XCAR (tem
));
8734 if (SYMBOLP (XCAR (tem
))
8735 || INTEGERP (XCAR (tem
)))
8736 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8739 /* If we got more than one event, put all but the first
8740 onto this list to be read later.
8741 Return just the first event now. */
8742 Vunread_command_events
8743 = nconc2 (XCDR (value
), Vunread_command_events
);
8744 value
= XCAR (value
);
8746 else if (NILP (value
))
8748 if (used_mouse_menu
)
8749 *used_mouse_menu
= 1;
8752 #endif /* HAVE_MENUS */
8756 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8757 We make this bigger when necessary, and never free it. */
8758 static char *read_char_minibuf_menu_text
;
8759 /* Size of that buffer. */
8760 static int read_char_minibuf_menu_width
;
8763 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8769 register Lisp_Object name
;
8771 /* FIXME: Use the minibuffer's frame width. */
8772 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8775 Lisp_Object rest
, vector
;
8781 if (! menu_prompting
)
8784 /* Get the menu name from the first map that has one (a prompt string). */
8785 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8787 name
= Fkeymap_prompt (maps
[mapno
]);
8792 /* If we don't have any menus, just read a character normally. */
8793 if (!STRINGP (name
))
8796 /* Make sure we have a big enough buffer for the menu text. */
8797 width
= max (width
, SBYTES (name
));
8798 if (read_char_minibuf_menu_text
== 0)
8800 read_char_minibuf_menu_width
= width
+ 4;
8801 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8803 else if (width
+ 4 > read_char_minibuf_menu_width
)
8805 read_char_minibuf_menu_width
= width
+ 4;
8806 read_char_minibuf_menu_text
8807 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8809 menu
= read_char_minibuf_menu_text
;
8811 /* Prompt string always starts with map's prompt, and a space. */
8812 strcpy (menu
, SDATA (name
));
8813 nlength
= SBYTES (name
);
8814 menu
[nlength
++] = ':';
8815 menu
[nlength
++] = ' ';
8818 /* Start prompting at start of first map. */
8822 /* Present the documented bindings, a line at a time. */
8829 Lisp_Object orig_defn_macro
;
8831 /* Loop over elements of map. */
8836 /* If reached end of map, start at beginning of next map. */
8840 /* At end of last map, wrap around to first map if just starting,
8841 or end this line if already have something on it. */
8845 if (notfirst
|| nobindings
) break;
8850 /* Look at the next element of the map. */
8852 elt
= XVECTOR (vector
)->contents
[idx
];
8854 elt
= Fcar_safe (rest
);
8856 if (idx
< 0 && VECTORP (elt
))
8858 /* If we found a dense table in the keymap,
8859 advanced past it, but start scanning its contents. */
8860 rest
= Fcdr_safe (rest
);
8866 /* An ordinary element. */
8867 Lisp_Object event
, tem
;
8871 event
= Fcar_safe (elt
); /* alist */
8872 elt
= Fcdr_safe (elt
);
8876 XSETINT (event
, idx
); /* vector */
8879 /* Ignore the element if it has no prompt string. */
8880 if (INTEGERP (event
) && parse_menu_item (elt
, -1))
8882 /* 1 if the char to type matches the string. */
8884 Lisp_Object upcased_event
, downcased_event
;
8885 Lisp_Object desc
= Qnil
;
8887 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8889 upcased_event
= Fupcase (event
);
8890 downcased_event
= Fdowncase (event
);
8891 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8892 || XINT (downcased_event
) == SREF (s
, 0));
8894 desc
= Fsingle_key_description (event
, Qnil
);
8896 #if 0 /* It is redundant to list the equivalent key bindings because
8897 the prefix is what the user has already typed. */
8899 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8901 /* Insert equivalent keybinding. */
8902 s
= concat2 (s
, tem
);
8905 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8906 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8908 /* Insert button prefix. */
8909 Lisp_Object selected
8910 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8911 if (EQ (tem
, QCradio
))
8912 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8914 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8915 s
= concat2 (tem
, s
);
8919 /* If we have room for the prompt string, add it to this line.
8920 If this is the first on the line, always add it. */
8921 if ((SCHARS (s
) + i
+ 2
8922 + (char_matches
? 0 : SCHARS (desc
) + 3))
8928 /* Punctuate between strings. */
8931 strcpy (menu
+ i
, ", ");
8937 /* If the char to type doesn't match the string's
8938 first char, explicitly show what char to type. */
8941 /* Add as much of string as fits. */
8942 thiswidth
= SCHARS (desc
);
8943 if (thiswidth
+ i
> width
)
8944 thiswidth
= width
- i
;
8945 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8947 strcpy (menu
+ i
, " = ");
8951 /* Add as much of string as fits. */
8952 thiswidth
= SCHARS (s
);
8953 if (thiswidth
+ i
> width
)
8954 thiswidth
= width
- i
;
8955 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8961 /* If this element does not fit, end the line now,
8962 and save the element for the next line. */
8963 strcpy (menu
+ i
, "...");
8968 /* Move past this element. */
8969 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8970 /* Handle reaching end of dense table. */
8975 rest
= Fcdr_safe (rest
);
8979 /* Prompt with that and read response. */
8980 message2_nolog (menu
, strlen (menu
),
8981 ! NILP (current_buffer
->enable_multibyte_characters
));
8983 /* Make believe its not a keyboard macro in case the help char
8984 is pressed. Help characters are not recorded because menu prompting
8985 is not used on replay.
8987 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8988 current_kboard
->defining_kbd_macro
= Qnil
;
8990 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8991 while (BUFFERP (obj
));
8992 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8994 if (!INTEGERP (obj
))
8996 else if (XINT (obj
) == -2)
9001 if (! EQ (obj
, menu_prompt_more_char
)
9002 && (!INTEGERP (menu_prompt_more_char
)
9003 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
9005 if (!NILP (current_kboard
->defining_kbd_macro
))
9006 store_kbd_macro_char (obj
);
9009 /* Help char - go round again */
9013 /* Reading key sequences. */
9015 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
9016 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
9017 keymap, or nil otherwise. Return the index of the first keymap in
9018 which KEY has any binding, or NMAPS if no map has a binding.
9020 If KEY is a meta ASCII character, treat it like meta-prefix-char
9021 followed by the corresponding non-meta character. Keymaps in
9022 CURRENT with non-prefix bindings for meta-prefix-char become nil in
9025 If KEY has no bindings in any of the CURRENT maps, NEXT is left
9028 NEXT may be the same array as CURRENT. */
9031 follow_key (key
, nmaps
, current
, defs
, next
)
9033 Lisp_Object
*current
, *defs
, *next
;
9036 int i
, first_binding
;
9038 first_binding
= nmaps
;
9039 for (i
= nmaps
- 1; i
>= 0; i
--)
9041 if (! NILP (current
[i
]))
9043 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
9044 if (! NILP (defs
[i
]))
9051 /* Given the set of bindings we've found, produce the next set of maps. */
9052 if (first_binding
< nmaps
)
9053 for (i
= 0; i
< nmaps
; i
++)
9054 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
9056 return first_binding
;
9059 /* Structure used to keep track of partial application of key remapping
9060 such as Vfunction_key_map and Vkey_translation_map. */
9061 typedef struct keyremap
9063 /* This is the map originally specified for this use. */
9065 /* This is a submap reached by looking up, in PARENT,
9066 the events from START to END. */
9068 /* Positions [START, END) in the key sequence buffer
9069 are the key that we have scanned so far.
9070 Those events are the ones that we will replace
9071 if PAREHT maps them into a key sequence. */
9075 /* Lookup KEY in MAP.
9076 MAP is a keymap mapping keys to key vectors or functions.
9077 If the mapping is a function and DO_FUNCTION is non-zero, then
9078 the function is called with PROMPT as parameter and its return
9079 value is used as the return value of this function (after checking
9080 that it is indeed a vector). */
9083 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
9084 Lisp_Object map
, key
, prompt
;
9089 next
= access_keymap (map
, key
, 1, 0, 1);
9091 /* Handle symbol with autoload definition. */
9092 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
9093 && CONSP (XSYMBOL (next
)->function
)
9094 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
9095 do_autoload (XSYMBOL (next
)->function
, next
);
9097 /* Handle a symbol whose function definition is a keymap
9099 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
9100 && (ARRAYP (XSYMBOL (next
)->function
)
9101 || KEYMAPP (XSYMBOL (next
)->function
)))
9102 next
= XSYMBOL (next
)->function
;
9104 /* If the keymap gives a function, not an
9105 array, then call the function with one arg and use
9106 its value instead. */
9107 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
9112 next
= call1 (next
, prompt
);
9113 /* If the function returned something invalid,
9114 barf--don't ignore it.
9115 (To ignore it safely, we would need to gcpro a bunch of
9116 other variables.) */
9117 if (! (VECTORP (next
) || STRINGP (next
)))
9118 error ("Function %s returns invalid key sequence", tem
);
9123 /* Do one step of the key remapping used for function-key-map and
9124 key-translation-map:
9125 KEYBUF is the buffer holding the input events.
9126 BUFSIZE is its maximum size.
9127 FKEY is a pointer to the keyremap structure to use.
9128 INPUT is the index of the last element in KEYBUF.
9129 DOIT if non-zero says that the remapping can actually take place.
9130 DIFF is used to return the number of keys added/removed by the remapping.
9131 PARENT is the root of the keymap.
9132 PROMPT is the prompt to use if the remapping happens through a function.
9133 The return value is non-zero if the remapping actually took place. */
9136 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
9137 Lisp_Object
*keybuf
, prompt
;
9139 int input
, doit
, *diff
, bufsize
;
9141 Lisp_Object next
, key
;
9143 key
= keybuf
[fkey
->end
++];
9145 if (KEYMAPP (fkey
->parent
))
9146 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
9150 /* If keybuf[fkey->start..fkey->end] is bound in the
9151 map and we're in a position to do the key remapping, replace it with
9152 the binding and restart with fkey->start at the end. */
9153 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
9155 int len
= XFASTINT (Flength (next
));
9158 *diff
= len
- (fkey
->end
- fkey
->start
);
9160 if (input
+ *diff
>= bufsize
)
9161 error ("Key sequence too long");
9163 /* Shift the keys that follow fkey->end. */
9165 for (i
= fkey
->end
; i
< input
; i
++)
9166 keybuf
[i
+ *diff
] = keybuf
[i
];
9168 for (i
= input
- 1; i
>= fkey
->end
; i
--)
9169 keybuf
[i
+ *diff
] = keybuf
[i
];
9170 /* Overwrite the old keys with the new ones. */
9171 for (i
= 0; i
< len
; i
++)
9172 keybuf
[fkey
->start
+ i
]
9173 = Faref (next
, make_number (i
));
9175 fkey
->start
= fkey
->end
+= *diff
;
9176 fkey
->map
= fkey
->parent
;
9181 fkey
->map
= get_keymap (next
, 0, 1);
9183 /* If we no longer have a bound suffix, try a new position for
9185 if (!CONSP (fkey
->map
))
9187 fkey
->end
= ++fkey
->start
;
9188 fkey
->map
= fkey
->parent
;
9193 /* Read a sequence of keys that ends with a non prefix character,
9194 storing it in KEYBUF, a buffer of size BUFSIZE.
9196 Return the length of the key sequence stored.
9197 Return -1 if the user rejected a command menu.
9199 Echo starting immediately unless `prompt' is 0.
9201 Where a key sequence ends depends on the currently active keymaps.
9202 These include any minor mode keymaps active in the current buffer,
9203 the current buffer's local map, and the global map.
9205 If a key sequence has no other bindings, we check Vfunction_key_map
9206 to see if some trailing subsequence might be the beginning of a
9207 function key's sequence. If so, we try to read the whole function
9208 key, and substitute its symbolic name into the key sequence.
9210 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
9211 `double-' events into similar click events, if that would make them
9212 bound. We try to turn `triple-' events first into `double-' events,
9215 If we get a mouse click in a mode line, vertical divider, or other
9216 non-text area, we treat the click as if it were prefixed by the
9217 symbol denoting that area - `mode-line', `vertical-line', or
9220 If the sequence starts with a mouse click, we read the key sequence
9221 with respect to the buffer clicked on, not the current buffer.
9223 If the user switches frames in the midst of a key sequence, we put
9224 off the switch-frame event until later; the next call to
9225 read_char will return it.
9227 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
9228 from the selected window's buffer. */
9231 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
9232 can_return_switch_frame
, fix_current_buffer
)
9233 Lisp_Object
*keybuf
;
9236 int dont_downcase_last
;
9237 int can_return_switch_frame
;
9238 int fix_current_buffer
;
9240 Lisp_Object from_string
;
9241 int count
= SPECPDL_INDEX ();
9243 /* How many keys there are in the current key sequence. */
9246 /* The length of the echo buffer when we started reading, and
9247 the length of this_command_keys when we started reading. */
9251 /* The number of keymaps we're scanning right now, and the number of
9252 keymaps we have allocated space for. */
9254 int nmaps_allocated
= 0;
9256 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
9257 the current keymaps. */
9258 Lisp_Object
*defs
= NULL
;
9260 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
9261 in the current keymaps, or nil where it is not a prefix. */
9262 Lisp_Object
*submaps
= NULL
;
9264 /* The local map to start out with at start of key sequence. */
9265 Lisp_Object orig_local_map
;
9267 /* The map from the `keymap' property to start out with at start of
9269 Lisp_Object orig_keymap
;
9271 /* 1 if we have already considered switching to the local-map property
9272 of the place where a mouse click occurred. */
9273 int localized_local_map
= 0;
9275 /* The index in submaps[] of the first keymap that has a binding for
9276 this key sequence. In other words, the lowest i such that
9277 submaps[i] is non-nil. */
9279 /* Index of the first key that has no binding.
9280 It is useless to try fkey.start larger than that. */
9283 /* If t < mock_input, then KEYBUF[t] should be read as the next
9286 We use this to recover after recognizing a function key. Once we
9287 realize that a suffix of the current key sequence is actually a
9288 function key's escape sequence, we replace the suffix with the
9289 function key's binding from Vfunction_key_map. Now keybuf
9290 contains a new and different key sequence, so the echo area,
9291 this_command_keys, and the submaps and defs arrays are wrong. In
9292 this situation, we set mock_input to t, set t to 0, and jump to
9293 restart_sequence; the loop will read keys from keybuf up until
9294 mock_input, thus rebuilding the state; and then it will resume
9295 reading characters from the keyboard. */
9298 /* If the sequence is unbound in submaps[], then
9299 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9300 and fkey.map is its binding.
9302 These might be > t, indicating that all function key scanning
9303 should hold off until t reaches them. We do this when we've just
9304 recognized a function key, to avoid searching for the function
9305 key's again in Vfunction_key_map. */
9308 /* Likewise, for key_translation_map and input-decode-map. */
9309 keyremap keytran
, indec
;
9311 /* Non-zero if we are trying to map a key by changing an upper-case
9312 letter to lower case, or a shifted function key to an unshifted
9314 int shift_translated
= 0;
9316 /* If we receive a `switch-frame' or `select-window' event in the middle of
9317 a key sequence, we put it off for later.
9318 While we're reading, we keep the event here. */
9319 Lisp_Object delayed_switch_frame
;
9321 /* See the comment below... */
9322 #if defined (GOBBLE_FIRST_EVENT)
9323 Lisp_Object first_event
;
9326 Lisp_Object original_uppercase
;
9327 int original_uppercase_position
= -1;
9329 /* Gets around Microsoft compiler limitations. */
9332 struct buffer
*starting_buffer
;
9334 /* List of events for which a fake prefix key has been generated. */
9335 Lisp_Object fake_prefixed_keys
= Qnil
;
9337 #if defined (GOBBLE_FIRST_EVENT)
9341 struct gcpro gcpro1
;
9343 GCPRO1 (fake_prefixed_keys
);
9344 raw_keybuf_count
= 0;
9346 last_nonmenu_event
= Qnil
;
9348 delayed_switch_frame
= Qnil
;
9353 echo_prompt (prompt
);
9354 else if (cursor_in_echo_area
9355 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9356 && NILP (Fzerop (Vecho_keystrokes
)))
9357 /* This doesn't put in a dash if the echo buffer is empty, so
9358 you don't always see a dash hanging out in the minibuffer. */
9362 /* Record the initial state of the echo area and this_command_keys;
9363 we will need to restore them if we replay a key sequence. */
9365 echo_start
= echo_length ();
9366 keys_start
= this_command_key_count
;
9367 this_single_command_key_start
= keys_start
;
9369 #if defined (GOBBLE_FIRST_EVENT)
9370 /* This doesn't quite work, because some of the things that read_char
9371 does cannot safely be bypassed. It seems too risky to try to make
9374 /* Read the first char of the sequence specially, before setting
9375 up any keymaps, in case a filter runs and switches buffers on us. */
9376 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9378 #endif /* GOBBLE_FIRST_EVENT */
9380 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9381 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9384 /* We jump here when we need to reinitialize fkey and keytran; this
9385 happens if we switch keyboards between rescans. */
9386 replay_entire_sequence
:
9388 indec
.map
= indec
.parent
= current_kboard
->Vinput_decode_map
;
9389 fkey
.map
= fkey
.parent
= current_kboard
->Vlocal_function_key_map
;
9390 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
9391 indec
.start
= indec
.end
= 0;
9392 fkey
.start
= fkey
.end
= 0;
9393 keytran
.start
= keytran
.end
= 0;
9395 /* We jump here when the key sequence has been thoroughly changed, and
9396 we need to rescan it starting from the beginning. When we jump here,
9397 keybuf[0..mock_input] holds the sequence we should reread. */
9400 starting_buffer
= current_buffer
;
9401 first_unbound
= bufsize
+ 1;
9403 /* Build our list of keymaps.
9404 If we recognize a function key and replace its escape sequence in
9405 keybuf with its symbol, or if the sequence starts with a mouse
9406 click and we need to switch buffers, we jump back here to rebuild
9407 the initial keymaps from the current buffer. */
9410 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9412 if (2 > nmaps_allocated
)
9414 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9415 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9416 nmaps_allocated
= 2;
9418 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
9420 else if (!NILP (Voverriding_local_map
))
9422 if (2 > nmaps_allocated
)
9424 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9425 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9426 nmaps_allocated
= 2;
9428 submaps
[nmaps
++] = Voverriding_local_map
;
9436 nminor
= current_minor_maps (0, &maps
);
9437 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9439 if (total
> nmaps_allocated
)
9441 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9442 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9443 nmaps_allocated
= total
;
9446 if (!NILP (orig_keymap
))
9447 submaps
[nmaps
++] = orig_keymap
;
9449 bcopy (maps
, (void *) (submaps
+ nmaps
),
9450 nminor
* sizeof (submaps
[0]));
9454 submaps
[nmaps
++] = orig_local_map
;
9456 submaps
[nmaps
++] = current_global_map
;
9458 /* Find an accurate initial value for first_binding. */
9459 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9460 if (! NILP (submaps
[first_binding
]))
9463 /* Start from the beginning in keybuf. */
9466 /* These are no-ops the first time through, but if we restart, they
9467 revert the echo area and this_command_keys to their original state. */
9468 this_command_key_count
= keys_start
;
9469 if (INTERACTIVE
&& t
< mock_input
)
9470 echo_truncate (echo_start
);
9472 /* If the best binding for the current key sequence is a keymap, or
9473 we may be looking at a function key's escape sequence, keep on
9475 while (first_binding
< nmaps
9476 /* Keep reading as long as there's a prefix binding. */
9477 ? !NILP (submaps
[first_binding
])
9478 /* Don't return in the middle of a possible function key sequence,
9479 if the only bindings we found were via case conversion.
9480 Thus, if ESC O a has a function-key-map translation
9481 and ESC o has a binding, don't return after ESC O,
9482 so that we can translate ESC O plus the next character. */
9483 : (/* indec.start < t || fkey.start < t || */ keytran
.start
< t
))
9486 int used_mouse_menu
= 0;
9488 /* Where the last real key started. If we need to throw away a
9489 key that has expanded into more than one element of keybuf
9490 (say, a mouse click on the mode line which is being treated
9491 as [mode-line (mouse-...)], then we backtrack to this point
9493 int last_real_key_start
;
9495 /* These variables are analogous to echo_start and keys_start;
9496 while those allow us to restart the entire key sequence,
9497 echo_local_start and keys_local_start allow us to throw away
9499 int echo_local_start
, keys_local_start
, local_first_binding
;
9501 eassert (indec
.end
== t
|| (indec
.end
> t
&& indec
.end
<= mock_input
));
9502 eassert (indec
.start
<= indec
.end
);
9503 eassert (fkey
.start
<= fkey
.end
);
9504 eassert (keytran
.start
<= keytran
.end
);
9505 /* key-translation-map is applied *after* function-key-map
9506 which is itself applied *after* input-decode-map. */
9507 eassert (fkey
.end
<= indec
.start
);
9508 eassert (keytran
.end
<= fkey
.start
);
9510 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9511 first_unbound
< keytran
.start
)
9512 { /* The prefix upto first_unbound has no binding and has
9513 no translation left to do either, so we know it's unbound.
9514 If we don't stop now, we risk staying here indefinitely
9515 (if the user keeps entering fkey or keytran prefixes
9516 like C-c ESC ESC ESC ESC ...) */
9518 for (i
= first_unbound
+ 1; i
< t
; i
++)
9519 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9520 mock_input
= t
- first_unbound
- 1;
9521 indec
.end
= indec
.start
-= first_unbound
+ 1;
9522 indec
.map
= indec
.parent
;
9523 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9524 fkey
.map
= fkey
.parent
;
9525 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9526 keytran
.map
= keytran
.parent
;
9527 goto replay_sequence
;
9531 error ("Key sequence too long");
9534 echo_local_start
= echo_length ();
9535 keys_local_start
= this_command_key_count
;
9536 local_first_binding
= first_binding
;
9539 /* These are no-ops, unless we throw away a keystroke below and
9540 jumped back up to replay_key; in that case, these restore the
9541 variables to their original state, allowing us to replay the
9543 if (INTERACTIVE
&& t
< mock_input
)
9544 echo_truncate (echo_local_start
);
9545 this_command_key_count
= keys_local_start
;
9546 first_binding
= local_first_binding
;
9548 /* By default, assume each event is "real". */
9549 last_real_key_start
= t
;
9551 /* Does mock_input indicate that we are re-reading a key sequence? */
9555 add_command_key (key
);
9556 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9557 && NILP (Fzerop (Vecho_keystrokes
)))
9561 /* If not, we should actually read a character. */
9565 KBOARD
*interrupted_kboard
= current_kboard
;
9566 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9567 key
= read_char (NILP (prompt
), nmaps
,
9568 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9569 &used_mouse_menu
, NULL
);
9570 if ((INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9571 /* When switching to a new tty (with a new keyboard),
9572 read_char returns the new buffer, rather than -2
9573 (Bug#5095). This is because `terminal-init-xterm'
9574 calls read-char, which eats the wrong_kboard_jmpbuf
9575 return. Any better way to fix this? -- cyd */
9576 || (interrupted_kboard
!= current_kboard
))
9581 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9582 if (k
== interrupted_kboard
)
9587 /* Don't touch interrupted_kboard when it's been
9589 delayed_switch_frame
= Qnil
;
9590 goto replay_entire_sequence
;
9593 if (!NILP (delayed_switch_frame
))
9595 interrupted_kboard
->kbd_queue
9596 = Fcons (delayed_switch_frame
,
9597 interrupted_kboard
->kbd_queue
);
9598 delayed_switch_frame
= Qnil
;
9602 interrupted_kboard
->kbd_queue
9603 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
9605 /* If the side queue is non-empty, ensure it begins with a
9606 switch-frame, so we'll replay it in the right context. */
9607 if (CONSP (interrupted_kboard
->kbd_queue
)
9608 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
9609 !(EVENT_HAS_PARAMETERS (key
)
9610 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9614 XSETFRAME (frame
, interrupted_frame
);
9615 interrupted_kboard
->kbd_queue
9616 = Fcons (make_lispy_switch_frame (frame
),
9617 interrupted_kboard
->kbd_queue
);
9620 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9621 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9622 goto replay_entire_sequence
;
9626 /* read_char returns t when it shows a menu and the user rejects it.
9630 unbind_to (count
, Qnil
);
9635 /* read_char returns -1 at the end of a macro.
9636 Emacs 18 handles this by returning immediately with a
9637 zero, so that's what we'll do. */
9638 if (INTEGERP (key
) && XINT (key
) == -1)
9641 /* The Microsoft C compiler can't handle the goto that
9647 /* If the current buffer has been changed from under us, the
9648 keymap may have changed, so replay the sequence. */
9651 timer_resume_idle ();
9654 /* Reset the current buffer from the selected window
9655 in case something changed the former and not the latter.
9656 This is to be more consistent with the behavior
9657 of the command_loop_1. */
9658 if (fix_current_buffer
)
9660 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9662 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9663 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9666 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9667 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9668 goto replay_sequence
;
9671 /* If we have a quit that was typed in another frame, and
9672 quit_throw_to_read_char switched buffers,
9673 replay to get the right keymap. */
9675 && XINT (key
) == quit_char
9676 && current_buffer
!= starting_buffer
)
9679 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9683 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9684 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9685 goto replay_sequence
;
9690 if (EVENT_HAS_PARAMETERS (key
)
9691 /* Either a `switch-frame' or a `select-window' event. */
9692 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9694 /* If we're at the beginning of a key sequence, and the caller
9695 says it's okay, go ahead and return this event. If we're
9696 in the midst of a key sequence, delay it until the end. */
9697 if (t
> 0 || !can_return_switch_frame
)
9699 delayed_switch_frame
= key
;
9705 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9709 /* Clicks in non-text areas get prefixed by the symbol
9710 in their CHAR-ADDRESS field. For example, a click on
9711 the mode line is prefixed by the symbol `mode-line'.
9713 Furthermore, key sequences beginning with mouse clicks
9714 are read using the keymaps of the buffer clicked on, not
9715 the current buffer. So we may have to switch the buffer
9718 When we turn one event into two events, we must make sure
9719 that neither of the two looks like the original--so that,
9720 if we replay the events, they won't be expanded again.
9721 If not for this, such reexpansion could happen either here
9722 or when user programs play with this-command-keys. */
9723 if (EVENT_HAS_PARAMETERS (key
))
9728 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9729 if (EQ (kind
, Qmouse_click
))
9731 Lisp_Object window
, posn
;
9733 window
= POSN_WINDOW (EVENT_START (key
));
9734 posn
= POSN_POSN (EVENT_START (key
));
9737 || (!NILP (fake_prefixed_keys
)
9738 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9740 /* We're looking a second time at an event for which
9741 we generated a fake prefix key. Set
9742 last_real_key_start appropriately. */
9744 last_real_key_start
= t
- 1;
9747 /* Key sequences beginning with mouse clicks are
9748 read using the keymaps in the buffer clicked on,
9749 not the current buffer. If we're at the
9750 beginning of a key sequence, switch buffers. */
9751 if (last_real_key_start
== 0
9753 && BUFFERP (XWINDOW (window
)->buffer
)
9754 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9756 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9760 /* Arrange to go back to the original buffer once we're
9761 done reading the key sequence. Note that we can't
9762 use save_excursion_{save,restore} here, because they
9763 save point as well as the current buffer; we don't
9764 want to save point, because redisplay may change it,
9765 to accommodate a Fset_window_start or something. We
9766 don't want to do this at the top of the function,
9767 because we may get input from a subprocess which
9768 wants to change the selected window and stuff (say,
9770 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9772 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9774 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9775 orig_local_map
= get_local_map (PT
, current_buffer
,
9777 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9778 goto replay_sequence
;
9781 /* For a mouse click, get the local text-property keymap
9782 of the place clicked on, rather than point. */
9783 if (last_real_key_start
== 0
9784 && CONSP (XCDR (key
))
9785 && ! localized_local_map
)
9787 Lisp_Object map_here
, start
, pos
;
9789 localized_local_map
= 1;
9790 start
= EVENT_START (key
);
9792 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9794 pos
= POSN_BUFFER_POSN (start
);
9796 && XINT (pos
) >= BEGV
9797 && XINT (pos
) <= ZV
)
9799 map_here
= get_local_map (XINT (pos
),
9800 current_buffer
, Qlocal_map
);
9801 if (!EQ (map_here
, orig_local_map
))
9803 orig_local_map
= map_here
;
9804 ++localized_local_map
;
9807 map_here
= get_local_map (XINT (pos
),
9808 current_buffer
, Qkeymap
);
9809 if (!EQ (map_here
, orig_keymap
))
9811 orig_keymap
= map_here
;
9812 ++localized_local_map
;
9815 if (localized_local_map
> 1)
9820 goto replay_sequence
;
9826 /* Expand mode-line and scroll-bar events into two events:
9827 use posn as a fake prefix key. */
9829 && (NILP (fake_prefixed_keys
)
9830 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9832 if (t
+ 1 >= bufsize
)
9833 error ("Key sequence too long");
9836 keybuf
[t
+ 1] = key
;
9839 /* Record that a fake prefix key has been generated
9840 for KEY. Don't modify the event; this would
9841 prevent proper action when the event is pushed
9842 back into unread-command-events. */
9843 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9845 /* If on a mode line string with a local keymap,
9846 reconsider the key sequence with that keymap. */
9847 if (string
= POSN_STRING (EVENT_START (key
)),
9848 (CONSP (string
) && STRINGP (XCAR (string
))))
9850 Lisp_Object pos
, map
, map2
;
9852 pos
= XCDR (string
);
9853 string
= XCAR (string
);
9855 && XINT (pos
) < SCHARS (string
))
9857 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9859 orig_local_map
= map
;
9860 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9863 if (!NILP (map
) || !NILP (map2
))
9864 goto replay_sequence
;
9870 else if (NILP (from_string
)
9871 && (string
= POSN_STRING (EVENT_START (key
)),
9872 (CONSP (string
) && STRINGP (XCAR (string
)))))
9874 /* For a click on a string, i.e. overlay string or a
9875 string displayed via the `display' property,
9876 consider `local-map' and `keymap' properties of
9878 Lisp_Object pos
, map
, map2
;
9880 pos
= XCDR (string
);
9881 string
= XCAR (string
);
9883 && XINT (pos
) < SCHARS (string
))
9885 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9887 orig_local_map
= map
;
9888 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9892 if (!NILP (map
) || !NILP (map2
))
9894 from_string
= string
;
9897 goto replay_sequence
;
9902 else if (CONSP (XCDR (key
))
9903 && CONSP (EVENT_START (key
))
9904 && CONSP (XCDR (EVENT_START (key
))))
9908 posn
= POSN_POSN (EVENT_START (key
));
9909 /* Handle menu-bar events:
9910 insert the dummy prefix event `menu-bar'. */
9911 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9913 if (t
+ 1 >= bufsize
)
9914 error ("Key sequence too long");
9918 /* Zap the position in key, so we know that we've
9919 expanded it, and don't try to do so again. */
9920 POSN_SET_POSN (EVENT_START (key
),
9921 Fcons (posn
, Qnil
));
9924 goto replay_sequence
;
9926 else if (CONSP (posn
))
9928 /* We're looking at the second event of a
9929 sequence which we expanded before. Set
9930 last_real_key_start appropriately. */
9931 if (last_real_key_start
== t
&& t
> 0)
9932 last_real_key_start
= t
- 1;
9937 /* We have finally decided that KEY is something we might want
9939 first_binding
= (follow_key (key
,
9940 nmaps
- first_binding
,
9941 submaps
+ first_binding
,
9942 defs
+ first_binding
,
9943 submaps
+ first_binding
)
9946 /* If KEY wasn't bound, we'll try some fallbacks. */
9947 if (first_binding
< nmaps
)
9948 /* This is needed for the following scenario:
9949 event 0: a down-event that gets dropped by calling replay_key.
9950 event 1: some normal prefix like C-h.
9951 After event 0, first_unbound is 0, after event 1 indec.start,
9952 fkey.start, and keytran.start are all 1, so when we see that
9953 C-h is bound, we need to update first_unbound. */
9954 first_unbound
= max (t
+ 1, first_unbound
);
9959 /* Remember the position to put an upper bound on indec.start. */
9960 first_unbound
= min (t
, first_unbound
);
9962 head
= EVENT_HEAD (key
);
9963 if (help_char_p (head
) && t
> 0)
9965 read_key_sequence_cmd
= Vprefix_help_command
;
9967 last_nonmenu_event
= key
;
9968 /* The Microsoft C compiler can't handle the goto that
9976 Lisp_Object breakdown
;
9979 breakdown
= parse_modifiers (head
);
9980 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9981 /* Attempt to reduce an unbound mouse event to a simpler
9982 event that is bound:
9983 Drags reduce to clicks.
9984 Double-clicks reduce to clicks.
9985 Triple-clicks reduce to double-clicks, then to clicks.
9986 Down-clicks are eliminated.
9987 Double-downs reduce to downs, then are eliminated.
9988 Triple-downs reduce to double-downs, then to downs,
9989 then are eliminated. */
9990 if (modifiers
& (down_modifier
| drag_modifier
9991 | double_modifier
| triple_modifier
))
9993 while (modifiers
& (down_modifier
| drag_modifier
9994 | double_modifier
| triple_modifier
))
9996 Lisp_Object new_head
, new_click
;
9997 if (modifiers
& triple_modifier
)
9998 modifiers
^= (double_modifier
| triple_modifier
);
9999 else if (modifiers
& double_modifier
)
10000 modifiers
&= ~double_modifier
;
10001 else if (modifiers
& drag_modifier
)
10002 modifiers
&= ~drag_modifier
;
10005 /* Dispose of this `down' event by simply jumping
10006 back to replay_key, to get another event.
10008 Note that if this event came from mock input,
10009 then just jumping back to replay_key will just
10010 hand it to us again. So we have to wipe out any
10013 We could delete keybuf[t] and shift everything
10014 after that to the left by one spot, but we'd also
10015 have to fix up any variable that points into
10016 keybuf, and shifting isn't really necessary
10019 Adding prefixes for non-textual mouse clicks
10020 creates two characters of mock input, and both
10021 must be thrown away. If we're only looking at
10022 the prefix now, we can just jump back to
10023 replay_key. On the other hand, if we've already
10024 processed the prefix, and now the actual click
10025 itself is giving us trouble, then we've lost the
10026 state of the keymaps we want to backtrack to, and
10027 we need to replay the whole sequence to rebuild
10030 Beyond that, only function key expansion could
10031 create more than two keys, but that should never
10032 generate mouse events, so it's okay to zero
10033 mock_input in that case too.
10035 FIXME: The above paragraph seems just plain
10036 wrong, if you consider things like
10037 xterm-mouse-mode. -stef
10039 Isn't this just the most wonderful code ever? */
10041 /* If mock_input > t + 1, the above simplification
10042 will actually end up dropping keys on the floor.
10043 This is probably OK for now, but even
10044 if mock_input <= t + 1, we need to adjust indec,
10046 Typical case [header-line down-mouse-N]:
10047 mock_input = 2, t = 1, fkey.end = 1,
10048 last_real_key_start = 0. */
10049 if (indec
.end
> last_real_key_start
)
10051 indec
.end
= indec
.start
10052 = min (last_real_key_start
, indec
.start
);
10053 indec
.map
= indec
.parent
;
10054 if (fkey
.end
> last_real_key_start
)
10056 fkey
.end
= fkey
.start
10057 = min (last_real_key_start
, fkey
.start
);
10058 fkey
.map
= fkey
.parent
;
10059 if (keytran
.end
> last_real_key_start
)
10061 keytran
.end
= keytran
.start
10062 = min (last_real_key_start
, keytran
.start
);
10063 keytran
.map
= keytran
.parent
;
10067 if (t
== last_real_key_start
)
10074 mock_input
= last_real_key_start
;
10075 goto replay_sequence
;
10080 = apply_modifiers (modifiers
, XCAR (breakdown
));
10082 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
10084 /* Look for a binding for this new key. follow_key
10085 promises that it didn't munge submaps the
10086 last time we called it, since key was unbound. */
10088 = (follow_key (new_click
,
10089 nmaps
- local_first_binding
,
10090 submaps
+ local_first_binding
,
10091 defs
+ local_first_binding
,
10092 submaps
+ local_first_binding
)
10093 + local_first_binding
);
10095 /* If that click is bound, go for it. */
10096 if (first_binding
< nmaps
)
10101 /* Otherwise, we'll leave key set to the drag event. */
10108 /* Normally, last_nonmenu_event gets the previous key we read.
10109 But when a mouse popup menu is being used,
10110 we don't update last_nonmenu_event; it continues to hold the mouse
10111 event that preceded the first level of menu. */
10112 if (!used_mouse_menu
)
10113 last_nonmenu_event
= key
;
10115 /* Record what part of this_command_keys is the current key sequence. */
10116 this_single_command_key_start
= this_command_key_count
- t
;
10118 /* Look for this sequence in input-decode-map.
10119 Scan from indec.end until we find a bound suffix. */
10120 while (indec
.end
< t
)
10122 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10125 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10126 done
= keyremap_step (keybuf
, bufsize
, &indec
, max (t
, mock_input
),
10131 mock_input
= diff
+ max (t
, mock_input
);
10132 goto replay_sequence
;
10136 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
])
10137 && indec
.start
>= t
)
10138 /* There is a binding and it's not a prefix.
10139 (and it doesn't have any input-decode-map translation pending).
10140 There is thus no function-key in this sequence.
10141 Moving fkey.start is important in this case to allow keytran.start
10142 to go over the sequence before we return (since we keep the
10143 invariant that keytran.end <= fkey.start). */
10145 if (fkey
.start
< t
)
10146 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
10149 /* If the sequence is unbound, see if we can hang a function key
10150 off the end of it. */
10151 /* Continue scan from fkey.end until we find a bound suffix. */
10152 while (fkey
.end
< indec
.start
)
10154 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10157 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10158 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
10159 max (t
, mock_input
),
10160 /* If there's a binding (i.e.
10161 first_binding >= nmaps) we don't want
10162 to apply this function-key-mapping. */
10163 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
10168 mock_input
= diff
+ max (t
, mock_input
);
10169 /* Adjust the input-decode-map counters. */
10171 indec
.start
+= diff
;
10173 goto replay_sequence
;
10177 /* Look for this sequence in key-translation-map.
10178 Scan from keytran.end until we find a bound suffix. */
10179 while (keytran
.end
< fkey
.start
)
10181 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10184 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
10185 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
10190 mock_input
= diff
+ max (t
, mock_input
);
10191 /* Adjust the function-key-map and input-decode-map counters. */
10193 indec
.start
+= diff
;
10195 fkey
.start
+= diff
;
10197 goto replay_sequence
;
10201 /* If KEY is not defined in any of the keymaps,
10202 and cannot be part of a function key or translation,
10203 and is an upper case letter
10204 use the corresponding lower-case letter instead. */
10205 if (first_binding
>= nmaps
10206 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
10208 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
10209 && UPPERCASEP (XINT (key
) & ~CHAR_MODIFIER_MASK
))
10210 || (XINT (key
) & shift_modifier
)))
10212 Lisp_Object new_key
;
10214 original_uppercase
= key
;
10215 original_uppercase_position
= t
- 1;
10217 if (XINT (key
) & shift_modifier
)
10218 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
10220 XSETINT (new_key
, (DOWNCASE (XINT (key
) & ~CHAR_MODIFIER_MASK
)
10221 | (XINT (key
) & CHAR_MODIFIER_MASK
)));
10223 /* We have to do this unconditionally, regardless of whether
10224 the lower-case char is defined in the keymaps, because they
10225 might get translated through function-key-map. */
10226 keybuf
[t
- 1] = new_key
;
10227 mock_input
= max (t
, mock_input
);
10228 shift_translated
= 1;
10230 goto replay_sequence
;
10232 /* If KEY is not defined in any of the keymaps,
10233 and cannot be part of a function key or translation,
10234 and is a shifted function key,
10235 use the corresponding unshifted function key instead. */
10236 if (first_binding
>= nmaps
10237 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
)
10239 Lisp_Object breakdown
= parse_modifiers (key
);
10241 = CONSP (breakdown
) ? (XINT (XCAR (XCDR (breakdown
)))) : 0;
10243 if (modifiers
& shift_modifier
10244 /* Treat uppercase keys as shifted. */
10246 && (KEY_TO_CHAR (key
)
10247 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
10248 && UPPERCASEP (KEY_TO_CHAR (key
))))
10250 Lisp_Object new_key
10251 = (modifiers
& shift_modifier
10252 ? apply_modifiers (modifiers
& ~shift_modifier
,
10254 : make_number (DOWNCASE (KEY_TO_CHAR (key
)) | modifiers
));
10256 original_uppercase
= key
;
10257 original_uppercase_position
= t
- 1;
10259 /* We have to do this unconditionally, regardless of whether
10260 the lower-case char is defined in the keymaps, because they
10261 might get translated through function-key-map. */
10262 keybuf
[t
- 1] = new_key
;
10263 mock_input
= max (t
, mock_input
);
10264 /* Reset fkey (and consequently keytran) to apply
10265 function-key-map on the result, so that S-backspace is
10266 correctly mapped to DEL (via backspace). OTOH,
10267 input-decode-map doesn't need to go through it again. */
10268 fkey
.start
= fkey
.end
= 0;
10269 keytran
.start
= keytran
.end
= 0;
10270 shift_translated
= 1;
10272 goto replay_sequence
;
10277 read_key_sequence_cmd
= (first_binding
< nmaps
10278 ? defs
[first_binding
]
10281 unread_switch_frame
= delayed_switch_frame
;
10282 unbind_to (count
, Qnil
);
10284 /* Don't downcase the last character if the caller says don't.
10285 Don't downcase it if the result is undefined, either. */
10286 if ((dont_downcase_last
|| first_binding
>= nmaps
)
10288 && t
- 1 == original_uppercase_position
)
10290 keybuf
[t
- 1] = original_uppercase
;
10291 shift_translated
= 0;
10294 if (shift_translated
)
10295 Vthis_command_keys_shift_translated
= Qt
;
10297 /* Occasionally we fabricate events, perhaps by expanding something
10298 according to function-key-map, or by adding a prefix symbol to a
10299 mouse click in the scroll bar or modeline. In this cases, return
10300 the entire generated key sequence, even if we hit an unbound
10301 prefix or a definition before the end. This means that you will
10302 be able to push back the event properly, and also means that
10303 read-key-sequence will always return a logical unit.
10306 for (; t
< mock_input
; t
++)
10308 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
10309 && NILP (Fzerop (Vecho_keystrokes
)))
10310 echo_char (keybuf
[t
]);
10311 add_command_key (keybuf
[t
]);
10318 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
10319 doc
: /* Read a sequence of keystrokes and return as a string or vector.
10320 The sequence is sufficient to specify a non-prefix command in the
10321 current local and global maps.
10323 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10324 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10325 as a continuation of the previous key.
10327 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10328 convert the last event to lower case. (Normally any upper case event
10329 is converted to lower case if the original event is undefined and the lower
10330 case equivalent is defined.) A non-nil value is appropriate for reading
10331 a key sequence to be defined.
10333 A C-g typed while in this function is treated like any other character,
10334 and `quit-flag' is not set.
10336 If the key sequence starts with a mouse click, then the sequence is read
10337 using the keymaps of the buffer of the window clicked in, not the buffer
10338 of the selected window as normal.
10340 `read-key-sequence' drops unbound button-down events, since you normally
10341 only care about the click or drag events which follow them. If a drag
10342 or multi-click event is unbound, but the corresponding click event would
10343 be bound, `read-key-sequence' turns the event into a click event at the
10344 drag's starting position. This means that you don't have to distinguish
10345 between click and drag, double, or triple events unless you want to.
10347 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10348 lines separating windows, and scroll bars with imaginary keys
10349 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10351 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10352 function will process a switch-frame event if the user switches frames
10353 before typing anything. If the user switches frames in the middle of a
10354 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10355 is nil, then the event will be put off until after the current key sequence.
10357 `read-key-sequence' checks `function-key-map' for function key
10358 sequences, where they wouldn't conflict with ordinary bindings. See
10359 `function-key-map' for more details.
10361 The optional fifth argument COMMAND-LOOP, if non-nil, means
10362 that this key sequence is being read by something that will
10363 read commands one after another. It should be nil if the caller
10364 will read just one key sequence. */)
10365 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10367 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10368 Lisp_Object can_return_switch_frame
, command_loop
;
10370 Lisp_Object keybuf
[30];
10372 struct gcpro gcpro1
;
10373 int count
= SPECPDL_INDEX ();
10375 if (!NILP (prompt
))
10376 CHECK_STRING (prompt
);
10379 specbind (Qinput_method_exit_on_first_char
,
10380 (NILP (command_loop
) ? Qt
: Qnil
));
10381 specbind (Qinput_method_use_echo_area
,
10382 (NILP (command_loop
) ? Qt
: Qnil
));
10384 bzero (keybuf
, sizeof keybuf
);
10385 GCPRO1 (keybuf
[0]);
10386 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10388 if (NILP (continue_echo
))
10390 this_command_key_count
= 0;
10391 this_command_key_count_reset
= 0;
10392 this_single_command_key_start
= 0;
10395 #ifdef HAVE_WINDOW_SYSTEM
10396 if (display_hourglass_p
)
10397 cancel_hourglass ();
10400 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10401 prompt
, ! NILP (dont_downcase_last
),
10402 ! NILP (can_return_switch_frame
), 0);
10404 #if 0 /* The following is fine for code reading a key sequence and
10405 then proceeding with a lenghty computation, but it's not good
10406 for code reading keys in a loop, like an input method. */
10407 #ifdef HAVE_WINDOW_SYSTEM
10408 if (display_hourglass_p
)
10409 start_hourglass ();
10419 return unbind_to (count
, make_event_array (i
, keybuf
));
10422 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10423 Sread_key_sequence_vector
, 1, 5, 0,
10424 doc
: /* Like `read-key-sequence' but always return a vector. */)
10425 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
10427 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
10428 Lisp_Object can_return_switch_frame
, command_loop
;
10430 Lisp_Object keybuf
[30];
10432 struct gcpro gcpro1
;
10433 int count
= SPECPDL_INDEX ();
10435 if (!NILP (prompt
))
10436 CHECK_STRING (prompt
);
10439 specbind (Qinput_method_exit_on_first_char
,
10440 (NILP (command_loop
) ? Qt
: Qnil
));
10441 specbind (Qinput_method_use_echo_area
,
10442 (NILP (command_loop
) ? Qt
: Qnil
));
10444 bzero (keybuf
, sizeof keybuf
);
10445 GCPRO1 (keybuf
[0]);
10446 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10448 if (NILP (continue_echo
))
10450 this_command_key_count
= 0;
10451 this_command_key_count_reset
= 0;
10452 this_single_command_key_start
= 0;
10455 #ifdef HAVE_WINDOW_SYSTEM
10456 if (display_hourglass_p
)
10457 cancel_hourglass ();
10460 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10461 prompt
, ! NILP (dont_downcase_last
),
10462 ! NILP (can_return_switch_frame
), 0);
10464 #ifdef HAVE_WINDOW_SYSTEM
10465 if (display_hourglass_p
)
10466 start_hourglass ();
10475 return unbind_to (count
, Fvector (i
, keybuf
));
10478 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10479 doc
: /* Execute CMD as an editor command.
10480 CMD must be a symbol that satisfies the `commandp' predicate.
10481 Optional second arg RECORD-FLAG non-nil
10482 means unconditionally put this command in `command-history'.
10483 Otherwise, that is done only if an arg is read using the minibuffer.
10484 The argument KEYS specifies the value to use instead of (this-command-keys)
10485 when reading the arguments; if it is nil, (this-command-keys) is used.
10486 The argument SPECIAL, if non-nil, means that this command is executing
10487 a special event, so ignore the prefix argument and don't clear it. */)
10488 (cmd
, record_flag
, keys
, special
)
10489 Lisp_Object cmd
, record_flag
, keys
, special
;
10491 register Lisp_Object final
;
10492 register Lisp_Object tem
;
10493 Lisp_Object prefixarg
;
10494 extern int debug_on_next_call
;
10496 debug_on_next_call
= 0;
10498 if (NILP (special
))
10500 prefixarg
= current_kboard
->Vprefix_arg
;
10501 Vcurrent_prefix_arg
= prefixarg
;
10502 current_kboard
->Vprefix_arg
= Qnil
;
10509 tem
= Fget (cmd
, Qdisabled
);
10510 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10512 tem
= Fsymbol_value (Qdisabled_command_function
);
10514 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10520 final
= Findirect_function (cmd
, Qnil
);
10522 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10524 struct gcpro gcpro1
, gcpro2
;
10526 GCPRO2 (cmd
, prefixarg
);
10527 do_autoload (final
, cmd
);
10534 if (STRINGP (final
) || VECTORP (final
))
10536 /* If requested, place the macro in the command history. For
10537 other sorts of commands, call-interactively takes care of
10539 if (!NILP (record_flag
))
10542 = Fcons (Fcons (Qexecute_kbd_macro
,
10543 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10546 /* Don't keep command history around forever. */
10547 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10549 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10551 XSETCDR (tem
, Qnil
);
10555 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10558 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10559 /* Don't call Fcall_interactively directly because we want to make
10560 sure the backtrace has an entry for `call-interactively'.
10561 For the same reason, pass `cmd' rather than `final'. */
10562 return call3 (Qcall_interactively
, cmd
, record_flag
, keys
);
10569 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10571 doc
: /* Read function name, then read its arguments and call it.
10573 To pass a numeric argument to the command you are invoking with, specify
10574 the numeric argument to this command.
10576 Noninteractively, the argument PREFIXARG is the prefix argument to
10577 give to the command you invoke, if it asks for an argument. */)
10579 Lisp_Object prefixarg
;
10581 Lisp_Object function
;
10583 int saved_last_point_position
;
10584 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10585 Lisp_Object bindings
, value
;
10586 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10587 #ifdef HAVE_WINDOW_SYSTEM
10588 /* The call to Fcompleting_read wil start and cancel the hourglass,
10589 but if the hourglass was already scheduled, this means that no
10590 hourglass will be shown for the actual M-x command itself.
10591 So we restart it if it is already scheduled. Note that checking
10592 hourglass_shown_p is not enough, normally the hourglass is not shown,
10593 just scheduled to be shown. */
10594 int hstarted
= hourglass_started ();
10597 saved_keys
= Fvector (this_command_key_count
,
10598 XVECTOR (this_command_keys
)->contents
);
10599 saved_last_point_position_buffer
= last_point_position_buffer
;
10600 saved_last_point_position
= last_point_position
;
10602 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10604 if (EQ (prefixarg
, Qminus
))
10605 strcpy (buf
, "- ");
10606 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
10607 strcpy (buf
, "C-u ");
10608 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
10609 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
10610 else if (INTEGERP (prefixarg
))
10611 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
10613 /* This isn't strictly correct if execute-extended-command
10614 is bound to anything else. Perhaps it should use
10615 this_command_keys? */
10616 strcat (buf
, "M-x ");
10618 /* Prompt with buf, and then read a string, completing from and
10619 restricting to the set of all defined commands. Don't provide
10620 any initial input. Save the command read on the extended-command
10622 function
= Fcompleting_read (build_string (buf
),
10623 Vobarray
, Qcommandp
,
10624 Qt
, Qnil
, Qextended_command_history
, Qnil
,
10627 #ifdef HAVE_WINDOW_SYSTEM
10628 if (hstarted
) start_hourglass ();
10631 if (STRINGP (function
) && SCHARS (function
) == 0)
10632 error ("No command name given");
10634 /* Set this_command_keys to the concatenation of saved_keys and
10635 function, followed by a RET. */
10640 this_command_key_count
= 0;
10641 this_command_key_count_reset
= 0;
10642 this_single_command_key_start
= 0;
10644 keys
= XVECTOR (saved_keys
)->contents
;
10645 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10646 add_command_key (keys
[i
]);
10648 for (i
= 0; i
< SCHARS (function
); i
++)
10649 add_command_key (Faref (function
, make_number (i
)));
10651 add_command_key (make_number ('\015'));
10654 last_point_position
= saved_last_point_position
;
10655 last_point_position_buffer
= saved_last_point_position_buffer
;
10659 function
= Fintern (function
, Qnil
);
10660 current_kboard
->Vprefix_arg
= prefixarg
;
10661 Vthis_command
= function
;
10662 real_this_command
= function
;
10664 /* If enabled, show which key runs this command. */
10665 if (!NILP (Vsuggest_key_bindings
)
10666 && NILP (Vexecuting_kbd_macro
)
10667 && SYMBOLP (function
))
10668 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10674 GCPRO3 (bindings
, value
, function
);
10675 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10677 /* If the command has a key binding, print it now. */
10678 if (!NILP (bindings
)
10679 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10682 /* But first wait, and skip the message if there is input. */
10683 Lisp_Object waited
;
10685 /* If this command displayed something in the echo area;
10686 wait a few seconds, then display our suggestion message. */
10687 if (NILP (echo_area_buffer
[0]))
10688 waited
= sit_for (make_number (0), 0, 2);
10689 else if (NUMBERP (Vsuggest_key_bindings
))
10690 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10692 waited
= sit_for (make_number (2), 0, 2);
10694 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10696 Lisp_Object binding
;
10698 int message_p
= push_message ();
10699 int count
= SPECPDL_INDEX ();
10701 record_unwind_protect (pop_message_unwind
, Qnil
);
10702 binding
= Fkey_description (bindings
, Qnil
);
10705 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10708 sprintf (newmessage
, "You can run the command `%s' with %s",
10709 SDATA (SYMBOL_NAME (function
)),
10711 message2_nolog (newmessage
,
10712 strlen (newmessage
),
10713 STRING_MULTIBYTE (binding
));
10714 if (NUMBERP (Vsuggest_key_bindings
))
10715 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10717 waited
= sit_for (make_number (2), 0, 2);
10719 if (!NILP (waited
) && message_p
)
10720 restore_message ();
10722 unbind_to (count
, Qnil
);
10726 RETURN_UNGCPRO (value
);
10730 /* Return nonzero if input events are pending. */
10733 detect_input_pending ()
10735 if (!input_pending
)
10736 get_input_pending (&input_pending
, 0);
10738 return input_pending
;
10741 /* Return nonzero if input events other than mouse movements are
10745 detect_input_pending_ignore_squeezables ()
10747 if (!input_pending
)
10748 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10750 return input_pending
;
10753 /* Return nonzero if input events are pending, and run any pending timers. */
10756 detect_input_pending_run_timers (do_display
)
10759 int old_timers_run
= timers_run
;
10761 if (!input_pending
)
10762 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10764 if (old_timers_run
!= timers_run
&& do_display
)
10766 redisplay_preserve_echo_area (8);
10767 /* The following fixes a bug when using lazy-lock with
10768 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10769 from an idle timer function. The symptom of the bug is that
10770 the cursor sometimes doesn't become visible until the next X
10771 event is processed. --gerd. */
10773 Lisp_Object tail
, frame
;
10774 FOR_EACH_FRAME (tail
, frame
)
10775 if (FRAME_RIF (XFRAME (frame
)))
10776 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10780 return input_pending
;
10783 /* This is called in some cases before a possible quit.
10784 It cases the next call to detect_input_pending to recompute input_pending.
10785 So calling this function unnecessarily can't do any harm. */
10788 clear_input_pending ()
10793 /* Return nonzero if there are pending requeued events.
10794 This isn't used yet. The hope is to make wait_reading_process_output
10795 call it, and return if it runs Lisp code that unreads something.
10796 The problem is, kbd_buffer_get_event needs to be fixed to know what
10797 to do in that case. It isn't trivial. */
10800 requeued_events_pending_p ()
10802 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10806 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10807 doc
: /* Return t if command input is currently available with no wait.
10808 Actually, the value is nil only if we can be sure that no input is available;
10809 if there is a doubt, the value is t. */)
10812 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10813 || !NILP (Vunread_post_input_method_events
)
10814 || !NILP (Vunread_input_method_events
))
10817 get_input_pending (&input_pending
,
10818 READABLE_EVENTS_DO_TIMERS_NOW
10819 | READABLE_EVENTS_FILTER_EVENTS
);
10820 return input_pending
> 0 ? Qt
: Qnil
;
10823 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10824 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10827 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10830 if (total_keys
< NUM_RECENT_KEYS
)
10831 return Fvector (total_keys
, keys
);
10834 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10835 bcopy (keys
+ recent_keys_index
,
10836 XVECTOR (val
)->contents
,
10837 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10839 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10840 recent_keys_index
* sizeof (Lisp_Object
));
10845 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10846 doc
: /* Return the key sequence that invoked this command.
10847 However, if the command has called `read-key-sequence', it returns
10848 the last key sequence that has been read.
10849 The value is a string or a vector.
10851 See also `this-command-keys-vector'. */)
10854 return make_event_array (this_command_key_count
,
10855 XVECTOR (this_command_keys
)->contents
);
10858 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10859 doc
: /* Return the key sequence that invoked this command, as a vector.
10860 However, if the command has called `read-key-sequence', it returns
10861 the last key sequence that has been read.
10863 See also `this-command-keys'. */)
10866 return Fvector (this_command_key_count
,
10867 XVECTOR (this_command_keys
)->contents
);
10870 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10871 Sthis_single_command_keys
, 0, 0, 0,
10872 doc
: /* Return the key sequence that invoked this command.
10873 More generally, it returns the last key sequence read, either by
10874 the command loop or by `read-key-sequence'.
10875 Unlike `this-command-keys', this function's value
10876 does not include prefix arguments.
10877 The value is always a vector. */)
10880 return Fvector (this_command_key_count
10881 - this_single_command_key_start
,
10882 (XVECTOR (this_command_keys
)->contents
10883 + this_single_command_key_start
));
10886 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10887 Sthis_single_command_raw_keys
, 0, 0, 0,
10888 doc
: /* Return the raw events that were read for this command.
10889 More generally, it returns the last key sequence read, either by
10890 the command loop or by `read-key-sequence'.
10891 Unlike `this-single-command-keys', this function's value
10892 shows the events before all translations (except for input methods).
10893 The value is always a vector. */)
10896 return Fvector (raw_keybuf_count
,
10897 (XVECTOR (raw_keybuf
)->contents
));
10900 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10901 Sreset_this_command_lengths
, 0, 0, 0,
10902 doc
: /* Make the unread events replace the last command and echo.
10903 Used in `universal-argument-other-key'.
10905 `universal-argument-other-key' rereads the event just typed.
10906 It then gets translated through `function-key-map'.
10907 The translated event has to replace the real events,
10908 both in the value of (this-command-keys) and in echoing.
10909 To achieve this, `universal-argument-other-key' calls
10910 `reset-this-command-lengths', which discards the record of reading
10911 these events the first time. */)
10914 this_command_key_count
= before_command_key_count
;
10915 if (this_command_key_count
< this_single_command_key_start
)
10916 this_single_command_key_start
= this_command_key_count
;
10918 echo_truncate (before_command_echo_length
);
10920 /* Cause whatever we put into unread-command-events
10921 to echo as if it were being freshly read from the keyboard. */
10922 this_command_key_count_reset
= 1;
10927 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10928 Sclear_this_command_keys
, 0, 1, 0,
10929 doc
: /* Clear out the vector that `this-command-keys' returns.
10930 Also clear the record of the last 100 events, unless optional arg
10931 KEEP-RECORD is non-nil. */)
10933 Lisp_Object keep_record
;
10937 this_command_key_count
= 0;
10938 this_command_key_count_reset
= 0;
10940 if (NILP (keep_record
))
10942 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10943 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10945 recent_keys_index
= 0;
10950 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10951 doc
: /* Return the current depth in recursive edits. */)
10955 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10959 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10960 "FOpen dribble file: ",
10961 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10962 If FILE is nil, close any open dribble file. */)
10975 file
= Fexpand_file_name (file
, Qnil
);
10976 dribble
= fopen (SDATA (file
), "w");
10978 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10983 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10984 doc
: /* Discard the contents of the terminal input buffer.
10985 Also end any kbd macro being defined. */)
10988 if (!NILP (current_kboard
->defining_kbd_macro
))
10990 /* Discard the last command from the macro. */
10991 Fcancel_kbd_macro_events ();
10995 update_mode_lines
++;
10997 Vunread_command_events
= Qnil
;
10998 unread_command_char
= -1;
11000 discard_tty_input ();
11002 kbd_fetch_ptr
= kbd_store_ptr
;
11008 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
11009 doc
: /* Stop Emacs and return to superior process. You can resume later.
11010 If `cannot-suspend' is non-nil, or if the system doesn't support job
11011 control, run a subshell instead.
11013 If optional arg STUFFSTRING is non-nil, its characters are stuffed
11014 to be read as terminal input by Emacs's parent, after suspension.
11016 Before suspending, run the normal hook `suspend-hook'.
11017 After resumption run the normal hook `suspend-resume-hook'.
11019 Some operating systems cannot stop the Emacs process and resume it later.
11020 On such systems, Emacs starts a subshell instead of suspending. */)
11022 Lisp_Object stuffstring
;
11024 int count
= SPECPDL_INDEX ();
11025 int old_height
, old_width
;
11027 struct gcpro gcpro1
;
11029 if (tty_list
&& tty_list
->next
)
11030 error ("There are other tty frames open; close them before suspending Emacs");
11032 if (!NILP (stuffstring
))
11033 CHECK_STRING (stuffstring
);
11035 /* Run the functions in suspend-hook. */
11036 if (!NILP (Vrun_hooks
))
11037 call1 (Vrun_hooks
, intern ("suspend-hook"));
11039 GCPRO1 (stuffstring
);
11040 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
11041 reset_all_sys_modes ();
11042 /* sys_suspend can get an error if it tries to fork a subshell
11043 and the system resources aren't available for that. */
11044 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_all_sys_modes
,
11046 stuff_buffered_input (stuffstring
);
11047 if (cannot_suspend
)
11051 unbind_to (count
, Qnil
);
11053 /* Check if terminal/window size has changed.
11054 Note that this is not useful when we are running directly
11055 with a window system; but suspend should be disabled in that case. */
11056 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
11057 if (width
!= old_width
|| height
!= old_height
)
11058 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
11060 /* Run suspend-resume-hook. */
11061 if (!NILP (Vrun_hooks
))
11062 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
11068 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
11069 Then in any case stuff anything Emacs has read ahead and not used. */
11072 stuff_buffered_input (stuffstring
)
11073 Lisp_Object stuffstring
;
11075 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
11076 register unsigned char *p
;
11078 if (STRINGP (stuffstring
))
11080 register int count
;
11082 p
= SDATA (stuffstring
);
11083 count
= SBYTES (stuffstring
);
11084 while (count
-- > 0)
11089 /* Anything we have read ahead, put back for the shell to read. */
11090 /* ?? What should this do when we have multiple keyboards??
11091 Should we ignore anything that was typed in at the "wrong" kboard?
11093 rms: we should stuff everything back into the kboard
11095 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
11098 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
11099 kbd_fetch_ptr
= kbd_buffer
;
11100 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
11101 stuff_char (kbd_fetch_ptr
->code
);
11103 clear_event (kbd_fetch_ptr
);
11107 #endif /* SIGTSTP */
11111 set_waiting_for_input (time_to_clear
)
11112 EMACS_TIME
*time_to_clear
;
11114 input_available_clear_time
= time_to_clear
;
11116 /* Tell handle_interrupt to throw back to read_char, */
11117 waiting_for_input
= 1;
11119 /* If handle_interrupt was called before and buffered a C-g,
11120 make it run again now, to avoid timing error. */
11121 if (!NILP (Vquit_flag
))
11122 quit_throw_to_read_char ();
11126 clear_waiting_for_input ()
11128 /* Tell handle_interrupt not to throw back to read_char, */
11129 waiting_for_input
= 0;
11130 input_available_clear_time
= 0;
11133 /* The SIGINT handler.
11135 If we have a frame on the controlling tty, we assume that the
11136 SIGINT was generated by C-g, so we call handle_interrupt.
11137 Otherwise, the handler kills Emacs. */
11140 interrupt_signal (signalnum
) /* If we don't have an argument, */
11141 int signalnum
; /* some compilers complain in signal calls. */
11143 /* Must preserve main program's value of errno. */
11144 int old_errno
= errno
;
11145 struct terminal
*terminal
;
11147 #if defined (USG) && !defined (POSIX_SIGNALS)
11148 /* USG systems forget handlers when they are used;
11149 must reestablish each time */
11150 signal (SIGINT
, interrupt_signal
);
11151 signal (SIGQUIT
, interrupt_signal
);
11154 SIGNAL_THREAD_CHECK (signalnum
);
11156 /* See if we have an active terminal on our controlling tty. */
11157 terminal
= get_named_tty ("/dev/tty");
11160 /* If there are no frames there, let's pretend that we are a
11161 well-behaving UN*X program and quit. */
11162 Fkill_emacs (Qnil
);
11166 /* Otherwise, the SIGINT was probably generated by C-g. */
11168 /* Set internal_last_event_frame to the top frame of the
11169 controlling tty, if we have a frame there. We disable the
11170 interrupt key on secondary ttys, so the SIGINT must have come
11171 from the controlling tty. */
11172 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
11174 handle_interrupt ();
11180 /* This routine is called at interrupt level in response to C-g.
11182 It is called from the SIGINT handler or kbd_buffer_store_event.
11184 If `waiting_for_input' is non zero, then unless `echoing' is
11185 nonzero, immediately throw back to read_char.
11187 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
11188 eval to throw, when it gets a chance. If quit-flag is already
11189 non-nil, it stops the job right away. */
11192 handle_interrupt ()
11198 /* XXX This code needs to be revised for multi-tty support. */
11199 if (!NILP (Vquit_flag
) && get_named_tty ("/dev/tty"))
11201 /* If SIGINT isn't blocked, don't let us be interrupted by
11202 another SIGINT, it might be harmful due to non-reentrancy
11203 in I/O functions. */
11204 sigblock (sigmask (SIGINT
));
11207 reset_all_sys_modes ();
11209 #ifdef SIGTSTP /* Support possible in later USG versions */
11211 * On systems which can suspend the current process and return to the original
11212 * shell, this command causes the user to end up back at the shell.
11213 * The "Auto-save" and "Abort" questions are not asked until
11214 * the user elects to return to emacs, at which point he can save the current
11215 * job and either dump core or continue.
11219 /* Perhaps should really fork an inferior shell?
11220 But that would not provide any way to get back
11221 to the original shell, ever. */
11222 printf ("No support for stopping a process on this operating system;\n");
11223 printf ("you can continue or abort.\n");
11224 #endif /* not SIGTSTP */
11226 /* We must remain inside the screen area when the internal terminal
11227 is used. Note that [Enter] is not echoed by dos. */
11228 cursor_to (SELECTED_FRAME (), 0, 0);
11230 /* It doesn't work to autosave while GC is in progress;
11231 the code used for auto-saving doesn't cope with the mark bit. */
11232 if (!gc_in_progress
)
11234 printf ("Auto-save? (y or n) ");
11236 if (((c
= getchar ()) & ~040) == 'Y')
11238 Fdo_auto_save (Qt
, Qnil
);
11240 printf ("\r\nAuto-save done");
11241 #else /* not MSDOS */
11242 printf ("Auto-save done\n");
11243 #endif /* not MSDOS */
11245 while (c
!= '\n') c
= getchar ();
11249 /* During GC, it must be safe to reenable quitting again. */
11250 Vinhibit_quit
= Qnil
;
11253 #endif /* not MSDOS */
11254 printf ("Garbage collection in progress; cannot auto-save now\r\n");
11255 printf ("but will instead do a real quit after garbage collection ends\r\n");
11260 printf ("\r\nAbort? (y or n) ");
11261 #else /* not MSDOS */
11262 printf ("Abort (and dump core)? (y or n) ");
11263 #endif /* not MSDOS */
11265 if (((c
= getchar ()) & ~040) == 'Y')
11267 while (c
!= '\n') c
= getchar ();
11269 printf ("\r\nContinuing...\r\n");
11270 #else /* not MSDOS */
11271 printf ("Continuing...\n");
11272 #endif /* not MSDOS */
11274 init_all_sys_modes ();
11279 /* If executing a function that wants to be interrupted out of
11280 and the user has not deferred quitting by binding `inhibit-quit'
11281 then quit right away. */
11282 if (immediate_quit
&& NILP (Vinhibit_quit
))
11284 struct gl_state_s saved
;
11285 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
11287 immediate_quit
= 0;
11290 GCPRO4 (saved
.object
, saved
.global_code
,
11291 saved
.current_syntax_table
, saved
.old_prop
);
11292 Fsignal (Qquit
, Qnil
);
11297 /* Else request quit when it's safe */
11301 /* TODO: The longjmp in this call throws the NS event loop integration off,
11302 and it seems to do fine without this. Probably some attention
11303 needs to be paid to the setting of waiting_for_input in
11304 wait_reading_process_output() under HAVE_NS because of the call
11305 to ns_select there (needed because otherwise events aren't picked up
11306 outside of polling since we don't get SIGIO like X and we don't have a
11307 separate event loop thread like W32. */
11309 if (waiting_for_input
&& !echoing
)
11310 quit_throw_to_read_char ();
11314 /* Handle a C-g by making read_char return C-g. */
11317 quit_throw_to_read_char ()
11320 /* Prevent another signal from doing this before we finish. */
11321 clear_waiting_for_input ();
11324 Vunread_command_events
= Qnil
;
11325 unread_command_char
= -1;
11327 #if 0 /* Currently, sit_for is called from read_char without turning
11328 off polling. And that can call set_waiting_for_input.
11329 It seems to be harmless. */
11330 #ifdef POLL_FOR_INPUT
11331 /* May be > 1 if in recursive minibuffer. */
11332 if (poll_suppress_count
== 0)
11336 if (FRAMEP (internal_last_event_frame
)
11337 && !EQ (internal_last_event_frame
, selected_frame
))
11338 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
11341 _longjmp (getcjmp
, 1);
11344 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
, Sset_input_interrupt_mode
, 1, 1, 0,
11345 doc
: /* Set interrupt mode of reading keyboard input.
11346 If INTERRUPT is non-nil, Emacs will use input interrupts;
11347 otherwise Emacs uses CBREAK mode.
11349 See also `current-input-mode'. */)
11351 Lisp_Object interrupt
;
11353 int new_interrupt_input
;
11355 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11356 #ifdef HAVE_X_WINDOWS
11357 if (x_display_list
!= NULL
)
11359 /* When using X, don't give the user a real choice,
11360 because we haven't implemented the mechanisms to support it. */
11361 #ifdef NO_SOCK_SIGIO
11362 new_interrupt_input
= 0;
11363 #else /* not NO_SOCK_SIGIO */
11364 new_interrupt_input
= 1;
11365 #endif /* NO_SOCK_SIGIO */
11368 #endif /* HAVE_X_WINDOWS */
11369 new_interrupt_input
= !NILP (interrupt
);
11370 #else /* not SIGIO */
11371 new_interrupt_input
= 0;
11372 #endif /* not SIGIO */
11374 if (new_interrupt_input
!= interrupt_input
)
11376 #ifdef POLL_FOR_INPUT
11380 /* this causes startup screen to be restored and messes with the mouse */
11381 reset_all_sys_modes ();
11383 interrupt_input
= new_interrupt_input
;
11385 init_all_sys_modes ();
11388 #ifdef POLL_FOR_INPUT
11389 poll_suppress_count
= 1;
11396 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
11397 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
11398 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11399 C-q in key sequences.
11401 This setting only has an effect on tty terminals and only when
11402 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11404 See also `current-input-mode'. */)
11406 Lisp_Object flow
, terminal
;
11408 struct terminal
*t
= get_terminal (terminal
, 1);
11409 struct tty_display_info
*tty
;
11410 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11412 tty
= t
->display_info
.tty
;
11414 if (tty
->flow_control
!= !NILP (flow
))
11417 /* this causes startup screen to be restored and messes with the mouse */
11418 reset_sys_modes (tty
);
11421 tty
->flow_control
= !NILP (flow
);
11424 init_sys_modes (tty
);
11430 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11431 doc
: /* Enable or disable 8-bit input on TERMINAL.
11432 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11433 bit as the Meta modifier.
11435 If META is nil, Emacs will ignore the top bit, on the assumption it is
11438 Otherwise, Emacs will accept and pass through 8-bit input without
11439 specially interpreting the top bit.
11441 This setting only has an effect on tty terminal devices.
11443 Optional parameter TERMINAL specifies the tty terminal device to use.
11444 It may be a terminal object, a frame, or nil for the terminal used by
11445 the currently selected frame.
11447 See also `current-input-mode'. */)
11449 Lisp_Object meta
, terminal
;
11451 struct terminal
*t
= get_terminal (terminal
, 1);
11452 struct tty_display_info
*tty
;
11455 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11457 tty
= t
->display_info
.tty
;
11461 else if (EQ (meta
, Qt
))
11466 if (tty
->meta_key
!= new_meta
)
11469 /* this causes startup screen to be restored and messes with the mouse */
11470 reset_sys_modes (tty
);
11473 tty
->meta_key
= new_meta
;
11476 init_sys_modes (tty
);
11482 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11483 doc
: /* Specify character used for quitting.
11484 QUIT must be an ASCII character.
11486 This function only has an effect on the controlling tty of the Emacs
11489 See also `current-input-mode'. */)
11493 struct terminal
*t
= get_named_tty ("/dev/tty");
11494 struct tty_display_info
*tty
;
11495 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11497 tty
= t
->display_info
.tty
;
11499 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11500 error ("QUIT must be an ASCII character");
11503 /* this causes startup screen to be restored and messes with the mouse */
11504 reset_sys_modes (tty
);
11507 /* Don't let this value be out of range. */
11508 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11511 init_sys_modes (tty
);
11517 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11518 doc
: /* Set mode of reading keyboard input.
11519 First arg INTERRUPT non-nil means use input interrupts;
11520 nil means use CBREAK mode.
11521 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11522 (no effect except in CBREAK mode).
11523 Third arg META t means accept 8-bit input (for a Meta key).
11524 META nil means ignore the top bit, on the assumption it is parity.
11525 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11526 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11527 See also `current-input-mode'. */)
11528 (interrupt
, flow
, meta
, quit
)
11529 Lisp_Object interrupt
, flow
, meta
, quit
;
11531 Fset_input_interrupt_mode (interrupt
);
11532 Fset_output_flow_control (flow
, Qnil
);
11533 Fset_input_meta_mode (meta
, Qnil
);
11535 Fset_quit_char (quit
);
11539 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11540 doc
: /* Return information about the way Emacs currently reads keyboard input.
11541 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11542 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11543 nil, Emacs is using CBREAK mode.
11544 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11545 terminal; this does not apply if Emacs uses interrupt-driven input.
11546 META is t if accepting 8-bit input with 8th bit as Meta flag.
11547 META nil means ignoring the top bit, on the assumption it is parity.
11548 META is neither t nor nil if accepting 8-bit input and using
11549 all 8 bits as the character code.
11550 QUIT is the character Emacs currently uses to quit.
11551 The elements of this list correspond to the arguments of
11552 `set-input-mode'. */)
11555 Lisp_Object val
[4];
11556 struct frame
*sf
= XFRAME (selected_frame
);
11558 val
[0] = interrupt_input
? Qt
: Qnil
;
11559 if (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
11561 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11562 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11564 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11571 XSETFASTINT (val
[3], quit_char
);
11573 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11576 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11577 doc
: /* Return position information for pixel coordinates X and Y.
11578 By default, X and Y are relative to text area of the selected window.
11579 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11580 If optional fourth arg WHOLE is non-nil, X is relative to the left
11581 edge of the window.
11583 The return value is similar to a mouse click position:
11584 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11585 IMAGE (DX . DY) (WIDTH . HEIGHT))
11586 The `posn-' functions access elements of such lists. */)
11587 (x
, y
, frame_or_window
, whole
)
11588 Lisp_Object x
, y
, frame_or_window
, whole
;
11593 if (NILP (frame_or_window
))
11594 frame_or_window
= selected_window
;
11596 if (WINDOWP (frame_or_window
))
11600 CHECK_LIVE_WINDOW (frame_or_window
);
11602 w
= XWINDOW (frame_or_window
);
11603 XSETINT (x
, (XINT (x
)
11604 + WINDOW_LEFT_EDGE_X (w
)
11606 ? window_box_left_offset (w
, TEXT_AREA
)
11608 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11609 frame_or_window
= w
->frame
;
11612 CHECK_LIVE_FRAME (frame_or_window
);
11614 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
11617 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11618 doc
: /* Return position information for buffer POS in WINDOW.
11619 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11621 Return nil if position is not visible in window. Otherwise,
11622 the return value is similar to that returned by `event-start' for
11623 a mouse click at the upper left corner of the glyph corresponding
11624 to the given buffer position:
11625 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11626 IMAGE (DX . DY) (WIDTH . HEIGHT))
11627 The `posn-' functions access elements of such lists. */)
11629 Lisp_Object pos
, window
;
11634 window
= selected_window
;
11636 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11639 Lisp_Object x
= XCAR (tem
);
11640 Lisp_Object y
= XCAR (XCDR (tem
));
11642 /* Point invisible due to hscrolling? */
11645 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11653 * Set up a new kboard object with reasonable initial values.
11659 kb
->Voverriding_terminal_local_map
= Qnil
;
11660 kb
->Vlast_command
= Qnil
;
11661 kb
->Vreal_last_command
= Qnil
;
11662 kb
->Vkeyboard_translate_table
= Qnil
;
11663 kb
->Vlast_repeatable_command
= Qnil
;
11664 kb
->Vprefix_arg
= Qnil
;
11665 kb
->Vlast_prefix_arg
= Qnil
;
11666 kb
->kbd_queue
= Qnil
;
11667 kb
->kbd_queue_has_data
= 0;
11668 kb
->immediate_echo
= 0;
11669 kb
->echo_string
= Qnil
;
11670 kb
->echo_after_prompt
= -1;
11671 kb
->kbd_macro_buffer
= 0;
11672 kb
->kbd_macro_bufsize
= 0;
11673 kb
->defining_kbd_macro
= Qnil
;
11674 kb
->Vlast_kbd_macro
= Qnil
;
11675 kb
->reference_count
= 0;
11676 kb
->Vsystem_key_alist
= Qnil
;
11677 kb
->system_key_syms
= Qnil
;
11678 kb
->Vwindow_system
= Qt
; /* Unset. */
11679 kb
->Vinput_decode_map
= Fmake_sparse_keymap (Qnil
);
11680 kb
->Vlocal_function_key_map
= Fmake_sparse_keymap (Qnil
);
11681 Fset_keymap_parent (kb
->Vlocal_function_key_map
, Vfunction_key_map
);
11682 kb
->Vdefault_minibuffer_frame
= Qnil
;
11686 * Destroy the contents of a kboard object, but not the object itself.
11687 * We use this just before deleting it, or if we're going to initialize
11688 * it a second time.
11694 xfree (kb
->kbd_macro_buffer
);
11697 /* Free KB and memory referenced from it. */
11705 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11708 *kbp
= kb
->next_kboard
;
11710 /* Prevent a dangling reference to KB. */
11711 if (kb
== current_kboard
11712 && FRAMEP (selected_frame
)
11713 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11715 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11717 if (current_kboard
== kb
)
11728 /* This is correct before outermost invocation of the editor loop */
11729 command_loop_level
= -1;
11730 immediate_quit
= 0;
11731 quit_char
= Ctl ('g');
11732 Vunread_command_events
= Qnil
;
11733 unread_command_char
= -1;
11734 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11736 recent_keys_index
= 0;
11737 kbd_fetch_ptr
= kbd_buffer
;
11738 kbd_store_ptr
= kbd_buffer
;
11739 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11740 do_mouse_tracking
= Qnil
;
11743 interrupt_input_blocked
= 0;
11744 interrupt_input_pending
= 0;
11746 pending_signals
= 0;
11749 /* This means that command_loop_1 won't try to select anything the first
11751 internal_last_event_frame
= Qnil
;
11752 Vlast_event_frame
= internal_last_event_frame
;
11754 current_kboard
= initial_kboard
;
11755 /* Re-initialize the keyboard again. */
11756 wipe_kboard (current_kboard
);
11757 init_kboard (current_kboard
);
11758 /* A value of nil for Vwindow_system normally means a tty, but we also use
11759 it for the initial terminal since there is no window system there. */
11760 current_kboard
->Vwindow_system
= Qnil
;
11762 if (!noninteractive
)
11764 /* Before multi-tty support, these handlers used to be installed
11765 only if the current session was a tty session. Now an Emacs
11766 session may have multiple display types, so we always handle
11767 SIGINT. There is special code in interrupt_signal to exit
11768 Emacs on SIGINT when there are no termcap frames on the
11769 controlling terminal. */
11770 signal (SIGINT
, interrupt_signal
);
11771 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
11772 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11773 SIGQUIT and we can't tell which one it will give us. */
11774 signal (SIGQUIT
, interrupt_signal
);
11775 #endif /* HAVE_TERMIO */
11777 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11779 if (!noninteractive
)
11780 signal (SIGIO
, input_available_signal
);
11783 /* Use interrupt input by default, if it works and noninterrupt input
11784 has deficiencies. */
11786 #ifdef INTERRUPT_INPUT
11787 interrupt_input
= 1;
11789 interrupt_input
= 0;
11795 if (keyboard_init_hook
)
11796 (*keyboard_init_hook
) ();
11798 #ifdef POLL_FOR_INPUT
11800 poll_suppress_count
= 1;
11805 /* This type's only use is in syms_of_keyboard, to initialize the
11806 event header symbols and put properties on them. */
11807 struct event_head
{
11813 struct event_head head_table
[] = {
11814 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11815 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11816 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11817 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11818 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11819 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11820 /* `select-window' should be handled just like `switch-frame'
11821 in read_key_sequence. */
11822 {&Qselect_window
, "select-window", &Qswitch_frame
}
11826 syms_of_keyboard ()
11828 pending_funcalls
= Qnil
;
11829 staticpro (&pending_funcalls
);
11831 Vlispy_mouse_stem
= make_pure_c_string ("mouse");
11832 staticpro (&Vlispy_mouse_stem
);
11835 QCimage
= intern_c_string (":image");
11836 staticpro (&QCimage
);
11838 staticpro (&Qhelp_echo
);
11839 Qhelp_echo
= intern_c_string ("help-echo");
11842 Qrtl
= intern_c_string (":rtl");
11844 staticpro (&item_properties
);
11845 item_properties
= Qnil
;
11847 staticpro (&tool_bar_item_properties
);
11848 tool_bar_item_properties
= Qnil
;
11849 staticpro (&tool_bar_items_vector
);
11850 tool_bar_items_vector
= Qnil
;
11852 staticpro (&real_this_command
);
11853 real_this_command
= Qnil
;
11855 Qtimer_event_handler
= intern_c_string ("timer-event-handler");
11856 staticpro (&Qtimer_event_handler
);
11858 Qdisabled_command_function
= intern_c_string ("disabled-command-function");
11859 staticpro (&Qdisabled_command_function
);
11861 Qself_insert_command
= intern_c_string ("self-insert-command");
11862 staticpro (&Qself_insert_command
);
11864 Qforward_char
= intern_c_string ("forward-char");
11865 staticpro (&Qforward_char
);
11867 Qbackward_char
= intern_c_string ("backward-char");
11868 staticpro (&Qbackward_char
);
11870 Qdisabled
= intern_c_string ("disabled");
11871 staticpro (&Qdisabled
);
11873 Qundefined
= intern_c_string ("undefined");
11874 staticpro (&Qundefined
);
11876 Qpre_command_hook
= intern_c_string ("pre-command-hook");
11877 staticpro (&Qpre_command_hook
);
11879 Qpost_command_hook
= intern_c_string ("post-command-hook");
11880 staticpro (&Qpost_command_hook
);
11882 Qdeferred_action_function
= intern_c_string ("deferred-action-function");
11883 staticpro (&Qdeferred_action_function
);
11885 Qcommand_hook_internal
= intern_c_string ("command-hook-internal");
11886 staticpro (&Qcommand_hook_internal
);
11888 Qfunction_key
= intern_c_string ("function-key");
11889 staticpro (&Qfunction_key
);
11890 Qmouse_click
= intern_c_string ("mouse-click");
11891 staticpro (&Qmouse_click
);
11892 #if defined (WINDOWSNT)
11893 Qlanguage_change
= intern_c_string ("language-change");
11894 staticpro (&Qlanguage_change
);
11896 Qdrag_n_drop
= intern_c_string ("drag-n-drop");
11897 staticpro (&Qdrag_n_drop
);
11899 Qsave_session
= intern_c_string ("save-session");
11900 staticpro (&Qsave_session
);
11903 Qdbus_event
= intern_c_string ("dbus-event");
11904 staticpro (&Qdbus_event
);
11907 Qconfig_changed_event
= intern_c_string ("config-changed-event");
11908 staticpro (&Qconfig_changed_event
);
11910 Qmenu_enable
= intern_c_string ("menu-enable");
11911 staticpro (&Qmenu_enable
);
11912 QCenable
= intern_c_string (":enable");
11913 staticpro (&QCenable
);
11914 QCvisible
= intern_c_string (":visible");
11915 staticpro (&QCvisible
);
11916 QChelp
= intern_c_string (":help");
11917 staticpro (&QChelp
);
11918 QCfilter
= intern_c_string (":filter");
11919 staticpro (&QCfilter
);
11920 QCbutton
= intern_c_string (":button");
11921 staticpro (&QCbutton
);
11922 QCkeys
= intern_c_string (":keys");
11923 staticpro (&QCkeys
);
11924 QCkey_sequence
= intern_c_string (":key-sequence");
11925 staticpro (&QCkey_sequence
);
11926 QCtoggle
= intern_c_string (":toggle");
11927 staticpro (&QCtoggle
);
11928 QCradio
= intern_c_string (":radio");
11929 staticpro (&QCradio
);
11931 Qmode_line
= intern_c_string ("mode-line");
11932 staticpro (&Qmode_line
);
11933 Qvertical_line
= intern_c_string ("vertical-line");
11934 staticpro (&Qvertical_line
);
11935 Qvertical_scroll_bar
= intern_c_string ("vertical-scroll-bar");
11936 staticpro (&Qvertical_scroll_bar
);
11937 Qmenu_bar
= intern_c_string ("menu-bar");
11938 staticpro (&Qmenu_bar
);
11940 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11941 Qmouse_fixup_help_message
= intern_c_string ("mouse-fixup-help-message");
11942 staticpro (&Qmouse_fixup_help_message
);
11945 Qabove_handle
= intern_c_string ("above-handle");
11946 staticpro (&Qabove_handle
);
11947 Qhandle
= intern_c_string ("handle");
11948 staticpro (&Qhandle
);
11949 Qbelow_handle
= intern_c_string ("below-handle");
11950 staticpro (&Qbelow_handle
);
11951 Qup
= intern_c_string ("up");
11953 Qdown
= intern_c_string ("down");
11954 staticpro (&Qdown
);
11955 Qtop
= intern_c_string ("top");
11957 Qbottom
= intern_c_string ("bottom");
11958 staticpro (&Qbottom
);
11959 Qend_scroll
= intern_c_string ("end-scroll");
11960 staticpro (&Qend_scroll
);
11961 Qratio
= intern_c_string ("ratio");
11962 staticpro (&Qratio
);
11964 Qevent_kind
= intern_c_string ("event-kind");
11965 staticpro (&Qevent_kind
);
11966 Qevent_symbol_elements
= intern_c_string ("event-symbol-elements");
11967 staticpro (&Qevent_symbol_elements
);
11968 Qevent_symbol_element_mask
= intern_c_string ("event-symbol-element-mask");
11969 staticpro (&Qevent_symbol_element_mask
);
11970 Qmodifier_cache
= intern_c_string ("modifier-cache");
11971 staticpro (&Qmodifier_cache
);
11973 Qrecompute_lucid_menubar
= intern_c_string ("recompute-lucid-menubar");
11974 staticpro (&Qrecompute_lucid_menubar
);
11975 Qactivate_menubar_hook
= intern_c_string ("activate-menubar-hook");
11976 staticpro (&Qactivate_menubar_hook
);
11978 Qpolling_period
= intern_c_string ("polling-period");
11979 staticpro (&Qpolling_period
);
11981 Qinput_method_function
= intern_c_string ("input-method-function");
11982 staticpro (&Qinput_method_function
);
11984 Qinput_method_exit_on_first_char
= intern_c_string ("input-method-exit-on-first-char");
11985 staticpro (&Qinput_method_exit_on_first_char
);
11986 Qinput_method_use_echo_area
= intern_c_string ("input-method-use-echo-area");
11987 staticpro (&Qinput_method_use_echo_area
);
11989 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11990 Fset (Qinput_method_use_echo_area
, Qnil
);
11992 last_point_position_buffer
= Qnil
;
11993 last_point_position_window
= Qnil
;
11996 struct event_head
*p
;
11998 for (p
= head_table
;
11999 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
12002 *p
->var
= intern_c_string (p
->name
);
12003 staticpro (p
->var
);
12004 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
12005 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
12009 button_down_location
= Fmake_vector (make_number (5), Qnil
);
12010 staticpro (&button_down_location
);
12011 mouse_syms
= Fmake_vector (make_number (5), Qnil
);
12012 staticpro (&mouse_syms
);
12013 wheel_syms
= Fmake_vector (make_number (sizeof (lispy_wheel_names
)
12014 / sizeof (lispy_wheel_names
[0])),
12016 staticpro (&wheel_syms
);
12020 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
12022 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
12023 for (i
= 0; i
< len
; i
++)
12024 if (modifier_names
[i
])
12025 XVECTOR (modifier_symbols
)->contents
[i
] = intern_c_string (modifier_names
[i
]);
12026 staticpro (&modifier_symbols
);
12029 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
12030 staticpro (&recent_keys
);
12032 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
12033 staticpro (&this_command_keys
);
12035 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
12036 staticpro (&raw_keybuf
);
12038 Qextended_command_history
= intern_c_string ("extended-command-history");
12039 Fset (Qextended_command_history
, Qnil
);
12040 staticpro (&Qextended_command_history
);
12042 accent_key_syms
= Qnil
;
12043 staticpro (&accent_key_syms
);
12045 func_key_syms
= Qnil
;
12046 staticpro (&func_key_syms
);
12048 drag_n_drop_syms
= Qnil
;
12049 staticpro (&drag_n_drop_syms
);
12051 unread_switch_frame
= Qnil
;
12052 staticpro (&unread_switch_frame
);
12054 internal_last_event_frame
= Qnil
;
12055 staticpro (&internal_last_event_frame
);
12057 read_key_sequence_cmd
= Qnil
;
12058 staticpro (&read_key_sequence_cmd
);
12060 menu_bar_one_keymap_changed_items
= Qnil
;
12061 staticpro (&menu_bar_one_keymap_changed_items
);
12063 menu_bar_items_vector
= Qnil
;
12064 staticpro (&menu_bar_items_vector
);
12066 help_form_saved_window_configs
= Qnil
;
12067 staticpro (&help_form_saved_window_configs
);
12069 defsubr (&Scurrent_idle_time
);
12070 defsubr (&Sevent_symbol_parse_modifiers
);
12071 defsubr (&Sevent_convert_list
);
12072 defsubr (&Sread_key_sequence
);
12073 defsubr (&Sread_key_sequence_vector
);
12074 defsubr (&Srecursive_edit
);
12075 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
12076 defsubr (&Strack_mouse
);
12078 defsubr (&Sinput_pending_p
);
12079 defsubr (&Scommand_execute
);
12080 defsubr (&Srecent_keys
);
12081 defsubr (&Sthis_command_keys
);
12082 defsubr (&Sthis_command_keys_vector
);
12083 defsubr (&Sthis_single_command_keys
);
12084 defsubr (&Sthis_single_command_raw_keys
);
12085 defsubr (&Sreset_this_command_lengths
);
12086 defsubr (&Sclear_this_command_keys
);
12087 defsubr (&Ssuspend_emacs
);
12088 defsubr (&Sabort_recursive_edit
);
12089 defsubr (&Sexit_recursive_edit
);
12090 defsubr (&Srecursion_depth
);
12091 defsubr (&Stop_level
);
12092 defsubr (&Sdiscard_input
);
12093 defsubr (&Sopen_dribble_file
);
12094 defsubr (&Sset_input_interrupt_mode
);
12095 defsubr (&Sset_output_flow_control
);
12096 defsubr (&Sset_input_meta_mode
);
12097 defsubr (&Sset_quit_char
);
12098 defsubr (&Sset_input_mode
);
12099 defsubr (&Scurrent_input_mode
);
12100 defsubr (&Sexecute_extended_command
);
12101 defsubr (&Sposn_at_point
);
12102 defsubr (&Sposn_at_x_y
);
12104 DEFVAR_LISP ("last-command-event", &last_command_event
,
12105 doc
: /* Last input event that was part of a command. */);
12107 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
12108 doc
: /* Last input event in a command, except for mouse menu events.
12109 Mouse menus give back keys that don't look like mouse events;
12110 this variable holds the actual mouse event that led to the menu,
12111 so that you can determine whether the command was run by mouse or not. */);
12113 DEFVAR_LISP ("last-input-event", &last_input_event
,
12114 doc
: /* Last input event. */);
12116 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
12117 doc
: /* List of events to be read as the command input.
12118 These events are processed first, before actual keyboard input.
12119 Events read from this list are not normally added to `this-command-keys',
12120 as they will already have been added once as they were read for the first time.
12121 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
12122 Vunread_command_events
= Qnil
;
12124 DEFVAR_INT ("unread-command-char", &unread_command_char
,
12125 doc
: /* If not -1, an object to be read as next command input event. */);
12127 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
12128 doc
: /* List of events to be processed as input by input methods.
12129 These events are processed before `unread-command-events'
12130 and actual keyboard input, but are not given to `input-method-function'. */);
12131 Vunread_post_input_method_events
= Qnil
;
12133 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
12134 doc
: /* List of events to be processed as input by input methods.
12135 These events are processed after `unread-command-events', but
12136 before actual keyboard input.
12137 If there's an active input method, the events are given to
12138 `input-method-function'. */);
12139 Vunread_input_method_events
= Qnil
;
12141 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
12142 doc
: /* Meta-prefix character code.
12143 Meta-foo as command input turns into this character followed by foo. */);
12144 XSETINT (meta_prefix_char
, 033);
12146 DEFVAR_KBOARD ("last-command", Vlast_command
,
12147 doc
: /* The last command executed.
12148 Normally a symbol with a function definition, but can be whatever was found
12149 in the keymap, or whatever the variable `this-command' was set to by that
12152 The value `mode-exit' is special; it means that the previous command
12153 read an event that told it to exit, and it did so and unread that event.
12154 In other words, the present command is the event that made the previous
12157 The value `kill-region' is special; it means that the previous command
12158 was a kill command.
12160 `last-command' has a separate binding for each terminal device.
12161 See Info node `(elisp)Multiple Terminals'. */);
12163 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
12164 doc
: /* Same as `last-command', but never altered by Lisp code. */);
12166 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command
,
12167 doc
: /* Last command that may be repeated.
12168 The last command executed that was not bound to an input event.
12169 This is the command `repeat' will try to repeat. */);
12171 DEFVAR_LISP ("this-command", &Vthis_command
,
12172 doc
: /* The command now being executed.
12173 The command can set this variable; whatever is put here
12174 will be in `last-command' during the following command. */);
12175 Vthis_command
= Qnil
;
12177 DEFVAR_LISP ("this-command-keys-shift-translated",
12178 &Vthis_command_keys_shift_translated
,
12179 doc
: /* Non-nil if the key sequence activating this command was shift-translated.
12180 Shift-translation occurs when there is no binding for the key sequence
12181 as entered, but a binding was found by changing an upper-case letter
12182 to lower-case, or a shifted function key to an unshifted one. */);
12183 Vthis_command_keys_shift_translated
= Qnil
;
12185 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
12186 doc
: /* The command bound to the current key sequence before remapping.
12187 It equals `this-command' if the original command was not remapped through
12188 any of the active keymaps. Otherwise, the value of `this-command' is the
12189 result of looking up the original command in the active keymaps. */);
12190 Vthis_original_command
= Qnil
;
12192 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
12193 doc
: /* *Number of input events between auto-saves.
12194 Zero means disable autosaving due to number of characters typed. */);
12195 auto_save_interval
= 300;
12197 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
12198 doc
: /* *Number of seconds idle time before auto-save.
12199 Zero or nil means disable auto-saving due to idleness.
12200 After auto-saving due to this many seconds of idle time,
12201 Emacs also does a garbage collection if that seems to be warranted. */);
12202 XSETFASTINT (Vauto_save_timeout
, 30);
12204 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
12205 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
12206 The value may be integer or floating point. */);
12207 Vecho_keystrokes
= make_number (1);
12209 DEFVAR_INT ("polling-period", &polling_period
,
12210 doc
: /* *Interval between polling for input during Lisp execution.
12211 The reason for polling is to make C-g work to stop a running program.
12212 Polling is needed only when using X windows and SIGIO does not work.
12213 Polling is automatically disabled in all other cases. */);
12214 polling_period
= 2;
12216 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
12217 doc
: /* *Maximum time between mouse clicks to make a double-click.
12218 Measured in milliseconds. The value nil means disable double-click
12219 recognition; t means double-clicks have no time limit and are detected
12220 by position only. */);
12221 Vdouble_click_time
= make_number (500);
12223 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
12224 doc
: /* *Maximum mouse movement between clicks to make a double-click.
12225 On window-system frames, value is the number of pixels the mouse may have
12226 moved horizontally or vertically between two clicks to make a double-click.
12227 On non window-system frames, value is interpreted in units of 1/8 characters
12230 This variable is also the threshold for motion of the mouse
12231 to count as a drag. */);
12232 double_click_fuzz
= 3;
12234 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
12235 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
12236 inhibit_local_menu_bar_menus
= 0;
12238 DEFVAR_INT ("num-input-keys", &num_input_keys
,
12239 doc
: /* Number of complete key sequences read as input so far.
12240 This includes key sequences read from keyboard macros.
12241 The number is effectively the number of interactive command invocations. */);
12242 num_input_keys
= 0;
12244 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
12245 doc
: /* Number of input events read from the keyboard so far.
12246 This does not include events generated by keyboard macros. */);
12247 num_nonmacro_input_events
= 0;
12249 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
12250 doc
: /* The frame in which the most recently read event occurred.
12251 If the last event came from a keyboard macro, this is set to `macro'. */);
12252 Vlast_event_frame
= Qnil
;
12254 /* This variable is set up in sysdep.c. */
12255 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
12256 doc
: /* The ERASE character as set by the user with stty. */);
12258 DEFVAR_LISP ("help-char", &Vhelp_char
,
12259 doc
: /* Character to recognize as meaning Help.
12260 When it is read, do `(eval help-form)', and display result if it's a string.
12261 If the value of `help-form' is nil, this char can be read normally. */);
12262 XSETINT (Vhelp_char
, Ctl ('H'));
12264 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
12265 doc
: /* List of input events to recognize as meaning Help.
12266 These work just like the value of `help-char' (see that). */);
12267 Vhelp_event_list
= Qnil
;
12269 DEFVAR_LISP ("help-form", &Vhelp_form
,
12270 doc
: /* Form to execute when character `help-char' is read.
12271 If the form returns a string, that string is displayed.
12272 If `help-form' is nil, the help char is not recognized. */);
12275 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
12276 doc
: /* Command to run when `help-char' character follows a prefix key.
12277 This command is used only when there is no actual binding
12278 for that character after that prefix key. */);
12279 Vprefix_help_command
= Qnil
;
12281 DEFVAR_LISP ("top-level", &Vtop_level
,
12282 doc
: /* Form to evaluate when Emacs starts up.
12283 Useful to set before you dump a modified Emacs. */);
12286 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
12287 doc
: /* Translate table for local keyboard input, or nil.
12288 If non-nil, the value should be a char-table. Each character read
12289 from the keyboard is looked up in this char-table. If the value found
12290 there is non-nil, then it is used instead of the actual input character.
12292 The value can also be a string or vector, but this is considered obsolete.
12293 If it is a string or vector of length N, character codes N and up are left
12294 untranslated. In a vector, an element which is nil means "no translation".
12296 This is applied to the characters supplied to input methods, not their
12297 output. See also `translation-table-for-input'.
12299 This variable has a separate binding for each terminal.
12300 See Info node `(elisp)Multiple Terminals'. */);
12302 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
12303 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
12304 \(Even if the operating system has support for stopping a process.\) */);
12305 cannot_suspend
= 0;
12307 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
12308 doc
: /* Non-nil means prompt with menus when appropriate.
12309 This is done when reading from a keymap that has a prompt string,
12310 for elements that have prompt strings.
12311 The menu is displayed on the screen
12312 if X menus were enabled at configuration
12313 time and the previous event was a mouse click prefix key.
12314 Otherwise, menu prompting uses the echo area. */);
12315 menu_prompting
= 1;
12317 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
12318 doc
: /* Character to see next line of menu prompt.
12319 Type this character while in a menu prompt to rotate around the lines of it. */);
12320 XSETINT (menu_prompt_more_char
, ' ');
12322 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
12323 doc
: /* A mask of additional modifier keys to use with every keyboard character.
12324 Emacs applies the modifiers of the character stored here to each keyboard
12325 character it reads. For example, after evaluating the expression
12326 (setq extra-keyboard-modifiers ?\\C-x)
12327 all input characters will have the control modifier applied to them.
12329 Note that the character ?\\C-@, equivalent to the integer zero, does
12330 not count as a control character; rather, it counts as a character
12331 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
12332 cancels any modification. */);
12333 extra_keyboard_modifiers
= 0;
12335 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
12336 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
12337 The command loop sets this to nil before each command,
12338 and tests the value when the command returns.
12339 Buffer modification stores t in this variable. */);
12340 Vdeactivate_mark
= Qnil
;
12341 Qdeactivate_mark
= intern_c_string ("deactivate-mark");
12342 staticpro (&Qdeactivate_mark
);
12344 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
12345 doc
: /* Temporary storage of `pre-command-hook' or `post-command-hook'. */);
12346 Vcommand_hook_internal
= Qnil
;
12348 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
12349 doc
: /* Normal hook run before each command is executed.
12350 If an unhandled error happens in running this hook,
12351 the hook value is set to nil, since otherwise the error
12352 might happen repeatedly and make Emacs nonfunctional. */);
12353 Vpre_command_hook
= Qnil
;
12355 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
12356 doc
: /* Normal hook run after each command is executed.
12357 If an unhandled error happens in running this hook,
12358 the hook value is set to nil, since otherwise the error
12359 might happen repeatedly and make Emacs nonfunctional. */);
12360 Vpost_command_hook
= Qnil
;
12363 DEFVAR_LISP ("echo-area-clear-hook", ...,
12364 doc
: /* Normal hook run when clearing the echo area. */);
12366 Qecho_area_clear_hook
= intern_c_string ("echo-area-clear-hook");
12367 staticpro (&Qecho_area_clear_hook
);
12368 Fset (Qecho_area_clear_hook
, Qnil
);
12370 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
12371 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
12372 Vlucid_menu_bar_dirty_flag
= Qnil
;
12374 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
12375 doc
: /* List of menu bar items to move to the end of the menu bar.
12376 The elements of the list are event types that may have menu bar bindings. */);
12377 Vmenu_bar_final_items
= Qnil
;
12379 DEFVAR_KBOARD ("overriding-terminal-local-map",
12380 Voverriding_terminal_local_map
,
12381 doc
: /* Per-terminal keymap that overrides all other local keymaps.
12382 If this variable is non-nil, it is used as a keymap instead of the
12383 buffer's local map, and the minor mode keymaps and text property keymaps.
12384 It also replaces `overriding-local-map'.
12386 This variable is intended to let commands such as `universal-argument'
12387 set up a different keymap for reading the next command.
12389 `overriding-terminal-local-map' has a separate binding for each
12391 See Info node `(elisp)Multiple Terminals'. */);
12393 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
12394 doc
: /* Keymap that overrides all other local keymaps.
12395 If this variable is non-nil, it is used as a keymap--replacing the
12396 buffer's local map, the minor mode keymaps, and char property keymaps. */);
12397 Voverriding_local_map
= Qnil
;
12399 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
12400 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
12401 Otherwise, the menu bar continues to reflect the buffer's local map
12402 and the minor mode maps regardless of `overriding-local-map'. */);
12403 Voverriding_local_map_menu_flag
= Qnil
;
12405 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
12406 doc
: /* Keymap defining bindings for special events to execute at low level. */);
12407 Vspecial_event_map
= Fcons (intern_c_string ("keymap"), Qnil
);
12409 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
12410 doc
: /* *Non-nil means generate motion events for mouse motion. */);
12412 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
12413 doc
: /* Alist of system-specific X windows key symbols.
12414 Each element should have the form (N . SYMBOL) where N is the
12415 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12416 and SYMBOL is its name.
12418 `system-key-alist' has a separate binding for each terminal device.
12419 See Info node `(elisp)Multiple Terminals'. */);
12421 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
12422 doc
: /* Keymap that translates key sequences to key sequences during input.
12423 This is used mainly for mapping key sequences into some preferred
12424 key events (symbols).
12426 The `read-key-sequence' function replaces any subsequence bound by
12427 `local-function-key-map' with its binding. More precisely, when the
12428 active keymaps have no binding for the current key sequence but
12429 `local-function-key-map' binds a suffix of the sequence to a vector or
12430 string, `read-key-sequence' replaces the matching suffix with its
12431 binding, and continues with the new sequence.
12433 If the binding is a function, it is called with one argument (the prompt)
12434 and its return value (a key sequence) is used.
12436 The events that come from bindings in `local-function-key-map' are not
12437 themselves looked up in `local-function-key-map'.
12439 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12440 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12441 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12442 typing `ESC O P x' would return [f1 x].
12444 `local-function-key-map' has a separate binding for each terminal
12445 device. See Info node `(elisp)Multiple Terminals'. If you need to
12446 define a binding on all terminals, change `function-key-map'
12447 instead. Initially, `local-function-key-map' is an empty keymap that
12448 has `function-key-map' as its parent on all terminal devices. */);
12450 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map
,
12451 doc
: /* Keymap that decodes input escape sequences.
12452 This is used mainly for mapping ASCII function key sequences into
12453 real Emacs function key events (symbols).
12455 The `read-key-sequence' function replaces any subsequence bound by
12456 `input-decode-map' with its binding. Contrary to `function-key-map',
12457 this map applies its rebinding regardless of the presence of an ordinary
12458 binding. So it is more like `key-translation-map' except that it applies
12459 before `function-key-map' rather than after.
12461 If the binding is a function, it is called with one argument (the prompt)
12462 and its return value (a key sequence) is used.
12464 The events that come from bindings in `input-decode-map' are not
12465 themselves looked up in `input-decode-map'.
12467 This variable is keyboard-local. */);
12469 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
12470 doc
: /* The parent keymap of all `local-function-key-map' instances.
12471 Function key definitions that apply to all terminal devices should go
12472 here. If a mapping is defined in both the current
12473 `local-function-key-map' binding and this variable, then the local
12474 definition will take precendence. */);
12475 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12477 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
12478 doc
: /* Keymap of key translations that can override keymaps.
12479 This keymap works like `function-key-map', but comes after that,
12480 and its non-prefix bindings override ordinary bindings.
12481 Another difference is that it is global rather than keyboard-local. */);
12482 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12484 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
12485 doc
: /* List of deferred actions to be performed at a later time.
12486 The precise format isn't relevant here; we just check whether it is nil. */);
12487 Vdeferred_action_list
= Qnil
;
12489 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
12490 doc
: /* Function to call to handle deferred actions, after each command.
12491 This function is called with no arguments after each command
12492 whenever `deferred-action-list' is non-nil. */);
12493 Vdeferred_action_function
= Qnil
;
12495 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
12496 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12497 The value can be a length of time to show the message for.
12498 If the value is non-nil and not a number, we wait 2 seconds. */);
12499 Vsuggest_key_bindings
= Qt
;
12501 DEFVAR_LISP ("timer-list", &Vtimer_list
,
12502 doc
: /* List of active absolute time timers in order of increasing time. */);
12503 Vtimer_list
= Qnil
;
12505 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
12506 doc
: /* List of active idle-time timers in order of increasing time. */);
12507 Vtimer_idle_list
= Qnil
;
12509 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
12510 doc
: /* If non-nil, the function that implements the current input method.
12511 It's called with one argument, a printing character that was just read.
12512 \(That means a character with code 040...0176.)
12513 Typically this function uses `read-event' to read additional events.
12514 When it does so, it should first bind `input-method-function' to nil
12515 so it will not be called recursively.
12517 The function should return a list of zero or more events
12518 to be used as input. If it wants to put back some events
12519 to be reconsidered, separately, by the input method,
12520 it can add them to the beginning of `unread-command-events'.
12522 The input method function can find in `input-method-previous-message'
12523 the previous echo area message.
12525 The input method function should refer to the variables
12526 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12527 for guidance on what to do. */);
12528 Vinput_method_function
= Qnil
;
12530 DEFVAR_LISP ("input-method-previous-message",
12531 &Vinput_method_previous_message
,
12532 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12533 This variable exists because `read-event' clears the echo area
12534 before running the input method. It is nil if there was no message. */);
12535 Vinput_method_previous_message
= Qnil
;
12537 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
12538 doc
: /* If non-nil, the function that implements the display of help.
12539 It's called with one argument, the help string to display. */);
12540 Vshow_help_function
= Qnil
;
12542 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
12543 doc
: /* If non-nil, suppress point adjustment after executing a command.
12545 After a command is executed, if point is moved into a region that has
12546 special properties (e.g. composition, display), we adjust point to
12547 the boundary of the region. But, when a command sets this variable to
12548 non-nil, we suppress the point adjustment.
12550 This variable is set to nil before reading a command, and is checked
12551 just after executing the command. */);
12552 Vdisable_point_adjustment
= Qnil
;
12554 DEFVAR_LISP ("global-disable-point-adjustment",
12555 &Vglobal_disable_point_adjustment
,
12556 doc
: /* *If non-nil, always suppress point adjustment.
12558 The default value is nil, in which case, point adjustment are
12559 suppressed only after special commands that set
12560 `disable-point-adjustment' (which see) to non-nil. */);
12561 Vglobal_disable_point_adjustment
= Qnil
;
12563 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
12564 doc
: /* *How long to display an echo-area message when the minibuffer is active.
12565 If the value is not a number, such messages don't time out. */);
12566 Vminibuffer_message_timeout
= make_number (2);
12568 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input
,
12569 doc
: /* If non-nil, any keyboard input throws to this symbol.
12570 The value of that variable is passed to `quit-flag' and later causes a
12571 peculiar kind of quitting. */);
12572 Vthrow_on_input
= Qnil
;
12574 DEFVAR_LISP ("command-error-function", &Vcommand_error_function
,
12575 doc
: /* If non-nil, function to output error messages.
12576 The arguments are the error data, a list of the form
12577 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12578 such as just as `condition-case' would bind its variable to,
12579 the context (a string which normally goes at the start of the message),
12580 and the Lisp function within which the error was signaled. */);
12581 Vcommand_error_function
= Qnil
;
12583 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12584 &Venable_disabled_menus_and_buttons
,
12585 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12587 Help functions bind this to allow help on disabled menu items
12588 and tool-bar buttons. */);
12589 Venable_disabled_menus_and_buttons
= Qnil
;
12591 /* Create the initial keyboard. */
12592 initial_kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12593 init_kboard (initial_kboard
);
12594 /* Vwindow_system is left at t for now. */
12595 initial_kboard
->next_kboard
= all_kboards
;
12596 all_kboards
= initial_kboard
;
12600 keys_of_keyboard ()
12602 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12603 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12604 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12605 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12606 initial_define_key (meta_map
, 'x', "execute-extended-command");
12608 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12609 "handle-delete-frame");
12610 initial_define_lispy_key (Vspecial_event_map
, "ns-put-working-text",
12611 "ns-put-working-text");
12612 initial_define_lispy_key (Vspecial_event_map
, "ns-unput-working-text",
12613 "ns-unput-working-text");
12614 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12615 current-prefix-arg, as is done in `handle-switch-frame'.
12616 But `handle-switch-frame is not run from the special-map.
12617 Commands from that map are run in a special way that automatically
12618 preserves the prefix-arg. Restoring the prefix arg here is not just
12619 redundant but harmful:
12621 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12622 - after the first prompt, the exit-minibuffer-hook is run which may
12623 iconify a frame and thus push a `iconify-frame' event.
12624 - after running exit-minibuffer-hook, current-prefix-arg is
12625 restored to the non-nil value it had before the prompt.
12626 - we enter the second prompt.
12627 current-prefix-arg is non-nil, prefix-arg is nil.
12628 - before running the first real event, we run the special iconify-frame
12629 event, but we pass the `special' arg to execute-command so
12630 current-prefix-arg and prefix-arg are left untouched.
12631 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12632 - the next key event will have a spuriously non-nil current-prefix-arg. */
12633 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12635 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12637 /* Handling it at such a low-level causes read_key_sequence to get
12638 * confused because it doesn't realize that the current_buffer was
12639 * changed by read_char.
12641 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12642 * "handle-select-window"); */
12643 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12644 "handle-save-session");
12647 /* Define a special event which is raised for dbus callback
12649 initial_define_lispy_key (Vspecial_event_map
, "dbus-event",
12650 "dbus-handle-event");
12653 initial_define_lispy_key (Vspecial_event_map
, "config-changed-event",
12657 /* Mark the pointers in the kboard objects.
12658 Called by the Fgarbage_collector. */
12664 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12666 if (kb
->kbd_macro_buffer
)
12667 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12669 mark_object (kb
->Voverriding_terminal_local_map
);
12670 mark_object (kb
->Vlast_command
);
12671 mark_object (kb
->Vreal_last_command
);
12672 mark_object (kb
->Vkeyboard_translate_table
);
12673 mark_object (kb
->Vlast_repeatable_command
);
12674 mark_object (kb
->Vprefix_arg
);
12675 mark_object (kb
->Vlast_prefix_arg
);
12676 mark_object (kb
->kbd_queue
);
12677 mark_object (kb
->defining_kbd_macro
);
12678 mark_object (kb
->Vlast_kbd_macro
);
12679 mark_object (kb
->Vsystem_key_alist
);
12680 mark_object (kb
->system_key_syms
);
12681 mark_object (kb
->Vwindow_system
);
12682 mark_object (kb
->Vinput_decode_map
);
12683 mark_object (kb
->Vlocal_function_key_map
);
12684 mark_object (kb
->Vdefault_minibuffer_frame
);
12685 mark_object (kb
->echo_string
);
12688 struct input_event
*event
;
12689 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12691 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12692 event
= kbd_buffer
;
12693 if (event
->kind
!= SELECTION_REQUEST_EVENT
12694 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12696 mark_object (event
->x
);
12697 mark_object (event
->y
);
12699 mark_object (event
->frame_or_window
);
12700 mark_object (event
->arg
);
12705 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
12706 (do not change this comment) */