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"
48 #ifdef HAVE_GTK_AND_PTHREAD
55 #include <sys/ioctl.h>
56 #endif /* not MSDOS */
58 #include "syssignal.h"
60 #include <sys/types.h>
69 /* This is to get the definitions of the XK_ symbols. */
76 #endif /* HAVE_NTGUI */
82 /* Variables for blockinput.h: */
84 /* Non-zero if interrupt input is blocked right now. */
85 volatile int interrupt_input_blocked
;
87 /* Nonzero means an input interrupt has arrived
88 during the current critical section. */
89 int interrupt_input_pending
;
91 /* This var should be (interrupt_input_pending || pending_atimers).
92 The QUIT macro checks this instead of interrupt_input_pending and
93 pending_atimers separately, to reduce code size. So, any code that
94 changes interrupt_input_pending or pending_atimers should update
100 #define KBD_BUFFER_SIZE 4096
102 KBOARD
*initial_kboard
;
103 KBOARD
*current_kboard
;
107 /* Non-nil disable property on a command means
108 do not execute it; call disabled-command-function's value instead. */
109 Lisp_Object Qdisabled
, Qdisabled_command_function
;
111 #define NUM_RECENT_KEYS (300)
112 int recent_keys_index
; /* Index for storing next element into recent_keys */
113 int total_keys
; /* Total number of elements stored into recent_keys */
114 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
116 /* Vector holding the key sequence that invoked the current command.
117 It is reused for each command, and it may be longer than the current
118 sequence; this_command_key_count indicates how many elements
119 actually mean something.
120 It's easier to staticpro a single Lisp_Object than an array. */
121 Lisp_Object this_command_keys
;
122 int this_command_key_count
;
124 /* 1 after calling Freset_this_command_lengths.
126 int this_command_key_count_reset
;
128 /* This vector is used as a buffer to record the events that were actually read
129 by read_key_sequence. */
130 Lisp_Object raw_keybuf
;
131 int raw_keybuf_count
;
133 /* Non-nil if the present key sequence was obtained by shift translation. */
134 Lisp_Object Vthis_command_keys_shift_translated
;
136 #define GROW_RAW_KEYBUF \
137 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
138 raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
140 /* Number of elements of this_command_keys
141 that precede this key sequence. */
142 int this_single_command_key_start
;
144 /* Record values of this_command_key_count and echo_length ()
145 before this command was read. */
146 static int before_command_key_count
;
147 static int before_command_echo_length
;
149 extern int minbuf_level
;
151 extern int message_enable_multibyte
;
153 /* If non-nil, the function that implements the display of help.
154 It's called with one argument, the help string to display. */
156 Lisp_Object Vshow_help_function
;
158 /* Nonzero means do menu prompting. */
160 static int menu_prompting
;
162 /* Character to see next line of menu prompt. */
164 static Lisp_Object menu_prompt_more_char
;
166 /* For longjmp to where kbd input is being done. */
168 static jmp_buf getcjmp
;
170 /* True while doing kbd input. */
171 int waiting_for_input
;
173 /* True while displaying for echoing. Delays C-g throwing. */
177 /* Non-null means we can start echoing at the next input pause even
178 though there is something in the echo area. */
180 static struct kboard
*ok_to_echo_at_next_pause
;
182 /* The kboard last echoing, or null for none. Reset to 0 in
183 cancel_echoing. If non-null, and a current echo area message
184 exists, and echo_message_buffer is eq to the current message
185 buffer, we know that the message comes from echo_kboard. */
187 struct kboard
*echo_kboard
;
189 /* The buffer used for echoing. Set in echo_now, reset in
192 Lisp_Object echo_message_buffer
;
194 /* Nonzero means disregard local maps for the menu bar. */
195 static int inhibit_local_menu_bar_menus
;
197 /* Nonzero means C-g should cause immediate error-signal. */
200 /* The user's hook function for outputting an error message. */
201 Lisp_Object Vcommand_error_function
;
203 /* The user's ERASE setting. */
204 Lisp_Object Vtty_erase_char
;
206 /* Character to recognize as the help char. */
207 Lisp_Object Vhelp_char
;
209 /* List of other event types to recognize as meaning "help". */
210 Lisp_Object Vhelp_event_list
;
212 /* Form to execute when help char is typed. */
213 Lisp_Object Vhelp_form
;
215 /* Command to run when the help character follows a prefix key. */
216 Lisp_Object Vprefix_help_command
;
218 /* List of items that should move to the end of the menu bar. */
219 Lisp_Object Vmenu_bar_final_items
;
221 /* Non-nil means show the equivalent key-binding for
222 any M-x command that has one.
223 The value can be a length of time to show the message for.
224 If the value is non-nil and not a number, we wait 2 seconds. */
225 Lisp_Object Vsuggest_key_bindings
;
227 /* How long to display an echo-area message when the minibuffer is active.
228 If the value is not a number, such messages don't time out. */
229 Lisp_Object Vminibuffer_message_timeout
;
231 /* Character that causes a quit. Normally C-g.
233 If we are running on an ordinary terminal, this must be an ordinary
234 ASCII char, since we want to make it our interrupt character.
236 If we are not running on an ordinary terminal, it still needs to be
237 an ordinary ASCII char. This character needs to be recognized in
238 the input interrupt handler. At this point, the keystroke is
239 represented as a struct input_event, while the desired quit
240 character is specified as a lispy event. The mapping from struct
241 input_events to lispy events cannot run in an interrupt handler,
242 and the reverse mapping is difficult for anything but ASCII
245 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
249 /* If non-nil, this is a map that overrides all other local maps. */
250 Lisp_Object Voverriding_local_map
;
252 /* If non-nil, Voverriding_local_map applies to the menu bar. */
253 Lisp_Object Voverriding_local_map_menu_flag
;
255 /* Keymap that defines special misc events that should
256 be processed immediately at a low level. */
257 Lisp_Object Vspecial_event_map
;
259 /* Current depth in recursive edits. */
260 int command_loop_level
;
262 /* Total number of times command_loop has read a key sequence. */
263 EMACS_INT num_input_keys
;
265 /* Last input event read as a command. */
266 Lisp_Object last_command_event
;
268 /* Last input character read as a command, not counting menus
269 reached by the mouse. */
270 Lisp_Object last_nonmenu_event
;
272 /* Last input event read for any purpose. */
273 Lisp_Object last_input_event
;
275 /* If not Qnil, a list of objects to be read as subsequent command input. */
276 Lisp_Object Vunread_command_events
;
278 /* If not Qnil, a list of objects to be read as subsequent command input
279 including input method processing. */
280 Lisp_Object Vunread_input_method_events
;
282 /* If not Qnil, a list of objects to be read as subsequent command input
283 but NOT including input method processing. */
284 Lisp_Object Vunread_post_input_method_events
;
286 /* If not -1, an event to be read as subsequent command input. */
287 EMACS_INT unread_command_char
;
289 /* If not Qnil, this is a switch-frame event which we decided to put
290 off until the end of a key sequence. This should be read as the
291 next command input, after any unread_command_events.
293 read_key_sequence uses this to delay switch-frame events until the
294 end of the key sequence; Fread_char uses it to put off switch-frame
295 events until a non-ASCII event is acceptable as input. */
296 Lisp_Object unread_switch_frame
;
298 /* A mask of extra modifier bits to put into every keyboard char. */
299 EMACS_INT extra_keyboard_modifiers
;
301 /* Char to use as prefix when a meta character is typed in.
302 This is bound on entry to minibuffer in case ESC is changed there. */
304 Lisp_Object meta_prefix_char
;
306 /* Last size recorded for a current buffer which is not a minibuffer. */
307 static int last_non_minibuf_size
;
309 /* Number of idle seconds before an auto-save and garbage collection. */
310 static Lisp_Object Vauto_save_timeout
;
312 /* Total number of times read_char has returned. */
313 int num_input_events
;
315 /* Total number of times read_char has returned, outside of macros. */
316 EMACS_INT num_nonmacro_input_events
;
318 /* Auto-save automatically when this many characters have been typed
319 since the last time. */
321 static EMACS_INT auto_save_interval
;
323 /* Value of num_nonmacro_input_events as of last auto save. */
327 /* The command being executed by the command loop.
328 Commands may set this, and the value set will be copied into
329 current_kboard->Vlast_command instead of the actual command. */
330 Lisp_Object Vthis_command
;
332 /* This is like Vthis_command, except that commands never set it. */
333 Lisp_Object real_this_command
;
335 /* If the lookup of the command returns a binding, the original
336 command is stored in this-original-command. It is nil otherwise. */
337 Lisp_Object Vthis_original_command
;
339 /* The value of point when the last command was started. */
340 int last_point_position
;
342 /* The buffer that was current when the last command was started. */
343 Lisp_Object last_point_position_buffer
;
345 /* The window that was selected when the last command was started. */
346 Lisp_Object last_point_position_window
;
348 /* The frame in which the last input event occurred, or Qmacro if the
349 last event came from a macro. We use this to determine when to
350 generate switch-frame events. This may be cleared by functions
351 like Fselect_frame, to make sure that a switch-frame event is
352 generated by the next character. */
353 Lisp_Object internal_last_event_frame
;
355 /* A user-visible version of the above, intended to allow users to
356 figure out where the last event came from, if the event doesn't
357 carry that information itself (i.e. if it was a character). */
358 Lisp_Object Vlast_event_frame
;
360 /* The timestamp of the last input event we received from the X server.
361 X Windows wants this for selection ownership. */
362 unsigned long last_event_timestamp
;
364 /* If non-nil, active regions automatically become the window selection. */
365 Lisp_Object Vselect_active_regions
;
367 /* The text in the active region prior to modifying the buffer.
368 Used by the `select-active-regions' feature. */
369 Lisp_Object Vsaved_region_selection
;
371 Lisp_Object Qx_set_selection
, QPRIMARY
, Qhandle_switch_frame
;
373 Lisp_Object Qself_insert_command
;
374 Lisp_Object Qforward_char
;
375 Lisp_Object Qbackward_char
;
376 Lisp_Object Qundefined
;
377 Lisp_Object Qtimer_event_handler
;
379 /* read_key_sequence stores here the command definition of the
380 key sequence that it reads. */
381 Lisp_Object read_key_sequence_cmd
;
383 /* Echo unfinished commands after this many seconds of pause. */
384 Lisp_Object Vecho_keystrokes
;
386 /* Form to evaluate (if non-nil) when Emacs is started. */
387 Lisp_Object Vtop_level
;
389 /* If non-nil, this implements the current input method. */
390 Lisp_Object Vinput_method_function
;
391 Lisp_Object Qinput_method_function
;
393 /* When we call Vinput_method_function,
394 this holds the echo area message that was just erased. */
395 Lisp_Object Vinput_method_previous_message
;
397 /* Non-nil means deactivate the mark at end of this command. */
398 Lisp_Object Vdeactivate_mark
;
399 Lisp_Object Qdeactivate_mark
;
401 /* Menu bar specified in Lucid Emacs fashion. */
403 Lisp_Object Vlucid_menu_bar_dirty_flag
;
404 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
406 Lisp_Object Qecho_area_clear_hook
;
408 /* Hooks to run before and after each command. */
409 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
410 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
411 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
413 /* Parent keymap of terminal-local function-key-map instances. */
414 Lisp_Object Vfunction_key_map
;
416 /* Keymap of key translations that can override keymaps. */
417 Lisp_Object Vkey_translation_map
;
419 /* List of deferred actions to be performed at a later time.
420 The precise format isn't relevant here; we just check whether it is nil. */
421 Lisp_Object Vdeferred_action_list
;
423 /* Function to call to handle deferred actions, when there are any. */
424 Lisp_Object Vdeferred_action_function
;
425 Lisp_Object Qdeferred_action_function
;
427 Lisp_Object Qinput_method_exit_on_first_char
;
428 Lisp_Object Qinput_method_use_echo_area
;
430 /* File in which we write all commands we read. */
433 /* Nonzero if input is available. */
436 extern char *pending_malloc_warning
;
438 /* Circular buffer for pre-read keyboard input. */
440 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
442 /* Pointer to next available character in kbd_buffer.
443 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
444 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
445 next available char is in kbd_buffer[0]. */
446 static struct input_event
*kbd_fetch_ptr
;
448 /* Pointer to next place to store character in kbd_buffer. This
449 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
450 character should go in kbd_buffer[0]. */
451 static struct input_event
* volatile kbd_store_ptr
;
453 /* The above pair of variables forms a "queue empty" flag. When we
454 enqueue a non-hook event, we increment kbd_store_ptr. When we
455 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
456 there is input available if the two pointers are not equal.
458 Why not just have a flag set and cleared by the enqueuing and
459 dequeuing functions? Such a flag could be screwed up by interrupts
460 at inopportune times. */
462 /* If this flag is non-nil, we check mouse_moved to see when the
463 mouse moves, and motion events will appear in the input stream.
464 Otherwise, mouse motion is ignored. */
465 Lisp_Object do_mouse_tracking
;
467 /* Symbols to head events. */
468 Lisp_Object Qmouse_movement
;
469 Lisp_Object Qscroll_bar_movement
;
470 Lisp_Object Qswitch_frame
;
471 Lisp_Object Qdelete_frame
;
472 Lisp_Object Qiconify_frame
;
473 Lisp_Object Qmake_frame_visible
;
474 Lisp_Object Qselect_window
;
475 Lisp_Object Qhelp_echo
;
477 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
478 Lisp_Object Qmouse_fixup_help_message
;
481 /* Symbols to denote kinds of events. */
482 Lisp_Object Qfunction_key
;
483 Lisp_Object Qmouse_click
;
484 #if defined (WINDOWSNT)
485 Lisp_Object Qlanguage_change
;
487 Lisp_Object Qdrag_n_drop
;
488 Lisp_Object Qsave_session
;
490 Lisp_Object Qdbus_event
;
492 Lisp_Object Qxwidget_event
;
493 Lisp_Object Qconfig_changed_event
;
495 /* Lisp_Object Qmouse_movement; - also an event header */
497 /* Properties of event headers. */
498 Lisp_Object Qevent_kind
;
499 Lisp_Object Qevent_symbol_elements
;
501 /* menu item parts */
502 Lisp_Object Qmenu_enable
;
503 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
504 Lisp_Object QCbutton
, QCtoggle
, QCradio
, QClabel
;
506 /* An event header symbol HEAD may have a property named
507 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
508 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
509 mask of modifiers applied to it. If present, this is used to help
510 speed up parse_modifiers. */
511 Lisp_Object Qevent_symbol_element_mask
;
513 /* An unmodified event header BASE may have a property named
514 Qmodifier_cache, which is an alist mapping modifier masks onto
515 modified versions of BASE. If present, this helps speed up
517 Lisp_Object Qmodifier_cache
;
519 /* Symbols to use for parts of windows. */
520 Lisp_Object Qmode_line
;
521 Lisp_Object Qvertical_line
;
522 Lisp_Object Qvertical_scroll_bar
;
523 Lisp_Object Qmenu_bar
;
525 Lisp_Object
recursive_edit_unwind (Lisp_Object buffer
), command_loop (void);
526 Lisp_Object
Fthis_command_keys (void);
527 Lisp_Object Qextended_command_history
;
528 EMACS_TIME
timer_check (int do_it_now
);
530 static void record_menu_key (Lisp_Object c
);
531 static int echo_length (void);
533 Lisp_Object Qpolling_period
;
535 /* List of absolute timers. Appears in order of next scheduled event. */
536 Lisp_Object Vtimer_list
;
538 /* List of idle time timers. Appears in order of next scheduled event. */
539 Lisp_Object Vtimer_idle_list
;
541 /* Incremented whenever a timer is run. */
544 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
546 EMACS_TIME
*input_available_clear_time
;
548 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
549 Default is 1 if INTERRUPT_INPUT is defined. */
552 /* Nonzero while interrupts are temporarily deferred during redisplay. */
553 int interrupts_deferred
;
555 /* Allow m- file to inhibit use of FIONREAD. */
556 #ifdef BROKEN_FIONREAD
560 /* We are unable to use interrupts if FIONREAD is not available,
561 so flush SIGIO so we won't try. */
562 #if !defined (FIONREAD)
568 /* If we support a window system, turn on the code to poll periodically
569 to detect C-g. It isn't actually used when doing interrupt input. */
570 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
571 #define POLL_FOR_INPUT
574 /* After a command is executed, if point is moved into a region that
575 has specific properties (e.g. composition, display), we adjust
576 point to the boundary of the region. But, if a command sets this
577 variable to non-nil, we suppress this point adjustment. This
578 variable is set to nil before reading a command. */
580 Lisp_Object Vdisable_point_adjustment
;
582 /* If non-nil, always disable point adjustment. */
584 Lisp_Object Vglobal_disable_point_adjustment
;
586 /* The time when Emacs started being idle. */
588 static EMACS_TIME timer_idleness_start_time
;
590 /* After Emacs stops being idle, this saves the last value
591 of timer_idleness_start_time from when it was idle. */
593 static EMACS_TIME timer_last_idleness_start_time
;
595 /* If non-nil, events produced by disabled menu items and tool-bar
596 buttons are not ignored. Help functions bind this to allow help on
597 those items and buttons. */
598 Lisp_Object Venable_disabled_menus_and_buttons
;
601 /* Global variable declarations. */
603 /* Flags for readable_events. */
604 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
605 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
606 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
608 /* Function for init_keyboard to call with no args (if nonzero). */
609 void (*keyboard_init_hook
) (void);
611 static int read_avail_input (int);
612 static void get_input_pending (int *, int);
613 static int readable_events (int);
614 static Lisp_Object
read_char_x_menu_prompt (int, Lisp_Object
*,
616 static Lisp_Object
read_char_minibuf_menu_prompt (int, int,
618 static Lisp_Object
make_lispy_event (struct input_event
*);
619 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
620 static Lisp_Object
make_lispy_movement (struct frame
*, Lisp_Object
,
621 enum scroll_bar_part
,
622 Lisp_Object
, Lisp_Object
,
625 static Lisp_Object
modify_event_symbol (int, unsigned, Lisp_Object
,
626 Lisp_Object
, const char **,
627 Lisp_Object
*, unsigned);
628 static Lisp_Object
make_lispy_switch_frame (Lisp_Object
);
629 static void save_getcjmp (jmp_buf);
630 static void restore_getcjmp (jmp_buf);
631 static Lisp_Object
apply_modifiers (int, Lisp_Object
);
632 static void clear_event (struct input_event
*);
633 static Lisp_Object
restore_kboard_configuration (Lisp_Object
);
634 static SIGTYPE
interrupt_signal (int signalnum
);
636 static SIGTYPE
input_available_signal (int signo
);
638 static void handle_interrupt (void);
639 static void timer_start_idle (void);
640 static void timer_stop_idle (void);
641 static void timer_resume_idle (void);
642 static SIGTYPE
handle_user_signal (int);
643 static char *find_user_signal_name (int);
644 static int store_user_signal_events (void);
646 /* Nonzero means don't try to suspend even if the operating system seems
648 static int cannot_suspend
;
651 /* Install the string STR as the beginning of the string of echoing,
652 so that it serves as a prompt for the next character.
653 Also start echoing. */
656 echo_prompt (Lisp_Object str
)
658 current_kboard
->echo_string
= str
;
659 current_kboard
->echo_after_prompt
= SCHARS (str
);
663 /* Add C to the echo string, if echoing is going on.
664 C can be a character, which is printed prettily ("M-C-x" and all that
665 jazz), or a symbol, whose name is printed. */
668 echo_char (Lisp_Object c
)
670 if (current_kboard
->immediate_echo
)
672 int size
= KEY_DESCRIPTION_SIZE
+ 100;
673 char *buffer
= (char *) alloca (size
);
675 Lisp_Object echo_string
;
677 echo_string
= current_kboard
->echo_string
;
679 /* If someone has passed us a composite event, use its head symbol. */
684 ptr
= push_key_description (XINT (c
), ptr
, 1);
686 else if (SYMBOLP (c
))
688 Lisp_Object name
= SYMBOL_NAME (c
);
689 int nbytes
= SBYTES (name
);
691 if (size
- (ptr
- buffer
) < nbytes
)
693 int offset
= ptr
- buffer
;
694 size
= max (2 * size
, size
+ nbytes
);
695 buffer
= (char *) alloca (size
);
696 ptr
= buffer
+ offset
;
699 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
700 STRING_MULTIBYTE (name
), 1);
703 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
706 const char *text
= " (Type ? for further options)";
707 int len
= strlen (text
);
709 if (size
- (ptr
- buffer
) < len
)
711 int offset
= ptr
- buffer
;
713 buffer
= (char *) alloca (size
);
714 ptr
= buffer
+ offset
;
717 memcpy (ptr
, text
, len
);
721 /* Replace a dash from echo_dash with a space, otherwise
722 add a space at the end as a separator between keys. */
723 if (STRINGP (echo_string
)
724 && SCHARS (echo_string
) > 1)
726 Lisp_Object last_char
, prev_char
, idx
;
728 idx
= make_number (SCHARS (echo_string
) - 2);
729 prev_char
= Faref (echo_string
, idx
);
731 idx
= make_number (SCHARS (echo_string
) - 1);
732 last_char
= Faref (echo_string
, idx
);
734 /* We test PREV_CHAR to make sure this isn't the echoing
736 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
737 Faset (echo_string
, idx
, make_number (' '));
739 echo_string
= concat2 (echo_string
, build_string (" "));
741 else if (STRINGP (echo_string
))
742 echo_string
= concat2 (echo_string
, build_string (" "));
744 current_kboard
->echo_string
745 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
751 /* Temporarily add a dash to the end of the echo string if it's not
752 empty, so that it serves as a mini-prompt for the very next character. */
757 /* Do nothing if not echoing at all. */
758 if (NILP (current_kboard
->echo_string
))
761 if (!current_kboard
->immediate_echo
762 && SCHARS (current_kboard
->echo_string
) == 0)
765 /* Do nothing if we just printed a prompt. */
766 if (current_kboard
->echo_after_prompt
767 == SCHARS (current_kboard
->echo_string
))
770 /* Do nothing if we have already put a dash at the end. */
771 if (SCHARS (current_kboard
->echo_string
) > 1)
773 Lisp_Object last_char
, prev_char
, idx
;
775 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
776 prev_char
= Faref (current_kboard
->echo_string
, idx
);
778 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
779 last_char
= Faref (current_kboard
->echo_string
, idx
);
781 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
785 /* Put a dash at the end of the buffer temporarily,
786 but make it go away when the next character is added. */
787 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
792 /* Display the current echo string, and begin echoing if not already
798 if (!current_kboard
->immediate_echo
)
801 current_kboard
->immediate_echo
= 1;
803 for (i
= 0; i
< this_command_key_count
; i
++)
807 /* Set before_command_echo_length to the value that would
808 have been saved before the start of this subcommand in
809 command_loop_1, if we had already been echoing then. */
810 if (i
== this_single_command_key_start
)
811 before_command_echo_length
= echo_length ();
813 c
= XVECTOR (this_command_keys
)->contents
[i
];
814 if (! (EVENT_HAS_PARAMETERS (c
)
815 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
819 /* Set before_command_echo_length to the value that would
820 have been saved before the start of this subcommand in
821 command_loop_1, if we had already been echoing then. */
822 if (this_command_key_count
== this_single_command_key_start
)
823 before_command_echo_length
= echo_length ();
825 /* Put a dash at the end to invite the user to type more. */
830 message3_nolog (current_kboard
->echo_string
,
831 SBYTES (current_kboard
->echo_string
),
832 STRING_MULTIBYTE (current_kboard
->echo_string
));
835 /* Record in what buffer we echoed, and from which kboard. */
836 echo_message_buffer
= echo_area_buffer
[0];
837 echo_kboard
= current_kboard
;
839 if (waiting_for_input
&& !NILP (Vquit_flag
))
840 quit_throw_to_read_char ();
843 /* Turn off echoing, for the start of a new command. */
846 cancel_echoing (void)
848 current_kboard
->immediate_echo
= 0;
849 current_kboard
->echo_after_prompt
= -1;
850 current_kboard
->echo_string
= Qnil
;
851 ok_to_echo_at_next_pause
= NULL
;
853 echo_message_buffer
= Qnil
;
856 /* Return the length of the current echo string. */
861 return (STRINGP (current_kboard
->echo_string
)
862 ? SCHARS (current_kboard
->echo_string
)
866 /* Truncate the current echo message to its first LEN chars.
867 This and echo_char get used by read_key_sequence when the user
868 switches frames while entering a key sequence. */
871 echo_truncate (int nchars
)
873 if (STRINGP (current_kboard
->echo_string
))
874 current_kboard
->echo_string
875 = Fsubstring (current_kboard
->echo_string
,
876 make_number (0), make_number (nchars
));
877 truncate_echo_area (nchars
);
881 /* Functions for manipulating this_command_keys. */
883 add_command_key (Lisp_Object key
)
885 #if 0 /* Not needed after we made Freset_this_command_lengths
886 do the job immediately. */
887 /* If reset-this-command-length was called recently, obey it now.
888 See the doc string of that function for an explanation of why. */
889 if (before_command_restore_flag
)
891 this_command_key_count
= before_command_key_count_1
;
892 if (this_command_key_count
< this_single_command_key_start
)
893 this_single_command_key_start
= this_command_key_count
;
894 echo_truncate (before_command_echo_length_1
);
895 before_command_restore_flag
= 0;
899 if (this_command_key_count
>= ASIZE (this_command_keys
))
900 this_command_keys
= larger_vector (this_command_keys
,
901 2 * ASIZE (this_command_keys
),
904 ASET (this_command_keys
, this_command_key_count
, key
);
905 ++this_command_key_count
;
910 recursive_edit_1 (void)
912 int count
= SPECPDL_INDEX ();
915 if (command_loop_level
> 0)
917 specbind (Qstandard_output
, Qt
);
918 specbind (Qstandard_input
, Qt
);
921 #ifdef HAVE_WINDOW_SYSTEM
922 /* The command loop has started an hourglass timer, so we have to
923 cancel it here, otherwise it will fire because the recursive edit
924 can take some time. Do not check for display_hourglass_p here,
925 because it could already be nil. */
929 /* This function may have been called from a debugger called from
930 within redisplay, for instance by Edebugging a function called
931 from fontification-functions. We want to allow redisplay in
932 the debugging session.
934 The recursive edit is left with a `(throw exit ...)'. The `exit'
935 tag is not caught anywhere in redisplay, i.e. when we leave the
936 recursive edit, the original redisplay leading to the recursive
937 edit will be unwound. The outcome should therefore be safe. */
938 specbind (Qinhibit_redisplay
, Qnil
);
941 val
= command_loop ();
943 Fsignal (Qquit
, Qnil
);
944 /* Handle throw from read_minibuf when using minibuffer
945 while it's active but we're in another window. */
947 xsignal1 (Qerror
, val
);
949 return unbind_to (count
, Qnil
);
952 /* When an auto-save happens, record the "time", and don't do again soon. */
955 record_auto_save (void)
957 last_auto_save
= num_nonmacro_input_events
;
960 /* Make an auto save happen as soon as possible at command level. */
963 force_auto_save_soon (void)
965 last_auto_save
= - auto_save_interval
- 1;
967 record_asynch_buffer_change ();
970 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
971 doc
: /* Invoke the editor command loop recursively.
972 To get out of the recursive edit, a command can do `(throw 'exit nil)';
973 that tells this function to return.
974 Alternatively, `(throw 'exit t)' makes this function signal an error.
975 This function is called by the editor initialization to begin editing. */)
978 int count
= SPECPDL_INDEX ();
981 /* If we enter while input is blocked, don't lock up here.
982 This may happen through the debugger during redisplay. */
986 command_loop_level
++;
987 update_mode_lines
= 1;
989 if (command_loop_level
990 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
991 buffer
= Fcurrent_buffer ();
995 /* If we leave recursive_edit_1 below with a `throw' for instance,
996 like it is done in the splash screen display, we have to
997 make sure that we restore single_kboard as command_loop_1
998 would have done if it were left normally. */
999 if (command_loop_level
> 0)
1000 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
1001 record_unwind_protect (recursive_edit_unwind
, buffer
);
1003 recursive_edit_1 ();
1004 return unbind_to (count
, Qnil
);
1008 recursive_edit_unwind (Lisp_Object buffer
)
1010 if (BUFFERP (buffer
))
1011 Fset_buffer (buffer
);
1013 command_loop_level
--;
1014 update_mode_lines
= 1;
1019 #if 0 /* These two functions are now replaced with
1020 temporarily_switch_to_single_kboard. */
1024 #if 0 /* Theory: if there's anything in Vunread_command_events,
1025 it will right away be read by read_key_sequence,
1026 and then if we do switch KBOARDS, it will go into the side
1027 queue then. So we don't need to do anything special here -- rms. */
1028 if (CONSP (Vunread_command_events
))
1030 current_kboard
->kbd_queue
1031 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1032 current_kboard
->kbd_queue_has_data
= 1;
1034 Vunread_command_events
= Qnil
;
1039 /* Switch to the single-kboard state, making current_kboard
1040 the only KBOARD from which further input is accepted. */
1043 single_kboard_state ()
1049 /* If we're in single_kboard state for kboard KBOARD,
1053 not_single_kboard_state (KBOARD
*kboard
)
1055 if (kboard
== current_kboard
)
1059 /* Maintain a stack of kboards, so other parts of Emacs
1060 can switch temporarily to the kboard of a given frame
1061 and then revert to the previous status. */
1066 struct kboard_stack
*next
;
1069 static struct kboard_stack
*kboard_stack
;
1072 push_kboard (struct kboard
*k
)
1074 struct kboard_stack
*p
1075 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1077 p
->next
= kboard_stack
;
1078 p
->kboard
= current_kboard
;
1088 struct kboard_stack
*p
= kboard_stack
;
1090 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
1092 if (t
->kboard
== p
->kboard
)
1094 current_kboard
= p
->kboard
;
1101 /* The terminal we remembered has been deleted. */
1102 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
1105 kboard_stack
= p
->next
;
1109 /* Switch to single_kboard mode, making current_kboard the only KBOARD
1110 from which further input is accepted. If F is non-nil, set its
1111 KBOARD as the current keyboard.
1113 This function uses record_unwind_protect to return to the previous
1116 If Emacs is already in single_kboard mode, and F's keyboard is
1117 locked, then this function will throw an errow. */
1120 temporarily_switch_to_single_kboard (struct frame
*f
)
1122 int was_locked
= single_kboard
;
1125 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
1126 /* We can not switch keyboards while in single_kboard mode.
1127 In rare cases, Lisp code may call `recursive-edit' (or
1128 `read-minibuffer' or `y-or-n-p') after it switched to a
1129 locked frame. For example, this is likely to happen
1130 when server.el connects to a new terminal while Emacs is in
1131 single_kboard mode. It is best to throw an error instead
1132 of presenting the user with a frozen screen. */
1133 error ("Terminal %d is locked, cannot read from it",
1134 FRAME_TERMINAL (f
)->id
);
1136 /* This call is unnecessary, but helps
1137 `restore_kboard_configuration' discover if somebody changed
1138 `current_kboard' behind our back. */
1139 push_kboard (current_kboard
);
1142 current_kboard
= FRAME_KBOARD (f
);
1144 record_unwind_protect (restore_kboard_configuration
,
1145 (was_locked
? Qt
: Qnil
));
1148 #if 0 /* This function is not needed anymore. */
1150 record_single_kboard_state ()
1153 push_kboard (current_kboard
);
1154 record_unwind_protect (restore_kboard_configuration
,
1155 (single_kboard
? Qt
: Qnil
));
1160 restore_kboard_configuration (Lisp_Object was_locked
)
1162 if (NILP (was_locked
))
1166 struct kboard
*prev
= current_kboard
;
1169 /* The pop should not change the kboard. */
1170 if (single_kboard
&& current_kboard
!= prev
)
1177 /* Handle errors that are not handled at inner levels
1178 by printing an error message and returning to the editor command loop. */
1181 cmd_error (Lisp_Object data
)
1183 Lisp_Object old_level
, old_length
;
1184 char macroerror
[50];
1186 #ifdef HAVE_WINDOW_SYSTEM
1187 if (display_hourglass_p
)
1188 cancel_hourglass ();
1191 if (!NILP (executing_kbd_macro
))
1193 if (executing_kbd_macro_iterations
== 1)
1194 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1196 sprintf (macroerror
, "After %d kbd macro iterations: ",
1197 executing_kbd_macro_iterations
);
1202 Vstandard_output
= Qt
;
1203 Vstandard_input
= Qt
;
1204 Vexecuting_kbd_macro
= Qnil
;
1205 executing_kbd_macro
= Qnil
;
1206 current_kboard
->Vprefix_arg
= Qnil
;
1207 current_kboard
->Vlast_prefix_arg
= Qnil
;
1210 /* Avoid unquittable loop if data contains a circular list. */
1211 old_level
= Vprint_level
;
1212 old_length
= Vprint_length
;
1213 XSETFASTINT (Vprint_level
, 10);
1214 XSETFASTINT (Vprint_length
, 10);
1215 cmd_error_internal (data
, macroerror
);
1216 Vprint_level
= old_level
;
1217 Vprint_length
= old_length
;
1221 Vinhibit_quit
= Qnil
;
1222 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1223 if (command_loop_level
== 0 && minibuf_level
== 0)
1224 any_kboard_state ();
1227 return make_number (0);
1230 /* Take actions on handling an error. DATA is the data that describes
1233 CONTEXT is a C-string containing ASCII characters only which
1234 describes the context in which the error happened. If we need to
1235 generalize CONTEXT to allow multibyte characters, make it a Lisp
1239 cmd_error_internal (Lisp_Object data
, const char *context
)
1241 struct frame
*sf
= SELECTED_FRAME ();
1243 /* The immediate context is not interesting for Quits,
1244 since they are asyncronous. */
1245 if (EQ (XCAR (data
), Qquit
))
1246 Vsignaling_function
= Qnil
;
1251 /* Use user's specified output function if any. */
1252 if (!NILP (Vcommand_error_function
))
1253 call3 (Vcommand_error_function
, data
,
1254 context
? build_string (context
) : empty_unibyte_string
,
1255 Vsignaling_function
);
1256 /* If the window system or terminal frame hasn't been initialized
1257 yet, or we're not interactive, write the message to stderr and exit. */
1258 else if (!sf
->glyphs_initialized_p
1259 /* The initial frame is a special non-displaying frame. It
1260 will be current in daemon mode when there are no frames
1261 to display, and in non-daemon mode before the real frame
1262 has finished initializing. If an error is thrown in the
1263 latter case while creating the frame, then the frame
1264 will never be displayed, so the safest thing to do is
1265 write to stderr and quit. In daemon mode, there are
1266 many other potential errors that do not prevent frames
1267 from being created, so continuing as normal is better in
1269 || (!IS_DAEMON
&& FRAME_INITIAL_P (sf
))
1272 print_error_message (data
, Qexternal_debugging_output
,
1273 context
, Vsignaling_function
);
1274 Fterpri (Qexternal_debugging_output
);
1275 Fkill_emacs (make_number (-1));
1279 clear_message (1, 0);
1281 message_log_maybe_newline ();
1284 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1287 Vsignaling_function
= Qnil
;
1290 Lisp_Object
command_loop_1 (void);
1291 Lisp_Object
command_loop_2 (Lisp_Object
);
1292 Lisp_Object
top_level_1 (Lisp_Object
);
1294 /* Entry to editor-command-loop.
1295 This level has the catches for exiting/returning to editor command loop.
1296 It returns nil to exit recursive edit, t to abort it. */
1301 if (command_loop_level
> 0 || minibuf_level
> 0)
1304 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1305 executing_kbd_macro
= Qnil
;
1311 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1312 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1313 /* Reset single_kboard in case top-level set it while
1314 evaluating an -f option, or we are stuck there for some
1316 any_kboard_state ();
1318 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1319 executing_kbd_macro
= Qnil
;
1321 /* End of file in -batch run causes exit here. */
1327 /* Here we catch errors in execution of commands within the
1328 editing loop, and reenter the editing loop.
1329 When there is an error, cmd_error runs and returns a non-nil
1330 value to us. A value of nil means that command_loop_1 itself
1331 returned due to end of file (or end of kbd macro). */
1334 command_loop_2 (Lisp_Object ignore
)
1336 register Lisp_Object val
;
1339 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1340 while (!NILP (val
));
1348 return Feval (Vtop_level
);
1352 top_level_1 (Lisp_Object ignore
)
1354 /* On entry to the outer level, run the startup file */
1355 if (!NILP (Vtop_level
))
1356 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1357 else if (!NILP (Vpurify_flag
))
1358 message ("Bare impure Emacs (standard Lisp code not loaded)");
1360 message ("Bare Emacs (standard Lisp code not loaded)");
1364 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1365 doc
: /* Exit all recursive editing levels.
1366 This also exits all active minibuffers. */)
1369 #ifdef HAVE_WINDOW_SYSTEM
1370 if (display_hourglass_p
)
1371 cancel_hourglass ();
1374 /* Unblock input if we enter with input blocked. This may happen if
1375 redisplay traps e.g. during tool-bar update with input blocked. */
1376 while (INPUT_BLOCKED_P
)
1379 Fthrow (Qtop_level
, Qnil
);
1382 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1383 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1386 if (command_loop_level
> 0 || minibuf_level
> 0)
1387 Fthrow (Qexit
, Qnil
);
1389 error ("No recursive edit is in progress");
1392 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1393 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1396 if (command_loop_level
> 0 || minibuf_level
> 0)
1399 error ("No recursive edit is in progress");
1402 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1404 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1405 of this function. */
1408 tracking_off (Lisp_Object old_value
)
1410 do_mouse_tracking
= old_value
;
1411 if (NILP (old_value
))
1413 /* Redisplay may have been preempted because there was input
1414 available, and it assumes it will be called again after the
1415 input has been processed. If the only input available was
1416 the sort that we have just disabled, then we need to call
1418 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1420 redisplay_preserve_echo_area (6);
1421 get_input_pending (&input_pending
,
1422 READABLE_EVENTS_DO_TIMERS_NOW
);
1428 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1429 doc
: /* Evaluate BODY with mouse movement events enabled.
1430 Within a `track-mouse' form, mouse motion generates input events that
1431 you can read with `read-event'.
1432 Normally, mouse motion is ignored.
1433 usage: (track-mouse BODY...) */)
1436 int count
= SPECPDL_INDEX ();
1439 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1441 do_mouse_tracking
= Qt
;
1443 val
= Fprogn (args
);
1444 return unbind_to (count
, val
);
1447 /* If mouse has moved on some frame, return one of those frames.
1451 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1452 after resizing the tool-bar window. */
1454 int ignore_mouse_drag_p
;
1457 some_mouse_moved (void)
1459 Lisp_Object tail
, frame
;
1461 if (ignore_mouse_drag_p
)
1463 /* ignore_mouse_drag_p = 0; */
1467 FOR_EACH_FRAME (tail
, frame
)
1469 if (XFRAME (frame
)->mouse_moved
)
1470 return XFRAME (frame
);
1476 #endif /* HAVE_MOUSE || HAVE_GPM */
1478 /* This is the actual command reading loop,
1479 sans error-handling encapsulation. */
1481 static int read_key_sequence (Lisp_Object
*, int, Lisp_Object
,
1483 void safe_run_hooks (Lisp_Object
);
1484 static void adjust_point_for_property (int, int);
1486 /* Cancel hourglass from protect_unwind.
1488 #ifdef HAVE_WINDOW_SYSTEM
1490 cancel_hourglass_unwind (Lisp_Object arg
)
1492 cancel_hourglass ();
1498 command_loop_1 (void)
1501 Lisp_Object keybuf
[30];
1503 int prev_modiff
= 0;
1504 struct buffer
*prev_buffer
= NULL
;
1505 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1506 int was_locked
= single_kboard
;
1508 int already_adjusted
= 0;
1510 current_kboard
->Vprefix_arg
= Qnil
;
1511 current_kboard
->Vlast_prefix_arg
= Qnil
;
1512 Vdeactivate_mark
= Qnil
;
1513 waiting_for_input
= 0;
1516 this_command_key_count
= 0;
1517 this_command_key_count_reset
= 0;
1518 this_single_command_key_start
= 0;
1520 if (NILP (Vmemory_full
))
1522 /* Make sure this hook runs after commands that get errors and
1523 throw to top level. */
1524 /* Note that the value cell will never directly contain nil
1525 if the symbol is a local variable. */
1526 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1527 safe_run_hooks (Qpost_command_hook
);
1529 /* If displaying a message, resize the echo area window to fit
1530 that message's size exactly. */
1531 if (!NILP (echo_area_buffer
[0]))
1532 resize_echo_area_exactly ();
1534 if (!NILP (Vdeferred_action_list
))
1535 safe_run_hooks (Qdeferred_action_function
);
1538 /* Do this after running Vpost_command_hook, for consistency. */
1539 current_kboard
->Vlast_command
= Vthis_command
;
1540 current_kboard
->Vreal_last_command
= real_this_command
;
1541 if (!CONSP (last_command_event
))
1542 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1546 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1549 /* Make sure the current window's buffer is selected. */
1550 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1551 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1553 /* Display any malloc warning that just came out. Use while because
1554 displaying one warning can cause another. */
1556 while (pending_malloc_warning
)
1557 display_malloc_warning ();
1559 Vdeactivate_mark
= Qnil
;
1561 /* If minibuffer on and echo area in use,
1562 wait a short time and redraw minibuffer. */
1565 && !NILP (echo_area_buffer
[0])
1566 && EQ (minibuf_window
, echo_area_window
)
1567 && NUMBERP (Vminibuffer_message_timeout
))
1569 /* Bind inhibit-quit to t so that C-g gets read in
1570 rather than quitting back to the minibuffer. */
1571 int count
= SPECPDL_INDEX ();
1572 specbind (Qinhibit_quit
, Qt
);
1574 sit_for (Vminibuffer_message_timeout
, 0, 2);
1576 /* Clear the echo area. */
1578 safe_run_hooks (Qecho_area_clear_hook
);
1580 unbind_to (count
, Qnil
);
1582 /* If a C-g came in before, treat it as input now. */
1583 if (!NILP (Vquit_flag
))
1586 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1591 /* Select the frame that the last event came from. Usually,
1592 switch-frame events will take care of this, but if some lisp
1593 code swallows a switch-frame event, we'll fix things up here.
1594 Is this a good idea? */
1595 if (FRAMEP (internal_last_event_frame
)
1596 && !EQ (internal_last_event_frame
, selected_frame
))
1597 Fselect_frame (internal_last_event_frame
, Qnil
);
1599 /* If it has changed current-menubar from previous value,
1600 really recompute the menubar from the value. */
1601 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1602 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1603 call0 (Qrecompute_lucid_menubar
);
1605 before_command_key_count
= this_command_key_count
;
1606 before_command_echo_length
= echo_length ();
1608 Vthis_command
= Qnil
;
1609 real_this_command
= Qnil
;
1610 Vthis_original_command
= Qnil
;
1611 Vthis_command_keys_shift_translated
= Qnil
;
1613 /* Read next key sequence; i gets its length. */
1614 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1617 /* A filter may have run while we were reading the input. */
1618 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1620 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1621 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1625 /* Now we have read a key sequence of length I,
1626 or else I is 0 and we found end of file. */
1628 if (i
== 0) /* End of file -- happens only in */
1629 return Qnil
; /* a kbd macro, at the end. */
1630 /* -1 means read_key_sequence got a menu that was rejected.
1631 Just loop around and read another command. */
1635 this_command_key_count
= 0;
1636 this_command_key_count_reset
= 0;
1637 this_single_command_key_start
= 0;
1641 last_command_event
= keybuf
[i
- 1];
1643 /* If the previous command tried to force a specific window-start,
1644 forget about that, in case this command moves point far away
1645 from that position. But also throw away beg_unchanged and
1646 end_unchanged information in that case, so that redisplay will
1647 update the whole window properly. */
1648 if (!NILP (XWINDOW (selected_window
)->force_start
))
1651 XWINDOW (selected_window
)->force_start
= Qnil
;
1652 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1653 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1656 cmd
= read_key_sequence_cmd
;
1657 if (!NILP (Vexecuting_kbd_macro
))
1659 if (!NILP (Vquit_flag
))
1661 Vexecuting_kbd_macro
= Qt
;
1662 QUIT
; /* Make some noise. */
1663 /* Will return since macro now empty. */
1667 /* Do redisplay processing after this command except in special
1668 cases identified below. */
1669 prev_buffer
= current_buffer
;
1670 prev_modiff
= MODIFF
;
1671 last_point_position
= PT
;
1672 last_point_position_window
= selected_window
;
1673 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1675 /* By default, we adjust point to a boundary of a region that
1676 has such a property that should be treated intangible
1677 (e.g. composition, display). But, some commands will set
1678 this variable differently. */
1679 Vdisable_point_adjustment
= Qnil
;
1681 /* Process filters and timers may have messed with deactivate-mark.
1682 reset it before we execute the command. */
1683 Vdeactivate_mark
= Qnil
;
1685 /* Remap command through active keymaps */
1686 Vthis_original_command
= cmd
;
1690 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1694 /* Execute the command. */
1696 Vthis_command
= cmd
;
1697 real_this_command
= cmd
;
1698 /* Note that the value cell will never directly contain nil
1699 if the symbol is a local variable. */
1700 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1701 safe_run_hooks (Qpre_command_hook
);
1703 already_adjusted
= 0;
1705 if (NILP (Vthis_command
))
1707 /* nil means key is undefined. */
1708 Lisp_Object keys
= Fvector (i
, keybuf
);
1709 keys
= Fkey_description (keys
, Qnil
);
1711 message_with_string ("%s is undefined", keys
, 0);
1712 current_kboard
->defining_kbd_macro
= Qnil
;
1713 update_mode_lines
= 1;
1714 current_kboard
->Vprefix_arg
= Qnil
;
1718 /* Here for a command that isn't executed directly */
1720 #ifdef HAVE_WINDOW_SYSTEM
1721 int scount
= SPECPDL_INDEX ();
1723 if (display_hourglass_p
1724 && NILP (Vexecuting_kbd_macro
))
1726 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1731 if (NILP (current_kboard
->Vprefix_arg
)) /* FIXME: Why? --Stef */
1733 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1735 #ifdef HAVE_WINDOW_SYSTEM
1736 /* Do not check display_hourglass_p here, because
1737 Fcommand_execute could change it, but we should cancel
1738 hourglass cursor anyway.
1739 But don't cancel the hourglass within a macro
1740 just because a command in the macro finishes. */
1741 if (NILP (Vexecuting_kbd_macro
))
1742 unbind_to (scount
, Qnil
);
1745 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1747 /* Note that the value cell will never directly contain nil
1748 if the symbol is a local variable. */
1749 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1750 safe_run_hooks (Qpost_command_hook
);
1752 /* If displaying a message, resize the echo area window to fit
1753 that message's size exactly. */
1754 if (!NILP (echo_area_buffer
[0]))
1755 resize_echo_area_exactly ();
1757 if (!NILP (Vdeferred_action_list
))
1758 safe_run_hooks (Qdeferred_action_function
);
1760 /* If there is a prefix argument,
1761 1) We don't want Vlast_command to be ``universal-argument''
1762 (that would be dumb), so don't set Vlast_command,
1763 2) we want to leave echoing on so that the prefix will be
1764 echoed as part of this key sequence, so don't call
1766 3) we want to leave this_command_key_count non-zero, so that
1767 read_char will realize that it is re-reading a character, and
1768 not echo it a second time.
1770 If the command didn't actually create a prefix arg,
1771 but is merely a frame event that is transparent to prefix args,
1772 then the above doesn't apply. */
1773 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_event
))
1775 current_kboard
->Vlast_command
= Vthis_command
;
1776 current_kboard
->Vreal_last_command
= real_this_command
;
1777 if (!CONSP (last_command_event
))
1778 current_kboard
->Vlast_repeatable_command
= real_this_command
;
1780 this_command_key_count
= 0;
1781 this_command_key_count_reset
= 0;
1782 this_single_command_key_start
= 0;
1785 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1787 /* In Emacs 22, setting transient-mark-mode to `only' was a
1788 way of turning it on for just one command. This usage is
1789 obsolete, but support it anyway. */
1790 if (EQ (Vtransient_mark_mode
, Qidentity
))
1791 Vtransient_mark_mode
= Qnil
;
1792 else if (EQ (Vtransient_mark_mode
, Qonly
))
1793 Vtransient_mark_mode
= Qidentity
;
1795 if (!NILP (Vdeactivate_mark
))
1796 /* If `select-active-regions' is non-nil, this call to
1797 `deactivate-mark' also sets the PRIMARY selection. */
1798 call0 (Qdeactivate_mark
);
1801 /* Even if not deactivating the mark, set PRIMARY if
1802 `select-active-regions' is non-nil. */
1803 if ((EQ (Vselect_active_regions
, Qonly
)
1804 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1805 : (!NILP (Vselect_active_regions
)
1806 && !NILP (Vtransient_mark_mode
)))
1807 && !EQ (Vthis_command
, Qhandle_switch_frame
))
1809 int beg
= XINT (Fmarker_position (current_buffer
->mark
));
1810 int end
= XINT (make_number (PT
));
1812 call2 (Qx_set_selection
, QPRIMARY
,
1813 make_buffer_string (beg
, end
, 0));
1815 call2 (Qx_set_selection
, QPRIMARY
,
1816 make_buffer_string (end
, beg
, 0));
1817 /* Don't set empty selections. */
1820 if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1821 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1824 Vsaved_region_selection
= Qnil
;
1829 if (current_buffer
== prev_buffer
1830 && last_point_position
!= PT
1831 && NILP (Vdisable_point_adjustment
)
1832 && NILP (Vglobal_disable_point_adjustment
))
1834 if (last_point_position
> BEGV
1835 && last_point_position
< ZV
1836 && (composition_adjust_point (last_point_position
,
1837 last_point_position
)
1838 != last_point_position
))
1839 /* The last point was temporarily set within a grapheme
1840 cluster to prevent automatic composition. To recover
1841 the automatic composition, we must update the
1843 windows_or_buffers_changed
++;
1844 if (!already_adjusted
)
1845 adjust_point_for_property (last_point_position
,
1846 MODIFF
!= prev_modiff
);
1849 /* Install chars successfully executed in kbd macro. */
1851 if (!NILP (current_kboard
->defining_kbd_macro
)
1852 && NILP (current_kboard
->Vprefix_arg
))
1853 finalize_kbd_macro_chars ();
1854 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1856 any_kboard_state ();
1861 /* Adjust point to a boundary of a region that has such a property
1862 that should be treated intangible. For the moment, we check
1863 `composition', `display' and `invisible' properties.
1864 LAST_PT is the last position of point. */
1867 adjust_point_for_property (int last_pt
, int modified
)
1870 Lisp_Object val
, overlay
, tmp
;
1871 /* When called after buffer modification, we should temporarily
1872 suppress the point adjustment for automatic composition so that a
1873 user can keep inserting another character at point or keep
1874 deleting characters around point. */
1875 int check_composition
= ! modified
, check_display
= 1, check_invisible
= 1;
1878 /* FIXME: cycling is probably not necessary because these properties
1879 can't be usefully combined anyway. */
1880 while (check_composition
|| check_display
|| check_invisible
)
1882 /* FIXME: check `intangible'. */
1883 if (check_composition
1884 && PT
> BEGV
&& PT
< ZV
1885 && (beg
= composition_adjust_point (last_pt
, PT
)) != PT
)
1888 check_display
= check_invisible
= 1;
1890 check_composition
= 0;
1892 && PT
> BEGV
&& PT
< ZV
1893 && !NILP (val
= get_char_property_and_overlay
1894 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1895 && display_prop_intangible_p (val
)
1896 && (!OVERLAYP (overlay
)
1897 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1898 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1899 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1900 && (beg
< PT
/* && end > PT <- It's always the case. */
1901 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
1904 SET_PT (PT
< last_pt
1905 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
1907 check_composition
= check_invisible
= 1;
1910 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1912 int inv
, ellipsis
= 0;
1915 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1918 /* FIXME: We should stop if we find a spot between
1919 two runs of `invisible' where inserted text would
1920 be visible. This is important when we have two
1921 invisible boundaries that enclose an area: if the
1922 area is empty, we need this test in order to make
1923 it possible to place point in the middle rather
1924 than skip both boundaries. However, this code
1925 also stops anywhere in a non-sticky text-property,
1926 which breaks (e.g.) Org mode. */
1927 && (val
= get_pos_property (make_number (end
),
1929 TEXT_PROP_MEANS_INVISIBLE (val
))
1931 && !NILP (val
= get_char_property_and_overlay
1932 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1933 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1935 ellipsis
= ellipsis
|| inv
> 1
1936 || (OVERLAYP (overlay
)
1937 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1938 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1939 tmp
= Fnext_single_char_property_change
1940 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1941 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1945 && (val
= get_pos_property (make_number (beg
),
1947 TEXT_PROP_MEANS_INVISIBLE (val
))
1949 && !NILP (val
= get_char_property_and_overlay
1950 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1951 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1953 ellipsis
= ellipsis
|| inv
> 1
1954 || (OVERLAYP (overlay
)
1955 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1956 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1957 tmp
= Fprevious_single_char_property_change
1958 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1959 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1962 /* Move away from the inside area. */
1963 if (beg
< PT
&& end
> PT
)
1965 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1966 /* We haven't moved yet (so we don't need to fear
1967 infinite-looping) and we were outside the range
1968 before (so either end of the range still corresponds
1969 to a move in the right direction): pretend we moved
1970 less than we actually did, so that we still have
1971 more freedom below in choosing which end of the range
1973 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1974 /* We either have moved already or the last point
1975 was already in the range: we don't get to choose
1976 which end of the range we have to go to. */
1977 : (PT
< last_pt
? beg
: end
));
1978 check_composition
= check_display
= 1;
1980 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
1981 the point to something other than its argument, due to
1982 point-motion hooks, intangibility, etc. */
1983 xassert (PT
== beg
|| PT
== end
);
1986 /* Pretend the area doesn't exist if the buffer is not
1988 if (!modified
&& !ellipsis
&& beg
< end
)
1990 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1991 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1992 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1993 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1994 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1995 /* We've already moved as far as we can. Trying to go
1996 to the other end would mean moving backwards and thus
1997 could lead to an infinite loop. */
1999 else if (val
= get_pos_property (make_number (PT
),
2001 TEXT_PROP_MEANS_INVISIBLE (val
)
2002 && (val
= get_pos_property
2003 (make_number (PT
== beg
? end
: beg
),
2005 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2006 (check_composition
= check_display
= 1,
2007 SET_PT (PT
== beg
? end
: beg
));
2010 check_invisible
= 0;
2014 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2017 safe_run_hooks_1 (void)
2019 if (NILP (Vrun_hooks
))
2021 return call1 (Vrun_hooks
, Vinhibit_quit
);
2024 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2027 safe_run_hooks_error (Lisp_Object data
)
2029 Lisp_Object args
[3];
2030 args
[0] = build_string ("Error in %s: %s");
2031 args
[1] = Vinhibit_quit
;
2034 return Fset (Vinhibit_quit
, Qnil
);
2037 /* If we get an error while running the hook, cause the hook variable
2038 to be nil. Also inhibit quits, so that C-g won't cause the hook
2039 to mysteriously evaporate. */
2042 safe_run_hooks (Lisp_Object hook
)
2044 int count
= SPECPDL_INDEX ();
2045 specbind (Qinhibit_quit
, hook
);
2047 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2049 unbind_to (count
, Qnil
);
2053 /* Number of seconds between polling for input. This is a Lisp
2054 variable that can be bound. */
2056 EMACS_INT polling_period
;
2058 /* Nonzero means polling for input is temporarily suppressed. */
2060 int poll_suppress_count
;
2062 /* Asynchronous timer for polling. */
2064 struct atimer
*poll_timer
;
2067 #ifdef POLL_FOR_INPUT
2069 /* Poll for input, so that we catch a C-g if it comes in. This
2070 function is called from x_make_frame_visible, see comment
2074 poll_for_input_1 (void)
2076 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
2077 doing anything dangerous. */
2081 if (interrupt_input_blocked
== 0
2082 && !waiting_for_input
)
2083 read_avail_input (0);
2089 /* Timer callback function for poll_timer. TIMER is equal to
2093 poll_for_input (struct atimer
*timer
)
2095 if (poll_suppress_count
== 0)
2098 interrupt_input_pending
= 1;
2099 pending_signals
= 1;
2101 poll_for_input_1 ();
2106 #endif /* POLL_FOR_INPUT */
2108 /* Begin signals to poll for input, if they are appropriate.
2109 This function is called unconditionally from various places. */
2112 start_polling (void)
2114 #ifdef POLL_FOR_INPUT
2115 /* XXX This condition was (read_socket_hook && !interrupt_input),
2116 but read_socket_hook is not global anymore. Let's pretend that
2118 if (!interrupt_input
)
2120 /* Turn alarm handling on unconditionally. It might have
2121 been turned off in process.c. */
2122 turn_on_atimers (1);
2124 /* If poll timer doesn't exist, are we need one with
2125 a different interval, start a new one. */
2126 if (poll_timer
== NULL
2127 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2129 EMACS_TIME interval
;
2132 cancel_atimer (poll_timer
);
2134 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2135 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2136 poll_for_input
, NULL
);
2139 /* Let the timer's callback function poll for input
2140 if this becomes zero. */
2141 --poll_suppress_count
;
2146 /* Nonzero if we are using polling to handle input asynchronously. */
2149 input_polling_used (void)
2151 #ifdef POLL_FOR_INPUT
2152 /* XXX This condition was (read_socket_hook && !interrupt_input),
2153 but read_socket_hook is not global anymore. Let's pretend that
2155 return !interrupt_input
;
2161 /* Turn off polling. */
2166 #ifdef POLL_FOR_INPUT
2167 /* XXX This condition was (read_socket_hook && !interrupt_input),
2168 but read_socket_hook is not global anymore. Let's pretend that
2170 if (!interrupt_input
)
2171 ++poll_suppress_count
;
2175 /* Set the value of poll_suppress_count to COUNT
2176 and start or stop polling accordingly. */
2179 set_poll_suppress_count (int count
)
2181 #ifdef POLL_FOR_INPUT
2182 if (count
== 0 && poll_suppress_count
!= 0)
2184 poll_suppress_count
= 1;
2187 else if (count
!= 0 && poll_suppress_count
== 0)
2191 poll_suppress_count
= count
;
2195 /* Bind polling_period to a value at least N.
2196 But don't decrease it. */
2199 bind_polling_period (int n
)
2201 #ifdef POLL_FOR_INPUT
2202 int new = polling_period
;
2207 stop_other_atimers (poll_timer
);
2209 specbind (Qpolling_period
, make_number (new));
2210 /* Start a new alarm with the new period. */
2215 /* Apply the control modifier to CHARACTER. */
2218 make_ctrl_char (int c
)
2220 /* Save the upper bits here. */
2221 int upper
= c
& ~0177;
2223 if (! ASCII_BYTE_P (c
))
2224 return c
|= ctrl_modifier
;
2228 /* Everything in the columns containing the upper-case letters
2229 denotes a control character. */
2230 if (c
>= 0100 && c
< 0140)
2234 /* Set the shift modifier for a control char
2235 made from a shifted letter. But only for letters! */
2236 if (oc
>= 'A' && oc
<= 'Z')
2237 c
|= shift_modifier
;
2240 /* The lower-case letters denote control characters too. */
2241 else if (c
>= 'a' && c
<= 'z')
2244 /* Include the bits for control and shift
2245 only if the basic ASCII code can't indicate them. */
2249 /* Replace the high bits. */
2250 c
|= (upper
& ~ctrl_modifier
);
2255 /* Display the help-echo property of the character after the mouse pointer.
2256 Either show it in the echo area, or call show-help-function to display
2257 it by other means (maybe in a tooltip).
2259 If HELP is nil, that means clear the previous help echo.
2261 If HELP is a string, display that string. If HELP is a function,
2262 call it with OBJECT and POS as arguments; the function should
2263 return a help string or nil for none. For all other types of HELP,
2264 evaluate it to obtain a string.
2266 WINDOW is the window in which the help was generated, if any.
2267 It is nil if not in a window.
2269 If OBJECT is a buffer, POS is the position in the buffer where the
2270 `help-echo' text property was found.
2272 If OBJECT is an overlay, that overlay has a `help-echo' property,
2273 and POS is the position in the overlay's buffer under the mouse.
2275 If OBJECT is a string (an overlay string or a string displayed with
2276 the `display' property). POS is the position in that string under
2279 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2280 echo overwrites a keystroke echo currently displayed in the echo
2283 Note: this function may only be called with HELP nil or a string
2284 from X code running asynchronously. */
2287 show_help_echo (Lisp_Object help
, Lisp_Object window
, Lisp_Object object
,
2288 Lisp_Object pos
, int ok_to_overwrite_keystroke_echo
)
2290 if (!NILP (help
) && !STRINGP (help
))
2292 if (FUNCTIONP (help
))
2294 Lisp_Object args
[4];
2299 help
= safe_call (4, args
);
2302 help
= safe_eval (help
);
2304 if (!STRINGP (help
))
2308 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2309 if (!noninteractive
&& STRINGP (help
))
2311 /* The mouse-fixup-help-message Lisp function can call
2312 mouse_position_hook, which resets the mouse_moved flags.
2313 This causes trouble if we are trying to read a mouse motion
2314 event (i.e., if we are inside a `track-mouse' form), so we
2315 restore the mouse_moved flag. */
2316 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2317 help
= call1 (Qmouse_fixup_help_message
, help
);
2323 if (STRINGP (help
) || NILP (help
))
2325 if (!NILP (Vshow_help_function
))
2326 call1 (Vshow_help_function
, help
);
2327 help_echo_showing_p
= STRINGP (help
);
2333 /* Input of single characters from keyboard */
2335 Lisp_Object
print_help (Lisp_Object object
);
2336 static Lisp_Object
kbd_buffer_get_event (KBOARD
**kbp
, int *used_mouse_menu
,
2337 struct timeval
*end_time
);
2338 static void record_char (Lisp_Object c
);
2340 static Lisp_Object help_form_saved_window_configs
;
2342 read_char_help_form_unwind (Lisp_Object arg
)
2344 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2345 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2346 if (!NILP (window_config
))
2347 Fset_window_configuration (window_config
);
2351 #define STOP_POLLING \
2352 do { if (! polling_stopped_here) stop_polling (); \
2353 polling_stopped_here = 1; } while (0)
2355 #define RESUME_POLLING \
2356 do { if (polling_stopped_here) start_polling (); \
2357 polling_stopped_here = 0; } while (0)
2359 /* read a character from the keyboard; call the redisplay if needed */
2360 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2361 -1 means do not do redisplay, but do do autosaving.
2364 /* The arguments MAPS and NMAPS are for menu prompting.
2365 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2367 PREV_EVENT is the previous input event, or nil if we are reading
2368 the first event of a key sequence (or not reading a key sequence).
2369 If PREV_EVENT is t, that is a "magic" value that says
2370 not to run input methods, but in other respects to act as if
2371 not reading a key sequence.
2373 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2374 if we used a mouse menu to read the input, or zero otherwise. If
2375 USED_MOUSE_MENU is null, we don't dereference it.
2377 Value is -2 when we find input on another keyboard. A second call
2378 to read_char will read it.
2380 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2381 specifying the maximum time to wait until. If no input arrives by
2382 that time, stop waiting and return nil.
2384 Value is t if we showed a menu and the user rejected it. */
2387 read_char (int commandflag
, int nmaps
, Lisp_Object
*maps
, Lisp_Object prev_event
,
2388 int *used_mouse_menu
, struct timeval
*end_time
)
2390 volatile Lisp_Object c
;
2391 int count
, jmpcount
;
2392 jmp_buf local_getcjmp
;
2394 volatile int key_already_recorded
= 0;
2395 Lisp_Object tem
, save
;
2396 volatile Lisp_Object previous_echo_area_message
;
2397 volatile Lisp_Object also_record
;
2398 volatile int reread
;
2399 struct gcpro gcpro1
, gcpro2
;
2400 int polling_stopped_here
= 0;
2401 struct kboard
*orig_kboard
= current_kboard
;
2405 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2406 before_command_key_count
= this_command_key_count
;
2407 before_command_echo_length
= echo_length ();
2410 previous_echo_area_message
= Qnil
;
2412 GCPRO2 (c
, previous_echo_area_message
);
2417 if (CONSP (Vunread_post_input_method_events
))
2419 c
= XCAR (Vunread_post_input_method_events
);
2420 Vunread_post_input_method_events
2421 = XCDR (Vunread_post_input_method_events
);
2423 /* Undo what read_char_x_menu_prompt did when it unread
2424 additional keys returned by Fx_popup_menu. */
2426 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2434 if (unread_command_char
!= -1)
2436 XSETINT (c
, unread_command_char
);
2437 unread_command_char
= -1;
2443 if (CONSP (Vunread_command_events
))
2445 int was_disabled
= 0;
2447 c
= XCAR (Vunread_command_events
);
2448 Vunread_command_events
= XCDR (Vunread_command_events
);
2452 /* Undo what sit-for did when it unread additional keys
2453 inside universal-argument. */
2456 && EQ (XCAR (c
), Qt
))
2462 /* Undo what read_char_x_menu_prompt did when it unread
2463 additional keys returned by Fx_popup_menu. */
2465 && EQ (XCDR (c
), Qdisabled
)
2466 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2472 /* If the queued event is something that used the mouse,
2473 set used_mouse_menu accordingly. */
2475 /* Also check was_disabled so last-nonmenu-event won't return
2476 a bad value when submenus are involved. (Bug#447) */
2477 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
) || was_disabled
))
2478 *used_mouse_menu
= 1;
2480 goto reread_for_input_method
;
2483 if (CONSP (Vunread_input_method_events
))
2485 c
= XCAR (Vunread_input_method_events
);
2486 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2488 /* Undo what read_char_x_menu_prompt did when it unread
2489 additional keys returned by Fx_popup_menu. */
2491 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2495 goto reread_for_input_method
;
2498 this_command_key_count_reset
= 0;
2500 if (!NILP (Vexecuting_kbd_macro
))
2502 /* We set this to Qmacro; since that's not a frame, nobody will
2503 try to switch frames on us, and the selected window will
2506 Since this event came from a macro, it would be misleading to
2507 leave internal_last_event_frame set to wherever the last
2508 real event came from. Normally, a switch-frame event selects
2509 internal_last_event_frame after each command is read, but
2510 events read from a macro should never cause a new frame to be
2512 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2514 /* Exit the macro if we are at the end.
2515 Also, some things replace the macro with t
2516 to force an early exit. */
2517 if (EQ (Vexecuting_kbd_macro
, Qt
)
2518 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2524 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2525 if (STRINGP (Vexecuting_kbd_macro
)
2526 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2527 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2529 executing_kbd_macro_index
++;
2534 if (!NILP (unread_switch_frame
))
2536 c
= unread_switch_frame
;
2537 unread_switch_frame
= Qnil
;
2539 /* This event should make it into this_command_keys, and get echoed
2540 again, so we do not set `reread'. */
2544 /* if redisplay was requested */
2545 if (commandflag
>= 0)
2547 int echo_current
= EQ (echo_message_buffer
, echo_area_buffer
[0]);
2549 /* If there is pending input, process any events which are not
2550 user-visible, such as X selection_request events. */
2552 || detect_input_pending_run_timers (0))
2553 swallow_events (0); /* may clear input_pending */
2555 /* Redisplay if no pending input. */
2556 while (!input_pending
)
2558 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2559 redisplay_preserve_echo_area (5);
2564 /* Normal case: no input arrived during redisplay. */
2567 /* Input arrived and pre-empted redisplay.
2568 Process any events which are not user-visible. */
2570 /* If that cleared input_pending, try again to redisplay. */
2573 /* Prevent the redisplay we just did
2574 from messing up echoing of the input after the prompt. */
2575 if (commandflag
== 0 && echo_current
)
2576 echo_message_buffer
= echo_area_buffer
[0];
2580 /* Message turns off echoing unless more keystrokes turn it on again.
2582 The code in 20.x for the condition was
2584 1. echo_area_glyphs && *echo_area_glyphs
2585 2. && echo_area_glyphs != current_kboard->echobuf
2586 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2588 (1) means there's a current message displayed
2590 (2) means it's not the message from echoing from the current
2593 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2594 is set to a non-null value. This is done in read_char and it is
2595 set to echo_area_glyphs after a call to echo_char. That means
2596 ok_to_echo_at_next_pause is either null or
2597 current_kboard->echobuf with the appropriate current_kboard at
2600 So, condition (3) means in clear text ok_to_echo_at_next_pause
2601 must be either null, or the current message isn't from echoing at
2602 all, or it's from echoing from a different kboard than the
2605 if (/* There currently is something in the echo area. */
2606 !NILP (echo_area_buffer
[0])
2607 && (/* And it's either not from echoing. */
2608 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2609 /* Or it's an echo from a different kboard. */
2610 || echo_kboard
!= current_kboard
2611 /* Or we explicitly allow overwriting whatever there is. */
2612 || ok_to_echo_at_next_pause
== NULL
))
2617 /* Try reading a character via menu prompting in the minibuf.
2618 Try this before the sit-for, because the sit-for
2619 would do the wrong thing if we are supposed to do
2620 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2621 after a mouse event so don't try a minibuf menu. */
2623 if (nmaps
> 0 && INTERACTIVE
2624 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2625 /* Don't bring up a menu if we already have another event. */
2626 && NILP (Vunread_command_events
)
2627 && unread_command_char
< 0
2628 && !detect_input_pending_run_timers (0))
2630 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2632 if (INTEGERP (c
) && XINT (c
) == -2)
2633 return c
; /* wrong_kboard_jmpbuf */
2637 key_already_recorded
= 1;
2642 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2643 We will do that below, temporarily for short sections of code,
2644 when appropriate. local_getcjmp must be in effect
2645 around any call to sit_for or kbd_buffer_get_event;
2646 it *must not* be in effect when we call redisplay. */
2648 jmpcount
= SPECPDL_INDEX ();
2649 if (_setjmp (local_getcjmp
))
2651 /* Handle quits while reading the keyboard. */
2652 /* We must have saved the outer value of getcjmp here,
2653 so restore it now. */
2654 restore_getcjmp (save_jump
);
2655 unbind_to (jmpcount
, Qnil
);
2656 XSETINT (c
, quit_char
);
2657 internal_last_event_frame
= selected_frame
;
2658 Vlast_event_frame
= internal_last_event_frame
;
2659 /* If we report the quit char as an event,
2660 don't do so more than once. */
2661 if (!NILP (Vinhibit_quit
))
2665 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2666 if (kb
!= current_kboard
)
2668 Lisp_Object link
= kb
->kbd_queue
;
2669 /* We shouldn't get here if we were in single-kboard mode! */
2674 while (CONSP (XCDR (link
)))
2676 if (!NILP (XCDR (link
)))
2680 kb
->kbd_queue
= Fcons (c
, Qnil
);
2682 XSETCDR (link
, Fcons (c
, Qnil
));
2683 kb
->kbd_queue_has_data
= 1;
2684 current_kboard
= kb
;
2685 /* This is going to exit from read_char
2686 so we had better get rid of this frame's stuff. */
2688 return make_number (-2); /* wrong_kboard_jmpbuf */
2694 /* Start idle timers if no time limit is supplied. We don't do it
2695 if a time limit is supplied to avoid an infinite recursion in the
2696 situation where an idle timer calls `sit-for'. */
2699 timer_start_idle ();
2701 /* If in middle of key sequence and minibuffer not active,
2702 start echoing if enough time elapses. */
2704 if (minibuf_level
== 0
2706 && !current_kboard
->immediate_echo
2707 && this_command_key_count
> 0
2709 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2710 && NILP (Fzerop (Vecho_keystrokes
))
2711 && (/* No message. */
2712 NILP (echo_area_buffer
[0])
2713 /* Or empty message. */
2714 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2715 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2716 /* Or already echoing from same kboard. */
2717 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2718 /* Or not echoing before and echoing allowed. */
2719 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2721 /* After a mouse event, start echoing right away.
2722 This is because we are probably about to display a menu,
2723 and we don't want to delay before doing so. */
2724 if (EVENT_HAS_PARAMETERS (prev_event
))
2730 save_getcjmp (save_jump
);
2731 restore_getcjmp (local_getcjmp
);
2732 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2733 restore_getcjmp (save_jump
);
2735 && ! CONSP (Vunread_command_events
))
2740 /* Maybe auto save due to number of keystrokes. */
2742 if (commandflag
!= 0
2743 && auto_save_interval
> 0
2744 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2745 && !detect_input_pending_run_timers (0))
2747 Fdo_auto_save (Qnil
, Qnil
);
2748 /* Hooks can actually change some buffers in auto save. */
2752 /* Try reading using an X menu.
2753 This is never confused with reading using the minibuf
2754 because the recursive call of read_char in read_char_minibuf_menu_prompt
2755 does not pass on any keymaps. */
2757 if (nmaps
> 0 && INTERACTIVE
2758 && !NILP (prev_event
)
2759 && EVENT_HAS_PARAMETERS (prev_event
)
2760 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2761 && !EQ (XCAR (prev_event
), Qtool_bar
)
2762 /* Don't bring up a menu if we already have another event. */
2763 && NILP (Vunread_command_events
)
2764 && unread_command_char
< 0)
2766 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2768 /* Now that we have read an event, Emacs is not idle. */
2775 /* Maybe autosave and/or garbage collect due to idleness. */
2777 if (INTERACTIVE
&& NILP (c
))
2779 int delay_level
, buffer_size
;
2781 /* Slow down auto saves logarithmically in size of current buffer,
2782 and garbage collect while we're at it. */
2783 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2784 last_non_minibuf_size
= Z
- BEG
;
2785 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2787 while (buffer_size
> 64)
2788 delay_level
++, buffer_size
-= buffer_size
>> 2;
2789 if (delay_level
< 4) delay_level
= 4;
2790 /* delay_level is 4 for files under around 50k, 7 at 100k,
2791 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2793 /* Auto save if enough time goes by without input. */
2794 if (commandflag
!= 0
2795 && num_nonmacro_input_events
> last_auto_save
2796 && INTEGERP (Vauto_save_timeout
)
2797 && XINT (Vauto_save_timeout
) > 0)
2800 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2802 save_getcjmp (save_jump
);
2803 restore_getcjmp (local_getcjmp
);
2804 tem0
= sit_for (make_number (timeout
), 1, 1);
2805 restore_getcjmp (save_jump
);
2808 && ! CONSP (Vunread_command_events
))
2810 Fdo_auto_save (Qnil
, Qnil
);
2812 /* If we have auto-saved and there is still no input
2813 available, garbage collect if there has been enough
2814 consing going on to make it worthwhile. */
2815 if (!detect_input_pending_run_timers (0)
2816 && consing_since_gc
> gc_cons_threshold
/ 2)
2817 Fgarbage_collect ();
2824 /* Notify the caller if an autosave hook, or a timer, sentinel or
2825 filter in the sit_for calls above have changed the current
2826 kboard. This could happen if they use the minibuffer or start a
2827 recursive edit, like the fancy splash screen in server.el's
2828 filter. If this longjmp wasn't here, read_key_sequence would
2829 interpret the next key sequence using the wrong translation
2830 tables and function keymaps. */
2831 if (NILP (c
) && current_kboard
!= orig_kboard
)
2834 return make_number (-2); /* wrong_kboard_jmpbuf */
2837 /* If this has become non-nil here, it has been set by a timer
2838 or sentinel or filter. */
2839 if (CONSP (Vunread_command_events
))
2841 c
= XCAR (Vunread_command_events
);
2842 Vunread_command_events
= XCDR (Vunread_command_events
);
2845 /* Read something from current KBOARD's side queue, if possible. */
2849 if (current_kboard
->kbd_queue_has_data
)
2851 if (!CONSP (current_kboard
->kbd_queue
))
2853 c
= XCAR (current_kboard
->kbd_queue
);
2854 current_kboard
->kbd_queue
2855 = XCDR (current_kboard
->kbd_queue
);
2856 if (NILP (current_kboard
->kbd_queue
))
2857 current_kboard
->kbd_queue_has_data
= 0;
2858 input_pending
= readable_events (0);
2859 if (EVENT_HAS_PARAMETERS (c
)
2860 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2861 internal_last_event_frame
= XCAR (XCDR (c
));
2862 Vlast_event_frame
= internal_last_event_frame
;
2866 /* If current_kboard's side queue is empty check the other kboards.
2867 If one of them has data that we have not yet seen here,
2868 switch to it and process the data waiting for it.
2870 Note: if the events queued up for another kboard
2871 have already been seen here, and therefore are not a complete command,
2872 the kbd_queue_has_data field is 0, so we skip that kboard here.
2873 That's to avoid an infinite loop switching between kboards here. */
2874 if (NILP (c
) && !single_kboard
)
2877 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2878 if (kb
->kbd_queue_has_data
)
2880 current_kboard
= kb
;
2881 /* This is going to exit from read_char
2882 so we had better get rid of this frame's stuff. */
2884 return make_number (-2); /* wrong_kboard_jmpbuf */
2892 /* Finally, we read from the main queue,
2893 and if that gives us something we can't use yet, we put it on the
2894 appropriate side queue and try again. */
2903 EMACS_GET_TIME (now
);
2904 if (EMACS_TIME_GE (now
, *end_time
))
2908 /* Actually read a character, waiting if necessary. */
2909 save_getcjmp (save_jump
);
2910 restore_getcjmp (local_getcjmp
);
2912 timer_start_idle ();
2913 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
2914 restore_getcjmp (save_jump
);
2916 if (! NILP (c
) && (kb
!= current_kboard
))
2918 Lisp_Object link
= kb
->kbd_queue
;
2921 while (CONSP (XCDR (link
)))
2923 if (!NILP (XCDR (link
)))
2927 kb
->kbd_queue
= Fcons (c
, Qnil
);
2929 XSETCDR (link
, Fcons (c
, Qnil
));
2930 kb
->kbd_queue_has_data
= 1;
2934 current_kboard
= kb
;
2935 /* This is going to exit from read_char
2936 so we had better get rid of this frame's stuff. */
2938 return make_number (-2);
2942 /* Terminate Emacs in batch mode if at eof. */
2943 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2944 Fkill_emacs (make_number (1));
2948 /* Add in any extra modifiers, where appropriate. */
2949 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2950 || ((extra_keyboard_modifiers
& 0177) < ' '
2951 && (extra_keyboard_modifiers
& 0177) != 0))
2952 XSETINT (c
, make_ctrl_char (XINT (c
)));
2954 /* Transfer any other modifier bits directly from
2955 extra_keyboard_modifiers to c. Ignore the actual character code
2956 in the low 16 bits of extra_keyboard_modifiers. */
2957 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2968 if (commandflag
>= 0
2969 && !input_pending
&& !detect_input_pending_run_timers (0))
2977 /* Buffer switch events are only for internal wakeups
2978 so don't show them to the user.
2979 Also, don't record a key if we already did. */
2980 if (BUFFERP (c
) || key_already_recorded
)
2983 /* Process special events within read_char
2984 and loop around to read another event. */
2987 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2992 struct buffer
*prev_buffer
= current_buffer
;
2993 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2994 int was_locked
= single_kboard
;
2995 int count
= SPECPDL_INDEX ();
2996 record_single_kboard_state ();
2999 last_input_event
= c
;
3000 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_event
), Qt
);
3002 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
3003 /* We stopped being idle for this event; undo that. This
3004 prevents automatic window selection (under
3005 mouse_autoselect_window from acting as a real input event, for
3006 example banishing the mouse under mouse-avoidance-mode. */
3007 timer_resume_idle ();
3009 #if 0 /* This shouldn't be necessary anymore. --lorentey */
3010 /* Resume allowing input from any kboard, if that was true before. */
3012 any_kboard_state ();
3013 unbind_to (count
, Qnil
);
3016 if (current_buffer
!= prev_buffer
)
3018 /* The command may have changed the keymaps. Pretend there
3019 is input in another keyboard and return. This will
3020 recalculate keymaps. */
3021 c
= make_number (-2);
3028 /* Handle things that only apply to characters. */
3031 /* If kbd_buffer_get_event gave us an EOF, return that. */
3035 if ((STRINGP (current_kboard
->Vkeyboard_translate_table
)
3036 && SCHARS (current_kboard
->Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
3037 || (VECTORP (current_kboard
->Vkeyboard_translate_table
)
3038 && XVECTOR (current_kboard
->Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
3039 || (CHAR_TABLE_P (current_kboard
->Vkeyboard_translate_table
)
3043 d
= Faref (current_kboard
->Vkeyboard_translate_table
, c
);
3044 /* nil in keyboard-translate-table means no translation. */
3050 /* If this event is a mouse click in the menu bar,
3051 return just menu-bar for now. Modify the mouse click event
3052 so we won't do this twice, then queue it up. */
3053 if (EVENT_HAS_PARAMETERS (c
)
3055 && CONSP (EVENT_START (c
))
3056 && CONSP (XCDR (EVENT_START (c
))))
3060 posn
= POSN_POSN (EVENT_START (c
));
3061 /* Handle menu-bar events:
3062 insert the dummy prefix event `menu-bar'. */
3063 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
3065 /* Change menu-bar to (menu-bar) as the event "position". */
3066 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
3069 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
3074 /* Store these characters into recent_keys, the dribble file if any,
3075 and the keyboard macro being defined, if any. */
3077 if (! NILP (also_record
))
3078 record_char (also_record
);
3080 /* Wipe the echo area.
3081 But first, if we are about to use an input method,
3082 save the echo area contents for it to refer to. */
3084 && ! NILP (Vinput_method_function
)
3085 && (unsigned) XINT (c
) >= ' '
3086 && (unsigned) XINT (c
) != 127
3087 && (unsigned) XINT (c
) < 256)
3089 previous_echo_area_message
= Fcurrent_message ();
3090 Vinput_method_previous_message
= previous_echo_area_message
;
3093 /* Now wipe the echo area, except for help events which do their
3094 own stuff with the echo area. */
3096 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3097 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3099 if (!NILP (echo_area_buffer
[0]))
3100 safe_run_hooks (Qecho_area_clear_hook
);
3101 clear_message (1, 0);
3104 reread_for_input_method
:
3106 /* Pass this to the input method, if appropriate. */
3108 && ! NILP (Vinput_method_function
)
3109 /* Don't run the input method within a key sequence,
3110 after the first event of the key sequence. */
3111 && NILP (prev_event
)
3112 && (unsigned) XINT (c
) >= ' '
3113 && (unsigned) XINT (c
) != 127
3114 && (unsigned) XINT (c
) < 256)
3117 int key_count
, key_count_reset
;
3118 struct gcpro gcpro1
;
3119 int count
= SPECPDL_INDEX ();
3121 /* Save the echo status. */
3122 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3123 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3124 Lisp_Object saved_echo_string
= current_kboard
->echo_string
;
3125 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3128 if (before_command_restore_flag
)
3130 this_command_key_count
= before_command_key_count_1
;
3131 if (this_command_key_count
< this_single_command_key_start
)
3132 this_single_command_key_start
= this_command_key_count
;
3133 echo_truncate (before_command_echo_length_1
);
3134 before_command_restore_flag
= 0;
3138 /* Save the this_command_keys status. */
3139 key_count
= this_command_key_count
;
3140 key_count_reset
= this_command_key_count_reset
;
3143 keys
= Fcopy_sequence (this_command_keys
);
3148 /* Clear out this_command_keys. */
3149 this_command_key_count
= 0;
3150 this_command_key_count_reset
= 0;
3152 /* Now wipe the echo area. */
3153 if (!NILP (echo_area_buffer
[0]))
3154 safe_run_hooks (Qecho_area_clear_hook
);
3155 clear_message (1, 0);
3158 /* If we are not reading a key sequence,
3159 never use the echo area. */
3162 specbind (Qinput_method_use_echo_area
, Qt
);
3165 /* Call the input method. */
3166 tem
= call1 (Vinput_method_function
, c
);
3168 tem
= unbind_to (count
, tem
);
3170 /* Restore the saved echoing state
3171 and this_command_keys state. */
3172 this_command_key_count
= key_count
;
3173 this_command_key_count_reset
= key_count_reset
;
3175 this_command_keys
= keys
;
3178 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3179 current_kboard
->echo_string
= saved_echo_string
;
3180 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3181 if (saved_immediate_echo
)
3186 /* The input method can return no events. */
3189 /* Bring back the previous message, if any. */
3190 if (! NILP (previous_echo_area_message
))
3191 message_with_string ("%s", previous_echo_area_message
, 0);
3194 /* It returned one event or more. */
3196 Vunread_post_input_method_events
3197 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3202 /* Display help if not echoing. */
3203 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3205 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3206 Lisp_Object help
, object
, position
, window
, tem
;
3208 tem
= Fcdr (XCDR (c
));
3211 window
= Fcar (tem
);
3213 object
= Fcar (tem
);
3215 position
= Fcar (tem
);
3217 show_help_echo (help
, window
, object
, position
, 0);
3219 /* We stopped being idle for this event; undo that. */
3221 timer_resume_idle ();
3225 if ((! reread
|| this_command_key_count
== 0
3226 || this_command_key_count_reset
)
3230 /* Don't echo mouse motion events. */
3231 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3232 && NILP (Fzerop (Vecho_keystrokes
))
3233 && ! (EVENT_HAS_PARAMETERS (c
)
3234 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3237 if (! NILP (also_record
))
3238 echo_char (also_record
);
3239 /* Once we reread a character, echoing can happen
3240 the next time we pause to read a new one. */
3241 ok_to_echo_at_next_pause
= current_kboard
;
3244 /* Record this character as part of the current key. */
3245 add_command_key (c
);
3246 if (! NILP (also_record
))
3247 add_command_key (also_record
);
3250 last_input_event
= c
;
3253 /* Process the help character specially if enabled */
3254 if (!NILP (Vhelp_form
) && help_char_p (c
))
3257 count
= SPECPDL_INDEX ();
3259 help_form_saved_window_configs
3260 = Fcons (Fcurrent_window_configuration (Qnil
),
3261 help_form_saved_window_configs
);
3262 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3264 tem0
= Feval (Vhelp_form
);
3266 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3271 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3272 if (EVENT_HAS_PARAMETERS (c
)
3273 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3274 XSETCAR (help_form_saved_window_configs
, Qnil
);
3276 while (BUFFERP (c
));
3277 /* Remove the help from the frame */
3278 unbind_to (count
, Qnil
);
3281 if (EQ (c
, make_number (040)))
3285 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3286 while (BUFFERP (c
));
3295 /* Record a key that came from a mouse menu.
3296 Record it for echoing, for this-command-keys, and so on. */
3299 record_menu_key (Lisp_Object c
)
3301 /* Wipe the echo area. */
3302 clear_message (1, 0);
3307 before_command_key_count
= this_command_key_count
;
3308 before_command_echo_length
= echo_length ();
3311 /* Don't echo mouse motion events. */
3312 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3313 && NILP (Fzerop (Vecho_keystrokes
)))
3317 /* Once we reread a character, echoing can happen
3318 the next time we pause to read a new one. */
3319 ok_to_echo_at_next_pause
= 0;
3322 /* Record this character as part of the current key. */
3323 add_command_key (c
);
3325 /* Re-reading in the middle of a command */
3326 last_input_event
= c
;
3330 /* Return 1 if should recognize C as "the help character". */
3333 help_char_p (Lisp_Object c
)
3337 if (EQ (c
, Vhelp_char
))
3339 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3340 if (EQ (c
, XCAR (tail
)))
3345 /* Record the input event C in various ways. */
3348 record_char (Lisp_Object c
)
3352 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3354 /* To avoid filling recent_keys with help-echo and mouse-movement
3355 events, we filter out repeated help-echo events, only store the
3356 first and last in a series of mouse-movement events, and don't
3357 store repeated help-echo events which are only separated by
3358 mouse-movement events. */
3360 Lisp_Object ev1
, ev2
, ev3
;
3363 if ((ix1
= recent_keys_index
- 1) < 0)
3364 ix1
= NUM_RECENT_KEYS
- 1;
3365 ev1
= AREF (recent_keys
, ix1
);
3367 if ((ix2
= ix1
- 1) < 0)
3368 ix2
= NUM_RECENT_KEYS
- 1;
3369 ev2
= AREF (recent_keys
, ix2
);
3371 if ((ix3
= ix2
- 1) < 0)
3372 ix3
= NUM_RECENT_KEYS
- 1;
3373 ev3
= AREF (recent_keys
, ix3
);
3375 if (EQ (XCAR (c
), Qhelp_echo
))
3377 /* Don't record `help-echo' in recent_keys unless it shows some help
3378 message, and a different help than the previously recorded
3380 Lisp_Object help
, last_help
;
3382 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3383 if (!STRINGP (help
))
3385 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3386 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3388 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3389 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3390 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3392 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3393 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3394 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3395 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3398 else if (EQ (XCAR (c
), Qmouse_movement
))
3400 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3401 So additional mouse movement events replace the last element. */
3402 Lisp_Object last_window
, window
;
3404 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3405 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3406 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3407 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3408 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3410 ASET (recent_keys
, ix1
, c
);
3416 store_kbd_macro_char (c
);
3421 ASET (recent_keys
, recent_keys_index
, c
);
3422 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3423 recent_keys_index
= 0;
3425 else if (recorded
< 0)
3427 /* We need to remove one or two events from recent_keys.
3428 To do this, we simply put nil at those events and move the
3429 recent_keys_index backwards over those events. Usually,
3430 users will never see those nil events, as they will be
3431 overwritten by the command keys entered to see recent_keys
3434 while (recorded
++ < 0 && total_keys
> 0)
3436 if (total_keys
< NUM_RECENT_KEYS
)
3438 if (--recent_keys_index
< 0)
3439 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3440 ASET (recent_keys
, recent_keys_index
, Qnil
);
3444 num_nonmacro_input_events
++;
3446 /* Write c to the dribble file. If c is a lispy event, write
3447 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3448 If you, dear reader, have a better idea, you've got the source. :-) */
3454 if (XUINT (c
) < 0x100)
3455 putc (XINT (c
), dribble
);
3457 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3461 Lisp_Object dribblee
;
3463 /* If it's a structured event, take the event header. */
3464 dribblee
= EVENT_HEAD (c
);
3466 if (SYMBOLP (dribblee
))
3468 putc ('<', dribble
);
3469 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3470 SBYTES (SYMBOL_NAME (dribblee
)),
3472 putc ('>', dribble
);
3482 print_help (Lisp_Object object
)
3484 struct buffer
*old
= current_buffer
;
3485 Fprinc (object
, Qnil
);
3486 set_buffer_internal (XBUFFER (Vstandard_output
));
3487 call0 (intern ("help-mode"));
3488 set_buffer_internal (old
);
3492 /* Copy out or in the info on where C-g should throw to.
3493 This is used when running Lisp code from within get_char,
3494 in case get_char is called recursively.
3495 See read_process_output. */
3498 save_getcjmp (jmp_buf temp
)
3500 memcpy (temp
, getcjmp
, sizeof getcjmp
);
3504 restore_getcjmp (jmp_buf temp
)
3506 memcpy (getcjmp
, temp
, sizeof getcjmp
);
3509 /* Low level keyboard/mouse input.
3510 kbd_buffer_store_event places events in kbd_buffer, and
3511 kbd_buffer_get_event retrieves them. */
3513 /* Return true if there are any events in the queue that read-char
3514 would return. If this returns false, a read-char would block. */
3516 readable_events (int flags
)
3519 /* Check whether a D-Bus message has arrived. */
3520 if (xd_pending_messages () > 0)
3522 #endif /* HAVE_DBUS */
3524 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3527 /* If the buffer contains only FOCUS_IN_EVENT events, and
3528 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3529 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3531 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3532 #ifdef USE_TOOLKIT_SCROLL_BARS
3533 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3537 struct input_event
*event
;
3539 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3546 #ifdef USE_TOOLKIT_SCROLL_BARS
3547 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3549 event
->kind
== FOCUS_IN_EVENT
)
3550 #ifdef USE_TOOLKIT_SCROLL_BARS
3551 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3552 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3553 && event
->part
== scroll_bar_handle
3554 && event
->modifiers
== 0)
3559 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3562 while (event
!= kbd_store_ptr
);
3568 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3569 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3570 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3575 if (current_kboard
->kbd_queue_has_data
)
3581 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3582 if (kb
->kbd_queue_has_data
)
3588 /* Set this for debugging, to have a way to get out */
3592 event_to_kboard (struct input_event
*event
)
3595 frame
= event
->frame_or_window
;
3597 frame
= XCAR (frame
);
3598 else if (WINDOWP (frame
))
3599 frame
= WINDOW_FRAME (XWINDOW (frame
));
3601 /* There are still some events that don't set this field.
3602 For now, just ignore the problem.
3603 Also ignore dead frames here. */
3604 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3607 return FRAME_KBOARD (XFRAME (frame
));
3610 /* Return the number of slots occupied in kbd_buffer. */
3613 kbd_buffer_nr_stored (void)
3615 return kbd_fetch_ptr
== kbd_store_ptr
3617 : (kbd_fetch_ptr
< kbd_store_ptr
3618 ? kbd_store_ptr
- kbd_fetch_ptr
3619 : ((kbd_buffer
+ KBD_BUFFER_SIZE
) - kbd_fetch_ptr
3620 + (kbd_store_ptr
- kbd_buffer
)));
3623 Lisp_Object Vthrow_on_input
;
3625 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3628 kbd_buffer_store_event (register struct input_event
*event
)
3630 kbd_buffer_store_event_hold (event
, 0);
3633 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3635 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3636 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3637 Else, if EVENT is a quit event, store the quit event
3638 in HOLD_QUIT, and return (thus ignoring further events).
3640 This is used in read_avail_input to postpone the processing
3641 of the quit event until all subsequent input events have been
3642 parsed (and discarded).
3646 kbd_buffer_store_event_hold (register struct input_event
*event
,
3647 struct input_event
*hold_quit
)
3649 if (event
->kind
== NO_EVENT
)
3652 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3655 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3657 register int c
= event
->code
& 0377;
3659 if (event
->modifiers
& ctrl_modifier
)
3660 c
= make_ctrl_char (c
);
3662 c
|= (event
->modifiers
3663 & (meta_modifier
| alt_modifier
3664 | hyper_modifier
| super_modifier
));
3668 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3669 struct input_event
*sp
;
3671 if (single_kboard
&& kb
!= current_kboard
)
3674 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3675 Fcons (make_number (c
), Qnil
));
3676 kb
->kbd_queue_has_data
= 1;
3677 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3679 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3682 if (event_to_kboard (sp
) == kb
)
3684 sp
->kind
= NO_EVENT
;
3685 sp
->frame_or_window
= Qnil
;
3694 memcpy (hold_quit
, event
, sizeof (*event
));
3698 /* If this results in a quit_char being returned to Emacs as
3699 input, set Vlast_event_frame properly. If this doesn't
3700 get returned to Emacs as an event, the next event read
3701 will set Vlast_event_frame again, so this is safe to do. */
3705 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3707 focus
= event
->frame_or_window
;
3708 internal_last_event_frame
= focus
;
3709 Vlast_event_frame
= focus
;
3712 last_event_timestamp
= event
->timestamp
;
3713 handle_interrupt ();
3717 if (c
&& c
== stop_character
)
3723 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3724 Just ignore the second one. */
3725 else if (event
->kind
== BUFFER_SWITCH_EVENT
3726 && kbd_fetch_ptr
!= kbd_store_ptr
3727 && ((kbd_store_ptr
== kbd_buffer
3728 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3729 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3732 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3733 kbd_store_ptr
= kbd_buffer
;
3735 /* Don't let the very last slot in the buffer become full,
3736 since that would make the two pointers equal,
3737 and that is indistinguishable from an empty buffer.
3738 Discard the event if it would fill the last slot. */
3739 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3741 *kbd_store_ptr
= *event
;
3743 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE
/2 && ! kbd_on_hold_p ())
3745 /* Don't read keyboard input until we have processed kbd_buffer.
3746 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3747 hold_keyboard_input ();
3749 if (!noninteractive
)
3750 signal (SIGIO
, SIG_IGN
);
3756 /* If we're inside while-no-input, and this event qualifies
3757 as input, set quit-flag to cause an interrupt. */
3758 if (!NILP (Vthrow_on_input
)
3759 && event
->kind
!= FOCUS_IN_EVENT
3760 && event
->kind
!= HELP_EVENT
3761 && event
->kind
!= DEICONIFY_EVENT
)
3763 Vquit_flag
= Vthrow_on_input
;
3764 /* If we're inside a function that wants immediate quits,
3766 if (immediate_quit
&& NILP (Vinhibit_quit
))
3776 /* Put an input event back in the head of the event queue. */
3779 kbd_buffer_unget_event (register struct input_event
*event
)
3781 if (kbd_fetch_ptr
== kbd_buffer
)
3782 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3784 /* Don't let the very last slot in the buffer become full, */
3785 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3788 *kbd_fetch_ptr
= *event
;
3793 /* Generate HELP_EVENT input_events in BUFP which has room for
3794 SIZE events. If there's not enough room in BUFP, ignore this
3797 HELP is the help form.
3799 FRAME is the frame on which the help is generated. OBJECT is the
3800 Lisp object where the help was found (a buffer, a string, an
3801 overlay, or nil if neither from a string nor from a buffer. POS is
3802 the position within OBJECT where the help was found.
3804 Value is the number of input_events generated. */
3807 gen_help_event (Lisp_Object help
, Lisp_Object frame
, Lisp_Object window
,
3808 Lisp_Object object
, int pos
)
3810 struct input_event event
;
3814 event
.kind
= HELP_EVENT
;
3815 event
.frame_or_window
= frame
;
3817 event
.x
= WINDOWP (window
) ? window
: frame
;
3820 kbd_buffer_store_event (&event
);
3824 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3827 kbd_buffer_store_help_event (Lisp_Object frame
, Lisp_Object help
)
3829 struct input_event event
;
3831 event
.kind
= HELP_EVENT
;
3832 event
.frame_or_window
= frame
;
3837 kbd_buffer_store_event (&event
);
3841 /* Discard any mouse events in the event buffer by setting them to
3844 discard_mouse_events (void)
3846 struct input_event
*sp
;
3847 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3849 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3852 if (sp
->kind
== MOUSE_CLICK_EVENT
3853 || sp
->kind
== WHEEL_EVENT
3854 || sp
->kind
== HORIZ_WHEEL_EVENT
3856 || sp
->kind
== GPM_CLICK_EVENT
3858 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3860 sp
->kind
= NO_EVENT
;
3866 /* Return non-zero if there are any real events waiting in the event
3867 buffer, not counting `NO_EVENT's.
3869 If DISCARD is non-zero, discard NO_EVENT events at the front of
3870 the input queue, possibly leaving the input queue empty if there
3871 are no real input events. */
3874 kbd_buffer_events_waiting (int discard
)
3876 struct input_event
*sp
;
3878 for (sp
= kbd_fetch_ptr
;
3879 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3882 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3889 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3893 /* Clear input event EVENT. */
3896 clear_event (struct input_event
*event
)
3898 event
->kind
= NO_EVENT
;
3902 /* Read one event from the event buffer, waiting if necessary.
3903 The value is a Lisp object representing the event.
3904 The value is nil for an event that should be ignored,
3905 or that was handled here.
3906 We always read and discard one event. */
3909 kbd_buffer_get_event (KBOARD
**kbp
,
3910 int *used_mouse_menu
,
3911 struct timeval
*end_time
)
3916 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE
/4)
3918 /* Start reading input again, we have processed enough so we can
3919 accept new events again. */
3920 unhold_keyboard_input ();
3922 if (!noninteractive
)
3923 signal (SIGIO
, input_available_signal
);
3929 /* In case we are running as a daemon, only do this before
3930 detaching from the terminal. */
3931 || (IS_DAEMON
&& daemon_pipe
[1] >= 0))
3935 *kbp
= current_kboard
;
3939 /* Wait until there is input available. */
3942 /* Break loop if there's an unread command event. Needed in
3943 moused window autoselection which uses a timer to insert such
3945 if (CONSP (Vunread_command_events
))
3948 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3950 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3951 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3955 /* If the quit flag is set, then read_char will return
3956 quit_char, so that counts as "available input." */
3957 if (!NILP (Vquit_flag
))
3958 quit_throw_to_read_char ();
3960 /* One way or another, wait until input is available; then, if
3961 interrupt handlers have not read it, read it now. */
3963 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3967 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3969 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3970 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3975 EMACS_TIME duration
;
3976 EMACS_GET_TIME (duration
);
3977 if (EMACS_TIME_GE (duration
, *end_time
))
3978 return Qnil
; /* finished waiting */
3981 EMACS_SUB_TIME (duration
, *end_time
, duration
);
3982 wait_reading_process_output (EMACS_SECS (duration
),
3983 EMACS_USECS (duration
),
3984 -1, 1, Qnil
, NULL
, 0);
3988 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
3990 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3991 /* Pass 1 for EXPECT since we just waited to have input. */
3992 read_avail_input (1);
3995 if (CONSP (Vunread_command_events
))
3998 first
= XCAR (Vunread_command_events
);
3999 Vunread_command_events
= XCDR (Vunread_command_events
);
4000 *kbp
= current_kboard
;
4004 /* At this point, we know that there is a readable event available
4005 somewhere. If the event queue is empty, then there must be a
4006 mouse movement enabled and available. */
4007 if (kbd_fetch_ptr
!= kbd_store_ptr
)
4009 struct input_event
*event
;
4011 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4015 last_event_timestamp
= event
->timestamp
;
4017 *kbp
= event_to_kboard (event
);
4019 *kbp
= current_kboard
; /* Better than returning null ptr? */
4023 /* These two kinds of events get special handling
4024 and don't actually appear to the command loop.
4025 We return nil for them. */
4026 if (event
->kind
== SELECTION_REQUEST_EVENT
4027 || event
->kind
== SELECTION_CLEAR_EVENT
)
4030 struct input_event copy
;
4032 /* Remove it from the buffer before processing it,
4033 since otherwise swallow_events will see it
4034 and process it again. */
4036 kbd_fetch_ptr
= event
+ 1;
4037 input_pending
= readable_events (0);
4038 x_handle_selection_event (©
);
4040 /* We're getting selection request events, but we don't have
4046 #if defined (HAVE_NS)
4047 else if (event
->kind
== NS_TEXT_EVENT
)
4049 if (event
->code
== KEY_NS_PUT_WORKING_TEXT
)
4050 obj
= Fcons (intern ("ns-put-working-text"), Qnil
);
4052 obj
= Fcons (intern ("ns-unput-working-text"), Qnil
);
4053 kbd_fetch_ptr
= event
+ 1;
4054 if (used_mouse_menu
)
4055 *used_mouse_menu
= 1;
4059 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4060 || defined (HAVE_NS)
4061 else if (event
->kind
== DELETE_WINDOW_EVENT
)
4063 /* Make an event (delete-frame (FRAME)). */
4064 obj
= Fcons (event
->frame_or_window
, Qnil
);
4065 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
4066 kbd_fetch_ptr
= event
+ 1;
4069 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
4070 || defined (HAVE_NS)
4071 else if (event
->kind
== ICONIFY_EVENT
)
4073 /* Make an event (iconify-frame (FRAME)). */
4074 obj
= Fcons (event
->frame_or_window
, Qnil
);
4075 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
4076 kbd_fetch_ptr
= event
+ 1;
4078 else if (event
->kind
== DEICONIFY_EVENT
)
4080 /* Make an event (make-frame-visible (FRAME)). */
4081 obj
= Fcons (event
->frame_or_window
, Qnil
);
4082 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
4083 kbd_fetch_ptr
= event
+ 1;
4086 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
4088 /* The value doesn't matter here; only the type is tested. */
4089 XSETBUFFER (obj
, current_buffer
);
4090 kbd_fetch_ptr
= event
+ 1;
4092 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4093 || defined(HAVE_NS) || defined (USE_GTK)
4094 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4096 kbd_fetch_ptr
= event
+ 1;
4097 input_pending
= readable_events (0);
4098 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4099 x_activate_menubar (XFRAME (event
->frame_or_window
));
4102 #if defined (WINDOWSNT)
4103 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4105 /* Make an event (language-change (FRAME CHARSET LCID)). */
4106 obj
= Fcons (event
->frame_or_window
, Qnil
);
4107 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4108 kbd_fetch_ptr
= event
+ 1;
4111 else if (event
->kind
== SAVE_SESSION_EVENT
)
4113 obj
= Fcons (Qsave_session
, Qnil
);
4114 kbd_fetch_ptr
= event
+ 1;
4116 /* Just discard these, by returning nil.
4117 With MULTI_KBOARD, these events are used as placeholders
4118 when we need to randomly delete events from the queue.
4119 (They shouldn't otherwise be found in the buffer,
4120 but on some machines it appears they do show up
4121 even without MULTI_KBOARD.) */
4122 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4123 mouse events during a popup-menu call. */
4124 else if (event
->kind
== NO_EVENT
)
4125 kbd_fetch_ptr
= event
+ 1;
4126 else if (event
->kind
== HELP_EVENT
)
4128 Lisp_Object object
, position
, help
, frame
, window
;
4130 frame
= event
->frame_or_window
;
4131 object
= event
->arg
;
4132 position
= make_number (event
->code
);
4135 clear_event (event
);
4137 kbd_fetch_ptr
= event
+ 1;
4138 if (!WINDOWP (window
))
4140 obj
= Fcons (Qhelp_echo
,
4141 list5 (frame
, help
, window
, object
, position
));
4143 else if (event
->kind
== FOCUS_IN_EVENT
)
4145 /* Notification of a FocusIn event. The frame receiving the
4146 focus is in event->frame_or_window. Generate a
4147 switch-frame event if necessary. */
4148 Lisp_Object frame
, focus
;
4150 frame
= event
->frame_or_window
;
4151 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4155 if (!EQ (frame
, internal_last_event_frame
)
4156 && !EQ (frame
, selected_frame
))
4157 obj
= make_lispy_switch_frame (frame
);
4158 internal_last_event_frame
= frame
;
4159 kbd_fetch_ptr
= event
+ 1;
4162 else if (event
->kind
== DBUS_EVENT
)
4164 obj
= make_lispy_event (event
);
4165 kbd_fetch_ptr
= event
+ 1;
4168 else if (event
->kind
== CONFIG_CHANGED_EVENT
|| event
->kind
== XWIDGET_EVENT
)
4170 obj
= make_lispy_event (event
);
4171 kbd_fetch_ptr
= event
+ 1;
4175 /* If this event is on a different frame, return a switch-frame this
4176 time, and leave the event in the queue for next time. */
4180 frame
= event
->frame_or_window
;
4182 frame
= XCAR (frame
);
4183 else if (WINDOWP (frame
))
4184 frame
= WINDOW_FRAME (XWINDOW (frame
));
4186 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4190 if (! EQ (frame
, internal_last_event_frame
)
4191 && !EQ (frame
, selected_frame
))
4192 obj
= make_lispy_switch_frame (frame
);
4193 internal_last_event_frame
= frame
;
4195 /* If we didn't decide to make a switch-frame event, go ahead
4196 and build a real event from the queue entry. */
4200 obj
= make_lispy_event (event
);
4202 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
4203 || defined(HAVE_NS) || defined (USE_GTK)
4204 /* If this was a menu selection, then set the flag to inhibit
4205 writing to last_nonmenu_event. Don't do this if the event
4206 we're returning is (menu-bar), though; that indicates the
4207 beginning of the menu sequence, and we might as well leave
4208 that as the `event with parameters' for this selection. */
4210 && !EQ (event
->frame_or_window
, event
->arg
)
4211 && (event
->kind
== MENU_BAR_EVENT
4212 || event
->kind
== TOOL_BAR_EVENT
))
4213 *used_mouse_menu
= 1;
4216 /* certain system events are non-key events */
4218 && event
->kind
== NS_NONKEY_EVENT
)
4219 *used_mouse_menu
= 1;
4222 /* Wipe out this event, to catch bugs. */
4223 clear_event (event
);
4224 kbd_fetch_ptr
= event
+ 1;
4228 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4229 /* Try generating a mouse motion event. */
4230 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4232 FRAME_PTR f
= some_mouse_moved ();
4233 Lisp_Object bar_window
;
4234 enum scroll_bar_part part
;
4238 *kbp
= current_kboard
;
4239 /* Note that this uses F to determine which terminal to look at.
4240 If there is no valid info, it does not store anything
4241 so x remains nil. */
4244 /* XXX Can f or mouse_position_hook be NULL here? */
4245 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4246 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4247 &part
, &x
, &y
, &time
);
4251 /* Decide if we should generate a switch-frame event. Don't
4252 generate switch-frame events for motion outside of all Emacs
4258 frame
= FRAME_FOCUS_FRAME (f
);
4260 XSETFRAME (frame
, f
);
4262 if (! EQ (frame
, internal_last_event_frame
)
4263 && !EQ (frame
, selected_frame
))
4264 obj
= make_lispy_switch_frame (frame
);
4265 internal_last_event_frame
= frame
;
4268 /* If we didn't decide to make a switch-frame event, go ahead and
4269 return a mouse-motion event. */
4270 if (!NILP (x
) && NILP (obj
))
4271 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4273 #endif /* HAVE_MOUSE || HAVE GPM */
4275 /* We were promised by the above while loop that there was
4276 something for us to read! */
4279 input_pending
= readable_events (0);
4281 Vlast_event_frame
= internal_last_event_frame
;
4286 /* Process any events that are not user-visible,
4287 then return, without reading any user-visible events. */
4290 swallow_events (int do_display
)
4294 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4296 struct input_event
*event
;
4298 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4302 last_event_timestamp
= event
->timestamp
;
4304 /* These two kinds of events get special handling
4305 and don't actually appear to the command loop. */
4306 if (event
->kind
== SELECTION_REQUEST_EVENT
4307 || event
->kind
== SELECTION_CLEAR_EVENT
)
4310 struct input_event copy
;
4312 /* Remove it from the buffer before processing it,
4313 since otherwise swallow_events called recursively could see it
4314 and process it again. */
4316 kbd_fetch_ptr
= event
+ 1;
4317 input_pending
= readable_events (0);
4318 x_handle_selection_event (©
);
4320 /* We're getting selection request events, but we don't have
4329 old_timers_run
= timers_run
;
4330 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4332 if (timers_run
!= old_timers_run
&& do_display
)
4333 redisplay_preserve_echo_area (7);
4336 /* Record the start of when Emacs is idle,
4337 for the sake of running idle-time timers. */
4340 timer_start_idle (void)
4344 /* If we are already in the idle state, do nothing. */
4345 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4348 EMACS_GET_TIME (timer_idleness_start_time
);
4350 timer_last_idleness_start_time
= timer_idleness_start_time
;
4352 /* Mark all idle-time timers as once again candidates for running. */
4353 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4357 timer
= XCAR (timers
);
4359 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4361 XVECTOR (timer
)->contents
[0] = Qnil
;
4365 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4368 timer_stop_idle (void)
4370 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4373 /* Resume idle timer from last idle start time. */
4376 timer_resume_idle (void)
4378 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4381 timer_idleness_start_time
= timer_last_idleness_start_time
;
4384 /* This is only for debugging. */
4385 struct input_event last_timer_event
;
4387 /* List of elisp functions to call, delayed because they were generated in
4388 a context where Elisp could not be safely run (e.g. redisplay, signal,
4389 ...). Each element has the form (FUN . ARGS). */
4390 Lisp_Object pending_funcalls
;
4392 /* Check whether a timer has fired. To prevent larger problems we simply
4393 disregard elements that are not proper timers. Do not make a circular
4394 timer list for the time being.
4396 Returns the time to wait until the next timer fires. If a
4397 timer is triggering now, return zero.
4398 If no timer is active, return -1.
4400 If a timer is ripe, we run it, with quitting turned off.
4401 In that case we return 0 to indicate that a new timer_check_2 call
4405 timer_check_2 (void)
4407 EMACS_TIME nexttime
;
4408 EMACS_TIME now
, idleness_now
;
4409 Lisp_Object timers
, idle_timers
, chosen_timer
;
4410 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4412 EMACS_SET_SECS (nexttime
, -1);
4413 EMACS_SET_USECS (nexttime
, -1);
4415 /* Always consider the ordinary timers. */
4416 timers
= Vtimer_list
;
4417 /* Consider the idle timers only if Emacs is idle. */
4418 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4419 idle_timers
= Vtimer_idle_list
;
4422 chosen_timer
= Qnil
;
4423 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4425 /* First run the code that was delayed. */
4426 while (CONSP (pending_funcalls
))
4428 Lisp_Object funcall
= XCAR (pending_funcalls
);
4429 pending_funcalls
= XCDR (pending_funcalls
);
4430 safe_call2 (Qapply
, XCAR (funcall
), XCDR (funcall
));
4433 if (CONSP (timers
) || CONSP (idle_timers
))
4435 EMACS_GET_TIME (now
);
4436 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4437 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4440 while (CONSP (timers
) || CONSP (idle_timers
))
4442 Lisp_Object
*vector
;
4443 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4444 EMACS_TIME timer_time
, idle_timer_time
;
4445 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4447 /* Skip past invalid timers and timers already handled. */
4450 timer
= XCAR (timers
);
4451 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4453 timers
= XCDR (timers
);
4456 vector
= XVECTOR (timer
)->contents
;
4458 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4459 || !INTEGERP (vector
[3])
4460 || ! NILP (vector
[0]))
4462 timers
= XCDR (timers
);
4466 if (!NILP (idle_timers
))
4468 timer
= XCAR (idle_timers
);
4469 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4471 idle_timers
= XCDR (idle_timers
);
4474 vector
= XVECTOR (timer
)->contents
;
4476 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4477 || !INTEGERP (vector
[3])
4478 || ! NILP (vector
[0]))
4480 idle_timers
= XCDR (idle_timers
);
4485 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4486 based on the next ordinary timer.
4487 TIMER_DIFFERENCE is the distance in time from NOW to when
4488 this timer becomes ripe (negative if it's already ripe). */
4491 timer
= XCAR (timers
);
4492 vector
= XVECTOR (timer
)->contents
;
4493 EMACS_SET_SECS (timer_time
,
4494 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4495 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4496 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4499 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4500 based on the next idle timer. */
4501 if (!NILP (idle_timers
))
4503 idle_timer
= XCAR (idle_timers
);
4504 vector
= XVECTOR (idle_timer
)->contents
;
4505 EMACS_SET_SECS (idle_timer_time
,
4506 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4507 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4508 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4511 /* Decide which timer is the next timer,
4512 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4513 Also step down the list where we found that timer. */
4515 if (! NILP (timers
) && ! NILP (idle_timers
))
4518 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4519 if (EMACS_TIME_NEG_P (temp
))
4521 chosen_timer
= timer
;
4522 timers
= XCDR (timers
);
4523 difference
= timer_difference
;
4527 chosen_timer
= idle_timer
;
4528 idle_timers
= XCDR (idle_timers
);
4529 difference
= idle_timer_difference
;
4532 else if (! NILP (timers
))
4534 chosen_timer
= timer
;
4535 timers
= XCDR (timers
);
4536 difference
= timer_difference
;
4540 chosen_timer
= idle_timer
;
4541 idle_timers
= XCDR (idle_timers
);
4542 difference
= idle_timer_difference
;
4544 vector
= XVECTOR (chosen_timer
)->contents
;
4546 /* If timer is ripe, run it if it hasn't been run. */
4547 if (EMACS_TIME_NEG_P (difference
)
4548 || (EMACS_SECS (difference
) == 0
4549 && EMACS_USECS (difference
) == 0))
4551 if (NILP (vector
[0]))
4553 int count
= SPECPDL_INDEX ();
4554 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4556 /* Mark the timer as triggered to prevent problems if the lisp
4557 code fails to reschedule it right. */
4560 specbind (Qinhibit_quit
, Qt
);
4562 call1 (Qtimer_event_handler
, chosen_timer
);
4563 Vdeactivate_mark
= old_deactivate_mark
;
4565 unbind_to (count
, Qnil
);
4567 /* Since we have handled the event,
4568 we don't need to tell the caller to wake up and do it. */
4569 /* But the caller must still wait for the next timer, so
4570 return 0 to indicate that. */
4573 EMACS_SET_SECS (nexttime
, 0);
4574 EMACS_SET_USECS (nexttime
, 0);
4577 /* When we encounter a timer that is still waiting,
4578 return the amount of time to wait before it is ripe. */
4585 /* No timers are pending in the future. */
4586 /* Return 0 if we generated an event, and -1 if not. */
4592 /* Check whether a timer has fired. To prevent larger problems we simply
4593 disregard elements that are not proper timers. Do not make a circular
4594 timer list for the time being.
4596 Returns the time to wait until the next timer fires.
4597 If no timer is active, return -1.
4599 As long as any timer is ripe, we run it.
4601 DO_IT_NOW is now ignored. It used to mean that we should
4602 run the timer directly instead of queueing a timer-event.
4603 Now we always run timers directly. */
4606 timer_check (int do_it_now
)
4608 EMACS_TIME nexttime
;
4612 nexttime
= timer_check_2 ();
4614 while (EMACS_SECS (nexttime
) == 0 && EMACS_USECS (nexttime
) == 0);
4619 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4620 doc
: /* Return the current length of Emacs idleness, or nil.
4621 The value when Emacs is idle is a list of three integers. The first has
4622 the most significant 16 bits of the seconds, while the second has the least
4623 significant 16 bits. The third integer gives the microsecond count.
4625 The value when Emacs is not idle is nil.
4627 The microsecond count is zero on systems that do not provide
4628 resolution finer than a second. */)
4631 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4633 EMACS_TIME now
, idleness_now
;
4635 EMACS_GET_TIME (now
);
4636 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4638 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4639 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4640 make_number (EMACS_USECS (idleness_now
)));
4646 /* Caches for modify_event_symbol. */
4647 static Lisp_Object accent_key_syms
;
4648 static Lisp_Object func_key_syms
;
4649 static Lisp_Object mouse_syms
;
4650 static Lisp_Object wheel_syms
;
4651 static Lisp_Object drag_n_drop_syms
;
4653 /* This is a list of keysym codes for special "accent" characters.
4654 It parallels lispy_accent_keys. */
4656 static const int lispy_accent_codes
[] =
4658 #ifdef XK_dead_circumflex
4663 #ifdef XK_dead_grave
4668 #ifdef XK_dead_tilde
4673 #ifdef XK_dead_diaeresis
4678 #ifdef XK_dead_macron
4683 #ifdef XK_dead_degree
4688 #ifdef XK_dead_acute
4693 #ifdef XK_dead_cedilla
4698 #ifdef XK_dead_breve
4703 #ifdef XK_dead_ogonek
4708 #ifdef XK_dead_caron
4713 #ifdef XK_dead_doubleacute
4714 XK_dead_doubleacute
,
4718 #ifdef XK_dead_abovedot
4723 #ifdef XK_dead_abovering
4733 #ifdef XK_dead_belowdot
4738 #ifdef XK_dead_voiced_sound
4739 XK_dead_voiced_sound
,
4743 #ifdef XK_dead_semivoiced_sound
4744 XK_dead_semivoiced_sound
,
4760 /* This is a list of Lisp names for special "accent" characters.
4761 It parallels lispy_accent_codes. */
4763 static const char *lispy_accent_keys
[] =
4781 "dead-voiced-sound",
4782 "dead-semivoiced-sound",
4788 #define FUNCTION_KEY_OFFSET 0x0
4790 char const *lispy_function_keys
[] =
4794 0, /* VK_LBUTTON 0x01 */
4795 0, /* VK_RBUTTON 0x02 */
4796 "cancel", /* VK_CANCEL 0x03 */
4797 0, /* VK_MBUTTON 0x04 */
4799 0, 0, 0, /* 0x05 .. 0x07 */
4801 "backspace", /* VK_BACK 0x08 */
4802 "tab", /* VK_TAB 0x09 */
4804 0, 0, /* 0x0A .. 0x0B */
4806 "clear", /* VK_CLEAR 0x0C */
4807 "return", /* VK_RETURN 0x0D */
4809 0, 0, /* 0x0E .. 0x0F */
4811 0, /* VK_SHIFT 0x10 */
4812 0, /* VK_CONTROL 0x11 */
4813 0, /* VK_MENU 0x12 */
4814 "pause", /* VK_PAUSE 0x13 */
4815 "capslock", /* VK_CAPITAL 0x14 */
4816 "kana", /* VK_KANA/VK_HANGUL 0x15 */
4818 "junja", /* VK_JUNJA 0x17 */
4819 "final", /* VK_FINAL 0x18 */
4820 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
4822 "escape", /* VK_ESCAPE 0x1B */
4823 "convert", /* VK_CONVERT 0x1C */
4824 "non-convert", /* VK_NONCONVERT 0x1D */
4825 "accept", /* VK_ACCEPT 0x1E */
4826 "mode-change", /* VK_MODECHANGE 0x1F */
4827 0, /* VK_SPACE 0x20 */
4828 "prior", /* VK_PRIOR 0x21 */
4829 "next", /* VK_NEXT 0x22 */
4830 "end", /* VK_END 0x23 */
4831 "home", /* VK_HOME 0x24 */
4832 "left", /* VK_LEFT 0x25 */
4833 "up", /* VK_UP 0x26 */
4834 "right", /* VK_RIGHT 0x27 */
4835 "down", /* VK_DOWN 0x28 */
4836 "select", /* VK_SELECT 0x29 */
4837 "print", /* VK_PRINT 0x2A */
4838 "execute", /* VK_EXECUTE 0x2B */
4839 "snapshot", /* VK_SNAPSHOT 0x2C */
4840 "insert", /* VK_INSERT 0x2D */
4841 "delete", /* VK_DELETE 0x2E */
4842 "help", /* VK_HELP 0x2F */
4844 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4846 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4848 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4850 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4852 0, 0, 0, 0, 0, 0, 0, 0, 0,
4853 0, 0, 0, 0, 0, 0, 0, 0, 0,
4854 0, 0, 0, 0, 0, 0, 0, 0,
4856 "lwindow", /* VK_LWIN 0x5B */
4857 "rwindow", /* VK_RWIN 0x5C */
4858 "apps", /* VK_APPS 0x5D */
4861 "kp-0", /* VK_NUMPAD0 0x60 */
4862 "kp-1", /* VK_NUMPAD1 0x61 */
4863 "kp-2", /* VK_NUMPAD2 0x62 */
4864 "kp-3", /* VK_NUMPAD3 0x63 */
4865 "kp-4", /* VK_NUMPAD4 0x64 */
4866 "kp-5", /* VK_NUMPAD5 0x65 */
4867 "kp-6", /* VK_NUMPAD6 0x66 */
4868 "kp-7", /* VK_NUMPAD7 0x67 */
4869 "kp-8", /* VK_NUMPAD8 0x68 */
4870 "kp-9", /* VK_NUMPAD9 0x69 */
4871 "kp-multiply", /* VK_MULTIPLY 0x6A */
4872 "kp-add", /* VK_ADD 0x6B */
4873 "kp-separator", /* VK_SEPARATOR 0x6C */
4874 "kp-subtract", /* VK_SUBTRACT 0x6D */
4875 "kp-decimal", /* VK_DECIMAL 0x6E */
4876 "kp-divide", /* VK_DIVIDE 0x6F */
4877 "f1", /* VK_F1 0x70 */
4878 "f2", /* VK_F2 0x71 */
4879 "f3", /* VK_F3 0x72 */
4880 "f4", /* VK_F4 0x73 */
4881 "f5", /* VK_F5 0x74 */
4882 "f6", /* VK_F6 0x75 */
4883 "f7", /* VK_F7 0x76 */
4884 "f8", /* VK_F8 0x77 */
4885 "f9", /* VK_F9 0x78 */
4886 "f10", /* VK_F10 0x79 */
4887 "f11", /* VK_F11 0x7A */
4888 "f12", /* VK_F12 0x7B */
4889 "f13", /* VK_F13 0x7C */
4890 "f14", /* VK_F14 0x7D */
4891 "f15", /* VK_F15 0x7E */
4892 "f16", /* VK_F16 0x7F */
4893 "f17", /* VK_F17 0x80 */
4894 "f18", /* VK_F18 0x81 */
4895 "f19", /* VK_F19 0x82 */
4896 "f20", /* VK_F20 0x83 */
4897 "f21", /* VK_F21 0x84 */
4898 "f22", /* VK_F22 0x85 */
4899 "f23", /* VK_F23 0x86 */
4900 "f24", /* VK_F24 0x87 */
4902 0, 0, 0, 0, /* 0x88 .. 0x8B */
4903 0, 0, 0, 0, /* 0x8C .. 0x8F */
4905 "kp-numlock", /* VK_NUMLOCK 0x90 */
4906 "scroll", /* VK_SCROLL 0x91 */
4907 /* Not sure where the following block comes from.
4908 Windows headers have NEC and Fujitsu specific keys in
4909 this block, but nothing generic. */
4910 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4911 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4912 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4913 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4914 "kp-end", /* VK_NUMPAD_END 0x96 */
4915 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4916 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4917 "kp-up", /* VK_NUMPAD_UP 0x99 */
4918 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4919 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4920 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4921 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4923 0, 0, /* 0x9E .. 0x9F */
4926 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4927 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4928 * No other API or message will distinguish left and right keys this way.
4933 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
4934 to enable them selectively, and gives access to a few more functions.
4935 See lispy_multimedia_keys below. */
4936 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
4937 0, 0, 0, /* 0xAD .. 0xAF Volume */
4938 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
4939 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
4941 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
4942 0, 0, 0, 0, 0, 0, 0, 0, 0,
4944 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
4945 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4946 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4949 "ax", /* VK_OEM_AX 0xE1 */
4950 0, /* VK_OEM_102 0xE2 */
4951 "ico-help", /* VK_ICO_HELP 0xE3 */
4952 "ico-00", /* VK_ICO_00 0xE4 */
4953 0, /* VK_PROCESSKEY 0xE5 - used by IME */
4954 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
4955 0, /* VK_PACKET 0xE7 - used to pass unicode chars */
4957 "reset", /* VK_OEM_RESET 0xE9 */
4958 "jump", /* VK_OEM_JUMP 0xEA */
4959 "oem-pa1", /* VK_OEM_PA1 0xEB */
4960 "oem-pa2", /* VK_OEM_PA2 0xEC */
4961 "oem-pa3", /* VK_OEM_PA3 0xED */
4962 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
4963 "cusel", /* VK_OEM_CUSEL 0xEF */
4964 "oem-attn", /* VK_OEM_ATTN 0xF0 */
4965 "finish", /* VK_OEM_FINISH 0xF1 */
4966 "copy", /* VK_OEM_COPY 0xF2 */
4967 "auto", /* VK_OEM_AUTO 0xF3 */
4968 "enlw", /* VK_OEM_ENLW 0xF4 */
4969 "backtab", /* VK_OEM_BACKTAB 0xF5 */
4970 "attn", /* VK_ATTN 0xF6 */
4971 "crsel", /* VK_CRSEL 0xF7 */
4972 "exsel", /* VK_EXSEL 0xF8 */
4973 "ereof", /* VK_EREOF 0xF9 */
4974 "play", /* VK_PLAY 0xFA */
4975 "zoom", /* VK_ZOOM 0xFB */
4976 "noname", /* VK_NONAME 0xFC */
4977 "pa1", /* VK_PA1 0xFD */
4978 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4982 /* Some of these duplicate the "Media keys" on newer keyboards,
4983 but they are delivered to the application in a different way. */
4984 static const char *lispy_multimedia_keys
[] =
4992 "browser-favorites",
5029 "toggle-dictate-command",
5035 "media-fast-forward",
5038 "media-channel-down"
5041 #else /* not HAVE_NTGUI */
5043 /* This should be dealt with in XTread_socket now, and that doesn't
5044 depend on the client system having the Kana syms defined. See also
5045 the XK_kana_A case below. */
5048 static const char *lispy_kana_keys
[] =
5050 /* X Keysym value */
5051 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
5052 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
5053 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
5054 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
5055 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
5056 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
5057 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
5058 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
5059 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
5060 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
5061 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
5062 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
5063 "kana-i", "kana-u", "kana-e", "kana-o",
5064 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
5065 "prolongedsound", "kana-A", "kana-I", "kana-U",
5066 "kana-E", "kana-O", "kana-KA", "kana-KI",
5067 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
5068 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
5069 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
5070 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
5071 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
5072 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
5073 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
5074 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
5075 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
5076 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
5077 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
5078 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
5080 #endif /* XK_kana_A */
5083 #define FUNCTION_KEY_OFFSET 0xff00
5085 /* You'll notice that this table is arranged to be conveniently
5086 indexed by X Windows keysym values. */
5087 static const char *lispy_function_keys
[] =
5089 /* X Keysym value */
5091 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
5092 "backspace", "tab", "linefeed", "clear",
5094 0, 0, 0, "pause", /* 0xff10...1f */
5095 0, 0, 0, 0, 0, 0, 0, "escape",
5097 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
5098 "romaji", "hiragana", "katakana", "hiragana-katakana",
5099 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
5100 "massyo", "kana-lock", "kana-shift", "eisu-shift",
5101 "eisu-toggle", /* 0xff30...3f */
5102 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5103 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
5105 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
5106 "down", "prior", "next", "end",
5107 "begin", 0, 0, 0, 0, 0, 0, 0,
5108 "select", /* 0xff60 */ /* IsMiscFunctionKey */
5119 "break", /* 0xff6b */
5122 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
5123 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
5124 "kp-space", /* 0xff80 */ /* IsKeypadKey */
5125 0, 0, 0, 0, 0, 0, 0, 0,
5126 "kp-tab", /* 0xff89 */
5128 "kp-enter", /* 0xff8d */
5130 "kp-f1", /* 0xff91 */
5134 "kp-home", /* 0xff95 */
5139 "kp-prior", /* kp-page-up */
5140 "kp-next", /* kp-page-down */
5146 0, 0, 0, 0, 0, 0, 0, 0, 0,
5147 "kp-multiply", /* 0xffaa */
5152 "kp-divide", /* 0xffaf */
5153 "kp-0", /* 0xffb0 */
5154 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
5157 "kp-equal", /* 0xffbd */
5158 "f1", /* 0xffbe */ /* IsFunctionKey */
5160 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
5161 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
5162 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
5163 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
5164 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
5165 0, 0, 0, 0, 0, 0, 0, 0,
5166 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
5167 0, 0, 0, 0, 0, 0, 0, "delete"
5170 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
5171 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
5173 static const char *iso_lispy_function_keys
[] =
5175 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
5176 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
5177 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
5178 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
5179 "iso-lefttab", /* 0xfe20 */
5180 "iso-move-line-up", "iso-move-line-down",
5181 "iso-partial-line-up", "iso-partial-line-down",
5182 "iso-partial-space-left", "iso-partial-space-right",
5183 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
5184 "iso-release-margin-left", "iso-release-margin-right",
5185 "iso-release-both-margins",
5186 "iso-fast-cursor-left", "iso-fast-cursor-right",
5187 "iso-fast-cursor-up", "iso-fast-cursor-down",
5188 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
5189 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
5192 #endif /* not HAVE_NTGUI */
5194 Lisp_Object Vlispy_mouse_stem
;
5196 static const char *lispy_wheel_names
[] =
5198 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
5201 /* drag-n-drop events are generated when a set of selected files are
5202 dragged from another application and dropped onto an Emacs window. */
5203 static const char *lispy_drag_n_drop_names
[] =
5208 /* Scroll bar parts. */
5209 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5210 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5211 Lisp_Object Qtop
, Qratio
;
5213 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5214 const Lisp_Object
*scroll_bar_parts
[] = {
5215 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5216 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5219 /* A vector, indexed by button number, giving the down-going location
5220 of currently depressed buttons, both scroll bar and non-scroll bar.
5222 The elements have the form
5223 (BUTTON-NUMBER MODIFIER-MASK . REST)
5224 where REST is the cdr of a position as it would be reported in the event.
5226 The make_lispy_event function stores positions here to tell the
5227 difference between click and drag events, and to store the starting
5228 location to be included in drag events. */
5230 static Lisp_Object button_down_location
;
5232 /* Information about the most recent up-going button event: Which
5233 button, what location, and what time. */
5235 static int last_mouse_button
;
5236 static int last_mouse_x
;
5237 static int last_mouse_y
;
5238 static unsigned long button_down_time
;
5240 /* The maximum time between clicks to make a double-click, or Qnil to
5241 disable double-click detection, or Qt for no time limit. */
5243 Lisp_Object Vdouble_click_time
;
5245 /* Maximum number of pixels the mouse may be moved between clicks
5246 to make a double-click. */
5248 EMACS_INT double_click_fuzz
;
5250 /* The number of clicks in this multiple-click. */
5252 int double_click_count
;
5254 /* Return position of a mouse click or wheel event */
5257 make_lispy_position (struct frame
*f
, Lisp_Object
*x
, Lisp_Object
*y
,
5261 enum window_part part
;
5262 Lisp_Object posn
= Qnil
;
5263 Lisp_Object extra_info
= Qnil
;
5266 /* Set `window' to the window under frame pixel coordinates (x,y) */
5268 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5269 &part
, &wx
, &wy
, 0);
5273 if (WINDOWP (window
))
5275 /* It's a click in window window at frame coordinates (x,y) */
5276 struct window
*w
= XWINDOW (window
);
5277 Lisp_Object string_info
= Qnil
;
5278 int textpos
= -1, rx
= -1, ry
= -1;
5279 int dx
= -1, dy
= -1;
5280 int width
= -1, height
= -1;
5281 Lisp_Object object
= Qnil
;
5283 /* Set event coordinates to window-relative coordinates
5284 for constructing the Lisp event below. */
5288 if (part
== ON_TEXT
)
5290 wx
+= WINDOW_LEFT_MARGIN_WIDTH (w
);
5292 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5294 /* Mode line or header line. Look for a string under
5295 the mouse that may have a `local-map' property. */
5299 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5301 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5302 &object
, &dx
, &dy
, &width
, &height
);
5303 if (STRINGP (string
))
5304 string_info
= Fcons (string
, make_number (charpos
));
5305 if (w
== XWINDOW (selected_window
)
5306 && current_buffer
== XBUFFER (w
->buffer
))
5309 textpos
= XMARKER (w
->pointm
)->charpos
;
5311 else if (part
== ON_VERTICAL_BORDER
)
5313 posn
= Qvertical_line
;
5318 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5323 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5325 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5326 &object
, &dx
, &dy
, &width
, &height
);
5327 if (STRINGP (string
))
5328 string_info
= Fcons (string
, make_number (charpos
));
5329 if (part
== ON_LEFT_MARGIN
)
5332 wx
= window_box_right_offset (w
, TEXT_AREA
) - 1;
5334 else if (part
== ON_LEFT_FRINGE
)
5336 posn
= Qleft_fringe
;
5339 wx
= (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5341 : window_box_width (w
, LEFT_MARGIN_AREA
));
5344 else if (part
== ON_RIGHT_FRINGE
)
5346 posn
= Qright_fringe
;
5349 wx
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5350 + window_box_width (w
, TEXT_AREA
)
5351 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5352 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5358 /* Note: We have no special posn for part == ON_SCROLL_BAR. */
5359 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5364 Lisp_Object string2
, object2
= Qnil
;
5365 struct display_pos p
;
5367 int width2
, height2
;
5368 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5369 &object2
, &dx2
, &dy2
,
5371 textpos
= CHARPOS (p
.pos
);
5372 if (rx
< 0) rx
= wx
;
5373 if (ry
< 0) ry
= wy
;
5374 if (dx
< 0) dx
= dx2
;
5375 if (dy
< 0) dy
= dy2
;
5376 if (width
< 0) width
= width2
;
5377 if (height
< 0) height
= height2
;
5381 posn
= make_number (textpos
);
5382 if (STRINGP (string2
))
5383 string_info
= Fcons (string2
,
5384 make_number (CHARPOS (p
.string_pos
)));
5390 #ifdef HAVE_WINDOW_SYSTEM
5391 if (IMAGEP (object
))
5393 Lisp_Object image_map
, hotspot
;
5394 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5396 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5398 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5399 posn
= XCAR (hotspot
);
5404 extra_info
= Fcons (object
,
5405 Fcons (Fcons (make_number (dx
),
5407 Fcons (Fcons (make_number (width
),
5408 make_number (height
)),
5412 extra_info
= Fcons (string_info
,
5413 Fcons (make_number (textpos
),
5414 Fcons (Fcons (make_number (rx
),
5420 XSETFRAME (window
, f
);
5425 XSETFASTINT (*x
, 0);
5426 XSETFASTINT (*y
, 0);
5429 return Fcons (window
,
5431 Fcons (Fcons (*x
, *y
),
5432 Fcons (make_number (time
),
5436 /* Given a struct input_event, build the lisp event which represents
5437 it. If EVENT is 0, build a mouse movement event from the mouse
5438 movement buffer, which should have a movement event in it.
5440 Note that events must be passed to this function in the order they
5441 are received; this function stores the location of button presses
5442 in order to build drag events when the button is released. */
5445 make_lispy_event (struct input_event
*event
)
5449 switch (SWITCH_ENUM_CAST (event
->kind
))
5451 /* A simple keystroke. */
5452 case ASCII_KEYSTROKE_EVENT
:
5453 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5455 Lisp_Object lispy_c
;
5456 int c
= event
->code
;
5457 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
5460 eassert (c
== event
->code
);
5461 /* Turn ASCII characters into control characters
5463 if (event
->modifiers
& ctrl_modifier
)
5465 c
= make_ctrl_char (c
);
5466 event
->modifiers
&= ~ctrl_modifier
;
5470 /* Add in the other modifier bits. The shift key was taken care
5471 of by the X code. */
5472 c
|= (event
->modifiers
5473 & (meta_modifier
| alt_modifier
5474 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5475 /* Distinguish Shift-SPC from SPC. */
5476 if ((event
->code
) == 040
5477 && event
->modifiers
& shift_modifier
)
5478 c
|= shift_modifier
;
5479 button_down_time
= 0;
5480 XSETFASTINT (lispy_c
, c
);
5485 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5486 except that they are non-key events (last-nonmenu-event is nil). */
5487 case NS_NONKEY_EVENT
:
5490 /* A function key. The symbol may need to have modifier prefixes
5492 case NON_ASCII_KEYSTROKE_EVENT
:
5493 button_down_time
= 0;
5495 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5496 if (event
->code
== lispy_accent_codes
[i
])
5497 return modify_event_symbol (i
,
5499 Qfunction_key
, Qnil
,
5500 lispy_accent_keys
, &accent_key_syms
,
5501 (sizeof (lispy_accent_keys
)
5502 / sizeof (lispy_accent_keys
[0])));
5506 if (event
->code
>= 0x400 && event
->code
< 0x500)
5507 return modify_event_symbol (event
->code
- 0x400,
5508 event
->modifiers
& ~shift_modifier
,
5509 Qfunction_key
, Qnil
,
5510 lispy_kana_keys
, &func_key_syms
,
5511 (sizeof (lispy_kana_keys
)
5512 / sizeof (lispy_kana_keys
[0])));
5513 #endif /* XK_kana_A */
5516 #ifdef ISO_FUNCTION_KEY_OFFSET
5517 if (event
->code
< FUNCTION_KEY_OFFSET
5518 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5519 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5521 Qfunction_key
, Qnil
,
5522 iso_lispy_function_keys
, &func_key_syms
,
5523 (sizeof (iso_lispy_function_keys
)
5524 / sizeof (iso_lispy_function_keys
[0])));
5527 /* Handle system-specific or unknown keysyms. */
5528 if (event
->code
& (1 << 28)
5529 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5530 || (event
->code
- FUNCTION_KEY_OFFSET
5531 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5532 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5534 /* We need to use an alist rather than a vector as the cache
5535 since we can't make a vector long enuf. */
5536 if (NILP (current_kboard
->system_key_syms
))
5537 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5538 return modify_event_symbol (event
->code
,
5541 current_kboard
->Vsystem_key_alist
,
5542 0, ¤t_kboard
->system_key_syms
,
5546 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5548 Qfunction_key
, Qnil
,
5549 lispy_function_keys
, &func_key_syms
,
5550 (sizeof (lispy_function_keys
)
5551 / sizeof (lispy_function_keys
[0])));
5554 case MULTIMEDIA_KEY_EVENT
:
5555 if (event
->code
< (sizeof (lispy_multimedia_keys
)
5556 / sizeof (lispy_multimedia_keys
[0]))
5557 && event
->code
> 0 && lispy_multimedia_keys
[event
->code
])
5559 return modify_event_symbol (event
->code
, event
->modifiers
,
5560 Qfunction_key
, Qnil
,
5561 lispy_multimedia_keys
, &func_key_syms
,
5562 (sizeof (lispy_multimedia_keys
)
5563 / sizeof (lispy_multimedia_keys
[0])));
5569 /* A mouse click. Figure out where it is, decide whether it's
5570 a press, click or drag, and build the appropriate structure. */
5571 case MOUSE_CLICK_EVENT
:
5572 #ifndef USE_TOOLKIT_SCROLL_BARS
5573 case SCROLL_BAR_CLICK_EVENT
:
5576 int button
= event
->code
;
5578 Lisp_Object position
;
5579 Lisp_Object
*start_pos_ptr
;
5580 Lisp_Object start_pos
;
5584 /* Build the position as appropriate for this mouse click. */
5585 if (event
->kind
== MOUSE_CLICK_EVENT
)
5587 struct frame
*f
= XFRAME (event
->frame_or_window
);
5588 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5592 /* Ignore mouse events that were made on frame that
5593 have been deleted. */
5594 if (! FRAME_LIVE_P (f
))
5597 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5598 /* EVENT->x and EVENT->y are frame-relative pixel
5599 coordinates at this place. Under old redisplay, COLUMN
5600 and ROW are set to frame relative glyph coordinates
5601 which are then used to determine whether this click is
5602 in a menu (non-toolkit version). */
5603 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5604 &column
, &row
, NULL
, 1);
5606 /* In the non-toolkit version, clicks on the menu bar
5607 are ordinary button events in the event buffer.
5608 Distinguish them, and invoke the menu.
5610 (In the toolkit version, the toolkit handles the menu bar
5611 and Emacs doesn't know about it until after the user
5612 makes a selection.) */
5613 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5614 && (event
->modifiers
& down_modifier
))
5616 Lisp_Object items
, item
;
5621 /* Activate the menu bar on the down event. If the
5622 up event comes in before the menu code can deal with it,
5624 if (! (event
->modifiers
& down_modifier
))
5628 /* Find the menu bar item under `column'. */
5630 items
= FRAME_MENU_BAR_ITEMS (f
);
5631 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5633 Lisp_Object pos
, string
;
5634 string
= AREF (items
, i
+ 1);
5635 pos
= AREF (items
, i
+ 3);
5638 if (column
>= XINT (pos
)
5639 && column
< XINT (pos
) + SCHARS (string
))
5641 item
= AREF (items
, i
);
5646 /* ELisp manual 2.4b says (x y) are window relative but
5647 code says they are frame-relative. */
5649 = Fcons (event
->frame_or_window
,
5651 Fcons (Fcons (event
->x
, event
->y
),
5652 Fcons (make_number (event
->timestamp
),
5655 return Fcons (item
, Fcons (position
, Qnil
));
5657 #endif /* not USE_X_TOOLKIT && not USE_GTK && not HAVE_NS */
5659 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5662 #ifndef USE_TOOLKIT_SCROLL_BARS
5665 /* It's a scrollbar click. */
5667 Lisp_Object portion_whole
;
5670 window
= event
->frame_or_window
;
5671 portion_whole
= Fcons (event
->x
, event
->y
);
5672 part
= *scroll_bar_parts
[(int) event
->part
];
5676 Fcons (Qvertical_scroll_bar
,
5677 Fcons (portion_whole
,
5678 Fcons (make_number (event
->timestamp
),
5679 Fcons (part
, Qnil
)))));
5681 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5683 if (button
>= ASIZE (button_down_location
))
5685 button_down_location
= larger_vector (button_down_location
,
5687 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5690 start_pos_ptr
= &AREF (button_down_location
, button
);
5691 start_pos
= *start_pos_ptr
;
5692 *start_pos_ptr
= Qnil
;
5695 /* On window-system frames, use the value of
5696 double-click-fuzz as is. On other frames, interpret it
5697 as a multiple of 1/8 characters. */
5701 if (WINDOWP (event
->frame_or_window
))
5702 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5703 else if (FRAMEP (event
->frame_or_window
))
5704 f
= XFRAME (event
->frame_or_window
);
5708 if (FRAME_WINDOW_P (f
))
5709 fuzz
= double_click_fuzz
;
5711 fuzz
= double_click_fuzz
/ 8;
5713 is_double
= (button
== last_mouse_button
5714 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5715 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5716 && button_down_time
!= 0
5717 && (EQ (Vdouble_click_time
, Qt
)
5718 || (INTEGERP (Vdouble_click_time
)
5719 && ((int)(event
->timestamp
- button_down_time
)
5720 < XINT (Vdouble_click_time
)))));
5723 last_mouse_button
= button
;
5724 last_mouse_x
= XINT (event
->x
);
5725 last_mouse_y
= XINT (event
->y
);
5727 /* If this is a button press, squirrel away the location, so
5728 we can decide later whether it was a click or a drag. */
5729 if (event
->modifiers
& down_modifier
)
5733 double_click_count
++;
5734 event
->modifiers
|= ((double_click_count
> 2)
5739 double_click_count
= 1;
5740 button_down_time
= event
->timestamp
;
5741 *start_pos_ptr
= Fcopy_alist (position
);
5742 ignore_mouse_drag_p
= 0;
5745 /* Now we're releasing a button - check the co-ordinates to
5746 see if this was a click or a drag. */
5747 else if (event
->modifiers
& up_modifier
)
5749 /* If we did not see a down before this up, ignore the up.
5750 Probably this happened because the down event chose a
5751 menu item. It would be an annoyance to treat the
5752 release of the button that chose the menu item as a
5755 if (!CONSP (start_pos
))
5758 event
->modifiers
&= ~up_modifier
;
5759 #if 0 /* Formerly we treated an up with no down as a click event. */
5760 if (!CONSP (start_pos
))
5761 event
->modifiers
|= click_modifier
;
5766 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5768 /* The third element of every position
5769 should be the (x,y) pair. */
5770 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5772 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5774 xdiff
= XINT (event
->x
) - XINT (XCAR (down
));
5775 ydiff
= XINT (event
->y
) - XINT (XCDR (down
));
5778 if (ignore_mouse_drag_p
)
5780 event
->modifiers
|= click_modifier
;
5781 ignore_mouse_drag_p
= 0;
5783 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5784 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5785 /* Maybe the mouse has moved a lot, caused scrolling, and
5786 eventually ended up at the same screen position (but
5787 not buffer position) in which case it is a drag, not
5789 /* FIXME: OTOH if the buffer position has changed
5790 because of a timer or process filter rather than
5791 because of mouse movement, it should be considered as
5792 a click. But mouse-drag-region completely ignores
5793 this case and it hasn't caused any real problem, so
5794 it's probably OK to ignore it as well. */
5795 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5796 /* Mouse hasn't moved (much). */
5797 event
->modifiers
|= click_modifier
;
5800 button_down_time
= 0;
5801 event
->modifiers
|= drag_modifier
;
5804 /* Don't check is_double; treat this as multiple
5805 if the down-event was multiple. */
5806 if (double_click_count
> 1)
5807 event
->modifiers
|= ((double_click_count
> 2)
5813 /* Every mouse event should either have the down_modifier or
5814 the up_modifier set. */
5818 /* Get the symbol we should use for the mouse click. */
5821 head
= modify_event_symbol (button
,
5823 Qmouse_click
, Vlispy_mouse_stem
,
5826 XVECTOR (mouse_syms
)->size
);
5827 if (event
->modifiers
& drag_modifier
)
5832 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5835 Fcons (make_number (double_click_count
),
5845 case HORIZ_WHEEL_EVENT
:
5847 Lisp_Object position
;
5850 /* Build the position as appropriate for this mouse click. */
5851 struct frame
*f
= XFRAME (event
->frame_or_window
);
5853 /* Ignore wheel events that were made on frame that have been
5855 if (! FRAME_LIVE_P (f
))
5858 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5861 /* Set double or triple modifiers to indicate the wheel speed. */
5863 /* On window-system frames, use the value of
5864 double-click-fuzz as is. On other frames, interpret it
5865 as a multiple of 1/8 characters. */
5871 if (WINDOWP (event
->frame_or_window
))
5872 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5873 else if (FRAMEP (event
->frame_or_window
))
5874 f
= XFRAME (event
->frame_or_window
);
5878 if (FRAME_WINDOW_P (f
))
5879 fuzz
= double_click_fuzz
;
5881 fuzz
= double_click_fuzz
/ 8;
5883 if (event
->modifiers
& up_modifier
)
5885 /* Emit a wheel-up event. */
5886 event
->modifiers
&= ~up_modifier
;
5889 else if (event
->modifiers
& down_modifier
)
5891 /* Emit a wheel-down event. */
5892 event
->modifiers
&= ~down_modifier
;
5896 /* Every wheel event should either have the down_modifier or
5897 the up_modifier set. */
5900 if (event
->kind
== HORIZ_WHEEL_EVENT
)
5903 is_double
= (last_mouse_button
== - (1 + symbol_num
)
5904 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5905 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5906 && button_down_time
!= 0
5907 && (EQ (Vdouble_click_time
, Qt
)
5908 || (INTEGERP (Vdouble_click_time
)
5909 && ((int)(event
->timestamp
- button_down_time
)
5910 < XINT (Vdouble_click_time
)))));
5913 double_click_count
++;
5914 event
->modifiers
|= ((double_click_count
> 2)
5920 double_click_count
= 1;
5921 event
->modifiers
|= click_modifier
;
5924 button_down_time
= event
->timestamp
;
5925 /* Use a negative value to distinguish wheel from mouse button. */
5926 last_mouse_button
= - (1 + symbol_num
);
5927 last_mouse_x
= XINT (event
->x
);
5928 last_mouse_y
= XINT (event
->y
);
5930 /* Get the symbol we should use for the wheel event. */
5931 head
= modify_event_symbol (symbol_num
,
5937 ASIZE (wheel_syms
));
5940 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5943 Fcons (make_number (double_click_count
),
5952 #ifdef USE_TOOLKIT_SCROLL_BARS
5954 /* We don't have down and up events if using toolkit scroll bars,
5955 so make this always a click event. Store in the `part' of
5956 the Lisp event a symbol which maps to the following actions:
5958 `above_handle' page up
5959 `below_handle' page down
5963 `bottom' bottom of buffer
5964 `handle' thumb has been dragged.
5965 `end-scroll' end of interaction with scroll bar
5967 The incoming input_event contains in its `part' member an
5968 index of type `enum scroll_bar_part' which we can use as an
5969 index in scroll_bar_parts to get the appropriate symbol. */
5971 case SCROLL_BAR_CLICK_EVENT
:
5973 Lisp_Object position
, head
, window
, portion_whole
, part
;
5975 window
= event
->frame_or_window
;
5976 portion_whole
= Fcons (event
->x
, event
->y
);
5977 part
= *scroll_bar_parts
[(int) event
->part
];
5981 Fcons (Qvertical_scroll_bar
,
5982 Fcons (portion_whole
,
5983 Fcons (make_number (event
->timestamp
),
5984 Fcons (part
, Qnil
)))));
5986 /* Always treat scroll bar events as clicks. */
5987 event
->modifiers
|= click_modifier
;
5988 event
->modifiers
&= ~up_modifier
;
5990 if (event
->code
>= ASIZE (mouse_syms
))
5991 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5993 /* Get the symbol we should use for the mouse click. */
5994 head
= modify_event_symbol (event
->code
,
5999 XVECTOR (mouse_syms
)->size
);
6000 return Fcons (head
, Fcons (position
, Qnil
));
6003 #endif /* USE_TOOLKIT_SCROLL_BARS */
6005 case DRAG_N_DROP_EVENT
:
6008 Lisp_Object head
, position
;
6011 f
= XFRAME (event
->frame_or_window
);
6014 /* Ignore mouse events that were made on frames that
6015 have been deleted. */
6016 if (! FRAME_LIVE_P (f
))
6019 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6022 head
= modify_event_symbol (0, event
->modifiers
,
6024 lispy_drag_n_drop_names
,
6025 &drag_n_drop_syms
, 1);
6031 #endif /* HAVE_MOUSE */
6033 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
6034 || defined(HAVE_NS) || defined (USE_GTK)
6035 case MENU_BAR_EVENT
:
6036 if (EQ (event
->arg
, event
->frame_or_window
))
6037 /* This is the prefix key. We translate this to
6038 `(menu_bar)' because the code in keyboard.c for menu
6039 events, which we use, relies on this. */
6040 return Fcons (Qmenu_bar
, Qnil
);
6044 case SELECT_WINDOW_EVENT
:
6045 /* Make an event (select-window (WINDOW)). */
6046 return Fcons (Qselect_window
,
6047 Fcons (Fcons (event
->frame_or_window
, Qnil
),
6050 case TOOL_BAR_EVENT
:
6051 if (EQ (event
->arg
, event
->frame_or_window
))
6052 /* This is the prefix key. We translate this to
6053 `(tool_bar)' because the code in keyboard.c for tool bar
6054 events, which we use, relies on this. */
6055 return Fcons (Qtool_bar
, Qnil
);
6056 else if (SYMBOLP (event
->arg
))
6057 return apply_modifiers (event
->modifiers
, event
->arg
);
6062 case USER_SIGNAL_EVENT
:
6063 /* A user signal. */
6065 char *name
= find_user_signal_name (event
->code
);
6068 return intern (name
);
6071 case SAVE_SESSION_EVENT
:
6072 return Qsave_session
;
6077 return Fcons (Qdbus_event
, event
->arg
);
6079 #endif /* HAVE_DBUS */
6082 printf("cool, an xwidget event arrived in make_lispy_event!\n");
6083 return Fcons (Qxwidget_event
,event
->arg
);
6086 case CONFIG_CHANGED_EVENT
:
6087 return Fcons (Qconfig_changed_event
,
6089 Fcons (event
->frame_or_window
, Qnil
)));
6091 case GPM_CLICK_EVENT
:
6093 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
6094 Lisp_Object head
, position
;
6095 Lisp_Object
*start_pos_ptr
;
6096 Lisp_Object start_pos
;
6097 int button
= event
->code
;
6099 if (button
>= ASIZE (button_down_location
))
6101 button_down_location
= larger_vector (button_down_location
,
6103 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
6106 start_pos_ptr
= &AREF (button_down_location
, button
);
6107 start_pos
= *start_pos_ptr
;
6109 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
6112 if (event
->modifiers
& down_modifier
)
6113 *start_pos_ptr
= Fcopy_alist (position
);
6114 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
6116 if (!CONSP (start_pos
))
6118 event
->modifiers
&= ~up_modifier
;
6121 head
= modify_event_symbol (button
,
6123 Qmouse_click
, Vlispy_mouse_stem
,
6126 XVECTOR (mouse_syms
)->size
);
6128 if (event
->modifiers
& drag_modifier
)
6133 else if (event
->modifiers
& double_modifier
)
6136 Fcons (make_number (2),
6138 else if (event
->modifiers
& triple_modifier
)
6141 Fcons (make_number (3),
6148 #endif /* HAVE_GPM */
6150 /* The 'kind' field of the event is something we don't recognize. */
6156 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
6159 make_lispy_movement (FRAME_PTR frame
, Lisp_Object bar_window
, enum scroll_bar_part part
,
6160 Lisp_Object x
, Lisp_Object y
, unsigned long time
)
6162 /* Is it a scroll bar movement? */
6163 if (frame
&& ! NILP (bar_window
))
6165 Lisp_Object part_sym
;
6167 part_sym
= *scroll_bar_parts
[(int) part
];
6168 return Fcons (Qscroll_bar_movement
,
6169 (Fcons (Fcons (bar_window
,
6170 Fcons (Qvertical_scroll_bar
,
6171 Fcons (Fcons (x
, y
),
6172 Fcons (make_number (time
),
6178 /* Or is it an ordinary mouse movement? */
6181 Lisp_Object position
;
6183 position
= make_lispy_position (frame
, &x
, &y
, time
);
6185 return Fcons (Qmouse_movement
,
6191 #endif /* HAVE_MOUSE || HAVE GPM */
6193 /* Construct a switch frame event. */
6195 make_lispy_switch_frame (Lisp_Object frame
)
6197 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
6200 /* Manipulating modifiers. */
6202 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
6204 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
6205 SYMBOL's name of the end of the modifiers; the string from this
6206 position is the unmodified symbol name.
6208 This doesn't use any caches. */
6211 parse_modifiers_uncached (Lisp_Object symbol
, int *modifier_end
)
6217 CHECK_SYMBOL (symbol
);
6220 name
= SYMBOL_NAME (symbol
);
6222 for (i
= 0; i
+2 <= SBYTES (name
); )
6224 int this_mod_end
= 0;
6227 /* See if the name continues with a modifier word.
6228 Check that the word appears, but don't check what follows it.
6229 Set this_mod and this_mod_end to record what we find. */
6231 switch (SREF (name
, i
))
6233 #define SINGLE_LETTER_MOD(BIT) \
6234 (this_mod_end = i + 1, this_mod = BIT)
6237 SINGLE_LETTER_MOD (alt_modifier
);
6241 SINGLE_LETTER_MOD (ctrl_modifier
);
6245 SINGLE_LETTER_MOD (hyper_modifier
);
6249 SINGLE_LETTER_MOD (meta_modifier
);
6253 SINGLE_LETTER_MOD (shift_modifier
);
6257 SINGLE_LETTER_MOD (super_modifier
);
6260 #undef SINGLE_LETTER_MOD
6262 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6263 if (i + LEN + 1 <= SBYTES (name) \
6264 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
6266 this_mod_end = i + LEN; \
6271 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6272 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6273 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6277 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6279 #undef MULTI_LETTER_MOD
6283 /* If we found no modifier, stop looking for them. */
6284 if (this_mod_end
== 0)
6287 /* Check there is a dash after the modifier, so that it
6288 really is a modifier. */
6289 if (this_mod_end
>= SBYTES (name
)
6290 || SREF (name
, this_mod_end
) != '-')
6293 /* This modifier is real; look for another. */
6294 modifiers
|= this_mod
;
6295 i
= this_mod_end
+ 1;
6298 /* Should we include the `click' modifier? */
6299 if (! (modifiers
& (down_modifier
| drag_modifier
6300 | double_modifier
| triple_modifier
))
6301 && i
+ 7 == SBYTES (name
)
6302 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
6303 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6304 modifiers
|= click_modifier
;
6306 if (! (modifiers
& (double_modifier
| triple_modifier
))
6307 && i
+ 6 < SBYTES (name
)
6308 && strncmp (SDATA (name
) + i
, "wheel-", 6) == 0)
6309 modifiers
|= click_modifier
;
6317 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6318 prepended to the string BASE[0..BASE_LEN-1].
6319 This doesn't use any caches. */
6321 apply_modifiers_uncached (int modifiers
, char *base
, int base_len
, int base_len_byte
)
6323 /* Since BASE could contain nulls, we can't use intern here; we have
6324 to use Fintern, which expects a genuine Lisp_String, and keeps a
6327 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6333 /* Only the event queue may use the `up' modifier; it should always
6334 be turned into a click or drag event before presented to lisp code. */
6335 if (modifiers
& up_modifier
)
6338 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6339 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6340 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6341 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6342 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6343 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6344 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6345 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6346 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6347 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6348 /* The click modifier is denoted by the absence of other modifiers. */
6352 mod_len
= p
- new_mods
;
6356 Lisp_Object new_name
;
6358 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6359 mod_len
+ base_len_byte
);
6360 memcpy (SDATA (new_name
), new_mods
, mod_len
);
6361 memcpy (SDATA (new_name
) + mod_len
, base
, base_len_byte
);
6363 return Fintern (new_name
, Qnil
);
6368 static const char *modifier_names
[] =
6370 "up", "down", "drag", "click", "double", "triple", 0, 0,
6371 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6372 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6374 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6376 static Lisp_Object modifier_symbols
;
6378 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6380 lispy_modifier_list (int modifiers
)
6382 Lisp_Object modifier_list
;
6385 modifier_list
= Qnil
;
6386 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6387 if (modifiers
& (1<<i
))
6388 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6391 return modifier_list
;
6395 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6396 where UNMODIFIED is the unmodified form of SYMBOL,
6397 MASK is the set of modifiers present in SYMBOL's name.
6398 This is similar to parse_modifiers_uncached, but uses the cache in
6399 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6400 Qevent_symbol_elements property. */
6402 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6405 parse_modifiers (Lisp_Object symbol
)
6407 Lisp_Object elements
;
6409 if (INTEGERP (symbol
))
6410 return (Fcons (make_number (KEY_TO_CHAR (symbol
)),
6411 Fcons (make_number (XINT (symbol
) & CHAR_MODIFIER_MASK
),
6413 else if (!SYMBOLP (symbol
))
6416 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6417 if (CONSP (elements
))
6422 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6423 Lisp_Object unmodified
;
6426 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6427 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6430 if (modifiers
& ~INTMASK
)
6432 XSETFASTINT (mask
, modifiers
);
6433 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6435 /* Cache the parsing results on SYMBOL. */
6436 Fput (symbol
, Qevent_symbol_element_mask
,
6438 Fput (symbol
, Qevent_symbol_elements
,
6439 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6441 /* Since we know that SYMBOL is modifiers applied to unmodified,
6442 it would be nice to put that in unmodified's cache.
6443 But we can't, since we're not sure that parse_modifiers is
6450 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers
,
6451 Sevent_symbol_parse_modifiers
, 1, 1, 0,
6452 doc
: /* Parse the event symbol. For internal use. */)
6453 (Lisp_Object symbol
)
6455 /* Fill the cache if needed. */
6456 parse_modifiers (symbol
);
6457 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6458 and use the Lispier representation stored on Qevent_symbol_elements
6460 return Fget (symbol
, Qevent_symbol_elements
);
6463 /* Apply the modifiers MODIFIERS to the symbol BASE.
6464 BASE must be unmodified.
6466 This is like apply_modifiers_uncached, but uses BASE's
6467 Qmodifier_cache property, if present. It also builds
6468 Qevent_symbol_elements properties, since it has that info anyway.
6470 apply_modifiers copies the value of BASE's Qevent_kind property to
6471 the modified symbol. */
6473 apply_modifiers (int modifiers
, Lisp_Object base
)
6475 Lisp_Object cache
, index
, entry
, new_symbol
;
6477 /* Mask out upper bits. We don't know where this value's been. */
6478 modifiers
&= INTMASK
;
6480 if (INTEGERP (base
))
6481 return make_number (XINT (base
) | modifiers
);
6483 /* The click modifier never figures into cache indices. */
6484 cache
= Fget (base
, Qmodifier_cache
);
6485 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6486 entry
= assq_no_quit (index
, cache
);
6489 new_symbol
= XCDR (entry
);
6492 /* We have to create the symbol ourselves. */
6493 new_symbol
= apply_modifiers_uncached (modifiers
,
6494 SDATA (SYMBOL_NAME (base
)),
6495 SCHARS (SYMBOL_NAME (base
)),
6496 SBYTES (SYMBOL_NAME (base
)));
6498 /* Add the new symbol to the base's cache. */
6499 entry
= Fcons (index
, new_symbol
);
6500 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6502 /* We have the parsing info now for free, so we could add it to
6504 XSETFASTINT (index, modifiers);
6505 Fput (new_symbol, Qevent_symbol_element_mask,
6506 Fcons (base, Fcons (index, Qnil)));
6507 Fput (new_symbol, Qevent_symbol_elements,
6508 Fcons (base, lispy_modifier_list (modifiers)));
6509 Sadly, this is only correct if `base' is indeed a base event,
6510 which is not necessarily the case. -stef */
6513 /* Make sure this symbol is of the same kind as BASE.
6515 You'd think we could just set this once and for all when we
6516 intern the symbol above, but reorder_modifiers may call us when
6517 BASE's property isn't set right; we can't assume that just
6518 because it has a Qmodifier_cache property it must have its
6519 Qevent_kind set right as well. */
6520 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6524 kind
= Fget (base
, Qevent_kind
);
6526 Fput (new_symbol
, Qevent_kind
, kind
);
6533 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6534 return a symbol with the modifiers placed in the canonical order.
6535 Canonical order is alphabetical, except for down and drag, which
6536 always come last. The 'click' modifier is never written out.
6538 Fdefine_key calls this to make sure that (for example) C-M-foo
6539 and M-C-foo end up being equivalent in the keymap. */
6542 reorder_modifiers (Lisp_Object symbol
)
6544 /* It's hopefully okay to write the code this way, since everything
6545 will soon be in caches, and no consing will be done at all. */
6548 parsed
= parse_modifiers (symbol
);
6549 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6554 /* For handling events, we often want to produce a symbol whose name
6555 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6556 to some base, like the name of a function key or mouse button.
6557 modify_event_symbol produces symbols of this sort.
6559 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6560 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6563 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6564 into symbol names, or a string specifying a name stem used to
6565 construct a symbol name or the form `STEM-N', where N is the decimal
6566 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6567 non-nil; otherwise NAME_TABLE is used.
6569 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6570 persist between calls to modify_event_symbol that it can use to
6571 store a cache of the symbols it's generated for this NAME_TABLE
6572 before. The object stored there may be a vector or an alist.
6574 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6576 MODIFIERS is a set of modifier bits (as given in struct input_events)
6577 whose prefixes should be applied to the symbol name.
6579 SYMBOL_KIND is the value to be placed in the event_kind property of
6580 the returned symbol.
6582 The symbols we create are supposed to have an
6583 `event-symbol-elements' property, which lists the modifiers present
6584 in the symbol's name. */
6587 modify_event_symbol (int symbol_num
, unsigned int modifiers
, Lisp_Object symbol_kind
,
6588 Lisp_Object name_alist_or_stem
, const char **name_table
,
6589 Lisp_Object
*symbol_table
, unsigned int table_size
)
6592 Lisp_Object symbol_int
;
6594 /* Get rid of the "vendor-specific" bit here. */
6595 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6597 /* Is this a request for a valid symbol? */
6598 if (symbol_num
< 0 || symbol_num
>= table_size
)
6601 if (CONSP (*symbol_table
))
6602 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6604 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6605 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6606 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6607 we've never used that symbol before. */
6610 if (! VECTORP (*symbol_table
)
6611 || XVECTOR (*symbol_table
)->size
!= table_size
)
6615 XSETFASTINT (size
, table_size
);
6616 *symbol_table
= Fmake_vector (size
, Qnil
);
6619 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6622 /* Have we already used this symbol before? */
6625 /* No; let's create it. */
6626 if (CONSP (name_alist_or_stem
))
6627 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6628 else if (STRINGP (name_alist_or_stem
))
6630 int len
= SBYTES (name_alist_or_stem
);
6631 char *buf
= (char *) alloca (len
+ 50);
6632 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6633 (long) XINT (symbol_int
) + 1);
6634 value
= intern (buf
);
6636 else if (name_table
!= 0 && name_table
[symbol_num
])
6637 value
= intern (name_table
[symbol_num
]);
6639 #ifdef HAVE_WINDOW_SYSTEM
6642 char *name
= x_get_keysym_name (symbol_num
);
6644 value
= intern (name
);
6651 sprintf (buf
, "key-%d", symbol_num
);
6652 value
= intern (buf
);
6655 if (CONSP (*symbol_table
))
6656 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6658 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6660 /* Fill in the cache entries for this symbol; this also
6661 builds the Qevent_symbol_elements property, which the user
6663 apply_modifiers (modifiers
& click_modifier
, value
);
6664 Fput (value
, Qevent_kind
, symbol_kind
);
6667 /* Apply modifiers to that symbol. */
6668 return apply_modifiers (modifiers
, value
);
6671 /* Convert a list that represents an event type,
6672 such as (ctrl meta backspace), into the usual representation of that
6673 event type as a number or a symbol. */
6675 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6676 doc
: /* Convert the event description list EVENT-DESC to an event type.
6677 EVENT-DESC should contain one base event type (a character or symbol)
6678 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6679 drag, down, double or triple). The base must be last.
6680 The return value is an event type (a character or symbol) which
6681 has the same base event type and all the specified modifiers. */)
6682 (Lisp_Object event_desc
)
6690 while (CONSP (rest
))
6698 /* Given a symbol, see if it is a modifier name. */
6699 if (SYMBOLP (elt
) && CONSP (rest
))
6700 this = parse_solitary_modifier (elt
);
6704 else if (!NILP (base
))
6705 error ("Two bases given in one event");
6711 /* Let the symbol A refer to the character A. */
6712 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6713 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6715 if (INTEGERP (base
))
6717 /* Turn (shift a) into A. */
6718 if ((modifiers
& shift_modifier
) != 0
6719 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6721 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6722 modifiers
&= ~shift_modifier
;
6725 /* Turn (control a) into C-a. */
6726 if (modifiers
& ctrl_modifier
)
6727 return make_number ((modifiers
& ~ctrl_modifier
)
6728 | make_ctrl_char (XINT (base
)));
6730 return make_number (modifiers
| XINT (base
));
6732 else if (SYMBOLP (base
))
6733 return apply_modifiers (modifiers
, base
);
6736 error ("Invalid base event");
6741 /* Try to recognize SYMBOL as a modifier name.
6742 Return the modifier flag bit, or 0 if not recognized. */
6745 parse_solitary_modifier (Lisp_Object symbol
)
6747 Lisp_Object name
= SYMBOL_NAME (symbol
);
6749 switch (SREF (name
, 0))
6751 #define SINGLE_LETTER_MOD(BIT) \
6752 if (SBYTES (name) == 1) \
6755 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6756 if (LEN == SBYTES (name) \
6757 && ! strncmp (SDATA (name), NAME, LEN)) \
6761 SINGLE_LETTER_MOD (alt_modifier
);
6765 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6769 SINGLE_LETTER_MOD (ctrl_modifier
);
6773 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6774 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6778 SINGLE_LETTER_MOD (hyper_modifier
);
6782 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6786 SINGLE_LETTER_MOD (meta_modifier
);
6790 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6794 SINGLE_LETTER_MOD (shift_modifier
);
6798 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6799 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6800 SINGLE_LETTER_MOD (super_modifier
);
6804 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6805 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6806 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6810 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6813 #undef SINGLE_LETTER_MOD
6814 #undef MULTI_LETTER_MOD
6820 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6821 Such a list is not valid as an event,
6822 but it can be a Lucid-style event type list. */
6825 lucid_event_type_list_p (Lisp_Object object
)
6829 if (! CONSP (object
))
6832 if (EQ (XCAR (object
), Qhelp_echo
)
6833 || EQ (XCAR (object
), Qvertical_line
)
6834 || EQ (XCAR (object
), Qmode_line
)
6835 || EQ (XCAR (object
), Qheader_line
))
6838 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6842 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6849 /* Store into *addr a value nonzero if terminal input chars are available.
6850 Serves the purpose of ioctl (0, FIONREAD, addr)
6851 but works even if FIONREAD does not exist.
6852 (In fact, this may actually read some input.)
6854 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6855 timer events that are ripe.
6856 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6857 events (FOCUS_IN_EVENT).
6858 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6859 movements and toolkit scroll bar thumb drags. */
6862 get_input_pending (int *addr
, int flags
)
6864 /* First of all, have we already counted some input? */
6865 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6867 /* If input is being read as it arrives, and we have none, there is none. */
6868 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6871 /* Try to read some input and see how much we get. */
6873 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6876 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6879 gobble_input (int expected
)
6882 /* Read D-Bus messages. */
6883 xd_read_queued_messages ();
6884 #endif /* HAVE_DBUS */
6887 if (interrupt_input
)
6890 mask
= sigblock (sigmask (SIGIO
));
6891 read_avail_input (expected
);
6895 #ifdef POLL_FOR_INPUT
6896 /* XXX This condition was (read_socket_hook && !interrupt_input),
6897 but read_socket_hook is not global anymore. Let's pretend that
6899 if (!interrupt_input
&& poll_suppress_count
== 0)
6902 mask
= sigblock (sigmask (SIGALRM
));
6903 read_avail_input (expected
);
6909 read_avail_input (expected
);
6912 /* Put a BUFFER_SWITCH_EVENT in the buffer
6913 so that read_key_sequence will notice the new current buffer. */
6916 record_asynch_buffer_change (void)
6918 struct input_event event
;
6922 event
.kind
= BUFFER_SWITCH_EVENT
;
6923 event
.frame_or_window
= Qnil
;
6926 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6927 The purpose of the event is to make read_key_sequence look up the
6928 keymaps again. If we aren't in read_key_sequence, we don't need one,
6929 and the event could cause trouble by messing up (input-pending-p).
6930 Note: Fwaiting_for_user_input_p always returns nil when async
6931 subprocesses aren't supported. */
6932 tem
= Fwaiting_for_user_input_p ();
6936 /* Make sure no interrupt happens while storing the event. */
6938 if (interrupt_input
)
6941 mask
= sigblock (sigmask (SIGIO
));
6942 kbd_buffer_store_event (&event
);
6949 kbd_buffer_store_event (&event
);
6954 /* Read any terminal input already buffered up by the system
6955 into the kbd_buffer, but do not wait.
6957 EXPECTED should be nonzero if the caller knows there is some input.
6959 Returns the number of keyboard chars read, or -1 meaning
6960 this is a bad time to try to read input. */
6963 read_avail_input (int expected
)
6969 /* Store pending user signal events, if any. */
6970 if (store_user_signal_events ())
6973 /* Loop through the available terminals, and call their input hooks. */
6977 struct terminal
*next
= t
->next_terminal
;
6979 if (t
->read_socket_hook
)
6982 struct input_event hold_quit
;
6984 EVENT_INIT (hold_quit
);
6985 hold_quit
.kind
= NO_EVENT
;
6987 /* No need for FIONREAD or fcntl; just say don't wait. */
6988 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
6994 if (nr
== -1) /* Not OK to read input now. */
6998 else if (nr
== -2) /* Non-transient error. */
7000 /* The terminal device terminated; it should be closed. */
7002 /* Kill Emacs if this was our last terminal. */
7003 if (!terminal_list
->next_terminal
)
7004 /* Formerly simply reported no input, but that
7005 sometimes led to a failure of Emacs to terminate.
7006 SIGHUP seems appropriate if we can't reach the
7008 /* ??? Is it really right to send the signal just to
7009 this process rather than to the whole process
7010 group? Perhaps on systems with FIONREAD Emacs is
7011 alone in its group. */
7012 kill (getpid (), SIGHUP
);
7014 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
7017 XSETTERMINAL (tmp
, t
);
7018 Fdelete_terminal (tmp
, Qnoelisp
);
7022 if (hold_quit
.kind
!= NO_EVENT
)
7023 kbd_buffer_store_event (&hold_quit
);
7032 frame_make_pointer_visible ();
7038 decode_keyboard_code (struct tty_display_info
*tty
,
7039 struct coding_system
*coding
,
7040 unsigned char *buf
, int nbytes
)
7042 unsigned char *src
= buf
;
7043 const unsigned char *p
;
7048 if (tty
->meta_key
!= 2)
7049 for (i
= 0; i
< nbytes
; i
++)
7051 if (coding
->carryover_bytes
> 0)
7053 src
= alloca (coding
->carryover_bytes
+ nbytes
);
7054 memcpy (src
, coding
->carryover
, coding
->carryover_bytes
);
7055 memcpy (src
+ coding
->carryover_bytes
, buf
, nbytes
);
7056 nbytes
+= coding
->carryover_bytes
;
7058 coding
->destination
= alloca (nbytes
* 4);
7059 coding
->dst_bytes
= nbytes
* 4;
7060 decode_coding_c_string (coding
, src
, nbytes
, Qnil
);
7061 if (coding
->produced_char
== 0)
7063 for (i
= 0, p
= coding
->destination
; i
< coding
->produced_char
; i
++)
7065 struct input_event buf
;
7068 buf
.code
= STRING_CHAR_ADVANCE (p
);
7069 buf
.kind
= (ASCII_CHAR_P (buf
.code
)
7070 ? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7071 /* See the comment in tty_read_avail_input. */
7072 buf
.frame_or_window
= tty
->top_frame
;
7074 kbd_buffer_store_event (&buf
);
7078 /* This is the tty way of reading available input.
7080 Note that each terminal device has its own `struct terminal' object,
7081 and so this function is called once for each individual termcap
7082 terminal. The first parameter indicates which terminal to read from. */
7085 tty_read_avail_input (struct terminal
*terminal
,
7087 struct input_event
*hold_quit
)
7089 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
7090 the kbd_buffer can really hold. That may prevent loss
7091 of characters on some systems when input is stuffed at us. */
7092 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
7094 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
7096 int buffer_free
= KBD_BUFFER_SIZE
- kbd_buffer_nr_stored () - 1;
7098 if (kbd_on_hold_p () || buffer_free
<= 0)
7101 if (!terminal
->name
) /* Don't read from a dead terminal. */
7104 if (terminal
->type
!= output_termcap
7105 && terminal
->type
!= output_msdos_raw
)
7108 /* XXX I think the following code should be moved to separate hook
7109 functions in system-dependent files. */
7112 #else /* not WINDOWSNT */
7113 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
7117 return 0; /* The terminal is suspended. */
7120 n_to_read
= dos_keysns ();
7124 cbuf
[0] = dos_keyread ();
7127 #else /* not MSDOS */
7132 struct input_event hold_quit
;
7133 int gpm
, fd
= gpm_fd
;
7135 EVENT_INIT (hold_quit
);
7136 hold_quit
.kind
= NO_EVENT
;
7138 /* gpm==1 if event received.
7139 gpm==0 if the GPM daemon has closed the connection, in which case
7140 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
7141 we save it in `fd' so close_gpm can remove it from the
7143 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
7144 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
7145 nread
+= handle_one_term_event (tty
, &event
, &hold_quit
);
7148 /* Presumably the GPM daemon has closed the connection. */
7150 if (hold_quit
.kind
!= NO_EVENT
)
7151 kbd_buffer_store_event (&hold_quit
);
7155 #endif /* HAVE_GPM */
7157 /* Determine how many characters we should *try* to read. */
7159 /* Find out how much input is available. */
7160 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
7162 if (! noninteractive
)
7163 return -2; /* Close this terminal. */
7169 if (n_to_read
> sizeof cbuf
)
7170 n_to_read
= sizeof cbuf
;
7171 #else /* no FIONREAD */
7172 #if defined (USG) || defined(CYGWIN)
7173 /* Read some input if available, but don't wait. */
7174 n_to_read
= sizeof cbuf
;
7175 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
7181 /* Don't read more than we can store. */
7182 if (n_to_read
> buffer_free
)
7183 n_to_read
= buffer_free
;
7185 /* Now read; for one reason or another, this will not block.
7186 NREAD is set to the number of chars read. */
7189 nread
= emacs_read (fileno (tty
->input
), cbuf
, n_to_read
);
7190 /* POSIX infers that processes which are not in the session leader's
7191 process group won't get SIGHUP's at logout time. BSDI adheres to
7192 this part standard and returns -1 from read (0) with errno==EIO
7193 when the control tty is taken away.
7194 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
7195 if (nread
== -1 && errno
== EIO
)
7196 return -2; /* Close this terminal. */
7197 #if defined (AIX) && defined (_BSD)
7198 /* The kernel sometimes fails to deliver SIGHUP for ptys.
7199 This looks incorrect, but it isn't, because _BSD causes
7200 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
7201 and that causes a value other than 0 when there is no input. */
7203 return -2; /* Close this terminal. */
7207 /* We used to retry the read if it was interrupted.
7208 But this does the wrong thing when O_NDELAY causes
7209 an EAGAIN error. Does anybody know of a situation
7210 where a retry is actually needed? */
7212 nread
< 0 && (errno
== EAGAIN
7226 #if defined (USG) || defined (CYGWIN)
7227 fcntl (fileno (tty
->input
), F_SETFL
, 0);
7228 #endif /* USG or CYGWIN */
7229 #endif /* no FIONREAD */
7234 #endif /* not MSDOS */
7235 #endif /* not WINDOWSNT */
7237 if (TERMINAL_KEYBOARD_CODING (terminal
)->common_flags
7238 & CODING_REQUIRE_DECODING_MASK
)
7240 struct coding_system
*coding
= TERMINAL_KEYBOARD_CODING (terminal
);
7243 /* Decode the key sequence except for those with meta
7245 for (i
= from
= 0; ; i
++)
7246 if (i
== nread
|| (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80)))
7248 struct input_event buf
;
7250 decode_keyboard_code (tty
, coding
, cbuf
+ from
, i
- from
);
7255 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7256 buf
.modifiers
= meta_modifier
;
7257 buf
.code
= cbuf
[i
] & ~0x80;
7258 /* See the comment below. */
7259 buf
.frame_or_window
= tty
->top_frame
;
7261 kbd_buffer_store_event (&buf
);
7267 for (i
= 0; i
< nread
; i
++)
7269 struct input_event buf
;
7271 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7273 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7274 buf
.modifiers
= meta_modifier
;
7275 if (tty
->meta_key
!= 2)
7279 /* Set the frame corresponding to the active tty. Note that the
7280 value of selected_frame is not reliable here, redisplay tends
7281 to temporarily change it. */
7282 buf
.frame_or_window
= tty
->top_frame
;
7285 kbd_buffer_store_event (&buf
);
7286 /* Don't look at input that follows a C-g too closely.
7287 This reduces lossage due to autorepeat on C-g. */
7288 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7289 && buf
.code
== quit_char
)
7297 handle_async_input (void)
7299 interrupt_input_pending
= 0;
7301 pending_signals
= pending_atimers
;
7303 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
7304 doing anything dangerous. */
7311 nread
= read_avail_input (1);
7312 /* -1 means it's not ok to read the input now.
7313 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7314 0 means there was no keyboard input available. */
7324 process_pending_signals (void)
7326 if (interrupt_input_pending
)
7327 handle_async_input ();
7328 do_pending_atimers ();
7331 #ifdef SIGIO /* for entire page */
7332 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7335 input_available_signal (int signo
)
7337 /* Must preserve main program's value of errno. */
7338 int old_errno
= errno
;
7339 SIGNAL_THREAD_CHECK (signo
);
7342 interrupt_input_pending
= 1;
7343 pending_signals
= 1;
7346 if (input_available_clear_time
)
7347 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7350 handle_async_input ();
7357 /* Send ourselves a SIGIO.
7359 This function exists so that the UNBLOCK_INPUT macro in
7360 blockinput.h can have some way to take care of input we put off
7361 dealing with, without assuming that every file which uses
7362 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7364 reinvoke_input_signal (void)
7367 handle_async_input ();
7373 /* User signal events. */
7375 struct user_signal_info
7377 /* Signal number. */
7380 /* Name of the signal. */
7383 /* Number of pending signals. */
7386 struct user_signal_info
*next
;
7389 /* List of user signals. */
7390 static struct user_signal_info
*user_signals
= NULL
;
7393 add_user_signal (int sig
, const char *name
)
7395 struct user_signal_info
*p
;
7397 for (p
= user_signals
; p
; p
= p
->next
)
7399 /* Already added. */
7402 p
= xmalloc (sizeof (struct user_signal_info
));
7404 p
->name
= xstrdup (name
);
7406 p
->next
= user_signals
;
7409 signal (sig
, handle_user_signal
);
7413 handle_user_signal (int sig
)
7415 int old_errno
= errno
;
7416 struct user_signal_info
*p
;
7418 SIGNAL_THREAD_CHECK (sig
);
7420 for (p
= user_signals
; p
; p
= p
->next
)
7425 if (interrupt_input
)
7426 kill (getpid (), SIGIO
);
7430 /* Tell wait_reading_process_output that it needs to wake
7431 up and look around. */
7432 if (input_available_clear_time
)
7433 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7442 find_user_signal_name (int sig
)
7444 struct user_signal_info
*p
;
7446 for (p
= user_signals
; p
; p
= p
->next
)
7454 store_user_signal_events (void)
7456 struct user_signal_info
*p
;
7457 struct input_event buf
;
7460 for (p
= user_signals
; p
; p
= p
->next
)
7461 if (p
->npending
> 0)
7467 memset (&buf
, 0, sizeof buf
);
7468 buf
.kind
= USER_SIGNAL_EVENT
;
7469 buf
.frame_or_window
= selected_frame
;
7471 nstored
+= p
->npending
;
7473 mask
= sigblock (sigmask (p
->sig
));
7477 kbd_buffer_store_event (&buf
);
7480 while (p
->npending
> 0);
7488 static void menu_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
7489 static Lisp_Object menu_bar_one_keymap_changed_items
;
7491 /* These variables hold the vector under construction within
7492 menu_bar_items and its subroutines, and the current index
7493 for storing into that vector. */
7494 static Lisp_Object menu_bar_items_vector
;
7495 static int menu_bar_items_index
;
7497 /* Return a vector of menu items for a menu bar, appropriate
7498 to the current buffer. Each item has three elements in the vector:
7501 OLD is an old vector we can optionally reuse, or nil. */
7504 menu_bar_items (Lisp_Object old
)
7506 /* The number of keymaps we're scanning right now, and the number of
7507 keymaps we have allocated space for. */
7510 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7511 in the current keymaps, or nil where it is not a prefix. */
7514 Lisp_Object def
, tail
;
7523 /* In order to build the menus, we need to call the keymap
7524 accessors. They all call QUIT. But this function is called
7525 during redisplay, during which a quit is fatal. So inhibit
7526 quitting while building the menus.
7527 We do this instead of specbind because (1) errors will clear it anyway
7528 and (2) this avoids risk of specpdl overflow. */
7529 oquit
= Vinhibit_quit
;
7533 menu_bar_items_vector
= old
;
7535 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7536 menu_bar_items_index
= 0;
7538 /* Build our list of keymaps.
7539 If we recognize a function key and replace its escape sequence in
7540 keybuf with its symbol, or if the sequence starts with a mouse
7541 click and we need to switch buffers, we jump back here to rebuild
7542 the initial keymaps from the current buffer. */
7546 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7547 if (!NILP (Voverriding_local_map_menu_flag
))
7549 /* Yes, use them (if non-nil) as well as the global map. */
7550 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7552 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7553 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7554 if (!NILP (Voverriding_local_map
))
7555 maps
[nmaps
++] = Voverriding_local_map
;
7559 /* No, so use major and minor mode keymaps and keymap property.
7560 Note that menu-bar bindings in the local-map and keymap
7561 properties may not work reliable, as they are only
7562 recognized when the menu-bar (or mode-line) is updated,
7563 which does not normally happen after every command. */
7566 nminor
= current_minor_maps (NULL
, &tmaps
);
7567 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7569 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7570 maps
[nmaps
++] = tem
;
7571 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
7573 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7575 maps
[nmaps
++] = current_global_map
;
7578 /* Look up in each map the dummy prefix key `menu-bar'. */
7582 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7583 if (!NILP (maps
[mapno
]))
7585 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7589 menu_bar_one_keymap_changed_items
= Qnil
;
7590 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7594 /* Move to the end those items that should be at the end. */
7596 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7599 int end
= menu_bar_items_index
;
7601 for (i
= 0; i
< end
; i
+= 4)
7602 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7604 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7605 /* Move the item at index I to the end,
7606 shifting all the others forward. */
7607 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7608 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7609 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7610 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7612 memmove (&XVECTOR (menu_bar_items_vector
)->contents
[i
],
7613 &XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7614 (end
- i
- 4) * sizeof (Lisp_Object
));
7615 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7616 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7617 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7618 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7623 /* Add nil, nil, nil, nil at the end. */
7624 i
= menu_bar_items_index
;
7625 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7626 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7627 /* Add this item. */
7628 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7629 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7630 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7631 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7632 menu_bar_items_index
= i
;
7634 Vinhibit_quit
= oquit
;
7635 return menu_bar_items_vector
;
7638 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7639 If there's already an item for KEY, add this DEF to it. */
7641 Lisp_Object item_properties
;
7644 menu_bar_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy1
, void *dummy2
)
7646 struct gcpro gcpro1
;
7650 if (EQ (item
, Qundefined
))
7652 /* If a map has an explicit `undefined' as definition,
7653 discard any previously made menu bar item. */
7655 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7656 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7658 if (menu_bar_items_index
> i
+ 4)
7659 memmove (&XVECTOR (menu_bar_items_vector
)->contents
[i
],
7660 &XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7661 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7662 menu_bar_items_index
-= 4;
7666 /* If this keymap has already contributed to this KEY,
7667 don't contribute to it a second time. */
7668 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7669 if (!NILP (tem
) || NILP (item
))
7672 menu_bar_one_keymap_changed_items
7673 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7675 /* We add to menu_bar_one_keymap_changed_items before doing the
7676 parse_menu_item, so that if it turns out it wasn't a menu item,
7677 it still correctly hides any further menu item. */
7679 i
= parse_menu_item (item
, 1);
7684 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7686 /* Find any existing item for this KEY. */
7687 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7688 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7691 /* If we did not find this KEY, add it at the end. */
7692 if (i
== menu_bar_items_index
)
7694 /* If vector is too small, get a bigger one. */
7695 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7696 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7697 /* Add this item. */
7698 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7699 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7700 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7701 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7702 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7703 menu_bar_items_index
= i
;
7705 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7709 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7710 /* If the new and the old items are not both keymaps,
7711 the lookup will only find `item'. */
7712 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7713 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7717 /* This is used as the handler when calling menu_item_eval_property. */
7719 menu_item_eval_property_1 (Lisp_Object arg
)
7721 /* If we got a quit from within the menu computation,
7722 quit all the way out of it. This takes care of C-] in the debugger. */
7723 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7724 Fsignal (Qquit
, Qnil
);
7729 /* Evaluate an expression and return the result (or nil if something
7730 went wrong). Used to evaluate dynamic parts of menu items. */
7732 menu_item_eval_property (Lisp_Object sexpr
)
7734 int count
= SPECPDL_INDEX ();
7736 specbind (Qinhibit_redisplay
, Qt
);
7737 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7738 menu_item_eval_property_1
);
7739 return unbind_to (count
, val
);
7742 /* This function parses a menu item and leaves the result in the
7743 vector item_properties.
7744 ITEM is a key binding, a possible menu item.
7745 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7747 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7748 parse_menu_item returns true if the item is a menu item and false
7752 parse_menu_item (Lisp_Object item
, int inmenubar
)
7754 Lisp_Object def
, tem
, item_string
, start
;
7756 Lisp_Object keyhint
;
7765 /* Create item_properties vector if necessary. */
7766 if (NILP (item_properties
))
7768 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7770 /* Initialize optional entries. */
7771 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7772 ASET (item_properties
, i
, Qnil
);
7773 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7775 /* Save the item here to protect it from GC. */
7776 ASET (item_properties
, ITEM_PROPERTY_ITEM
, item
);
7778 item_string
= XCAR (item
);
7782 if (STRINGP (item_string
))
7784 /* Old format menu item. */
7785 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7787 /* Maybe help string. */
7788 if (CONSP (item
) && STRINGP (XCAR (item
)))
7790 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7795 /* Maybe an obsolete key binding cache. */
7796 if (CONSP (item
) && CONSP (XCAR (item
))
7797 && (NILP (XCAR (XCAR (item
)))
7798 || VECTORP (XCAR (XCAR (item
)))))
7801 /* This is the real definition--the function to run. */
7802 ASET (item_properties
, ITEM_PROPERTY_DEF
, item
);
7804 /* Get enable property, if any. */
7807 tem
= Fget (item
, Qmenu_enable
);
7808 if (!NILP (Venable_disabled_menus_and_buttons
))
7809 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7810 else if (!NILP (tem
))
7811 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7814 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7816 /* New format menu item. */
7817 ASET (item_properties
, ITEM_PROPERTY_NAME
, XCAR (item
));
7818 start
= XCDR (item
);
7821 /* We have a real binding. */
7822 ASET (item_properties
, ITEM_PROPERTY_DEF
, XCAR (start
));
7824 item
= XCDR (start
);
7825 /* Is there an obsolete cache list with key equivalences. */
7826 if (CONSP (item
) && CONSP (XCAR (item
)))
7829 /* Parse properties. */
7830 while (CONSP (item
) && CONSP (XCDR (item
)))
7835 if (EQ (tem
, QCenable
))
7837 if (!NILP (Venable_disabled_menus_and_buttons
))
7838 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7840 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, XCAR (item
));
7842 else if (EQ (tem
, QCvisible
))
7844 /* If got a visible property and that evaluates to nil
7845 then ignore this item. */
7846 tem
= menu_item_eval_property (XCAR (item
));
7850 else if (EQ (tem
, QChelp
))
7851 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7852 else if (EQ (tem
, QCfilter
))
7854 else if (EQ (tem
, QCkey_sequence
))
7857 if (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
))
7858 /* Be GC protected. Set keyhint to item instead of tem. */
7861 else if (EQ (tem
, QCkeys
))
7864 if (CONSP (tem
) || STRINGP (tem
))
7865 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, tem
);
7867 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7872 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7874 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
7876 ASET (item_properties
, ITEM_PROPERTY_TYPE
, type
);
7882 else if (inmenubar
|| !NILP (start
))
7886 return 0; /* not a menu item */
7888 /* If item string is not a string, evaluate it to get string.
7889 If we don't get a string, skip this item. */
7890 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7891 if (!(STRINGP (item_string
)))
7893 item_string
= menu_item_eval_property (item_string
);
7894 if (!STRINGP (item_string
))
7896 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7899 /* If got a filter apply it on definition. */
7900 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7903 def
= menu_item_eval_property (list2 (XCAR (filter
),
7904 list2 (Qquote
, def
)));
7906 ASET (item_properties
, ITEM_PROPERTY_DEF
, def
);
7909 /* Enable or disable selection of item. */
7910 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7913 tem
= menu_item_eval_property (tem
);
7914 if (inmenubar
&& NILP (tem
))
7915 return 0; /* Ignore disabled items in menu bar. */
7916 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7919 /* If we got no definition, this item is just unselectable text which
7920 is OK in a submenu but not in the menubar. */
7922 return (inmenubar
? 0 : 1);
7924 /* See if this is a separate pane or a submenu. */
7925 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7926 tem
= get_keymap (def
, 0, 1);
7927 /* For a subkeymap, just record its details and exit. */
7930 ASET (item_properties
, ITEM_PROPERTY_MAP
, tem
);
7931 ASET (item_properties
, ITEM_PROPERTY_DEF
, tem
);
7935 /* At the top level in the menu bar, do likewise for commands also.
7936 The menu bar does not display equivalent key bindings anyway.
7937 ITEM_PROPERTY_DEF is already set up properly. */
7941 { /* This is a command. See if there is an equivalent key binding. */
7942 Lisp_Object keyeq
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7944 /* The previous code preferred :key-sequence to :keys, so we
7945 preserve this behavior. */
7946 if (STRINGP (keyeq
) && !CONSP (keyhint
))
7947 keyeq
= Fsubstitute_command_keys (keyeq
);
7950 Lisp_Object prefix
= keyeq
;
7951 Lisp_Object keys
= Qnil
;
7955 def
= XCAR (prefix
);
7956 prefix
= XCDR (prefix
);
7959 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7961 if (CONSP (keyhint
) && !NILP (XCAR (keyhint
)))
7963 keys
= XCAR (keyhint
);
7964 tem
= Fkey_binding (keys
, Qnil
, Qnil
, Qnil
);
7966 /* We have a suggested key. Is it bound to the command? */
7969 /* If the command is an alias for another
7970 (such as lmenu.el set it up), check if the
7971 original command matches the cached command. */
7972 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7977 keys
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qnil
);
7981 tem
= Fkey_description (keys
, Qnil
);
7984 if (STRINGP (XCAR (prefix
)))
7985 tem
= concat2 (XCAR (prefix
), tem
);
7986 if (STRINGP (XCDR (prefix
)))
7987 tem
= concat2 (tem
, XCDR (prefix
));
7989 keyeq
= concat2 (build_string (" "), tem
);
7990 /* keyeq = concat3(build_string(" ("),tem,build_string(")")); */
7996 /* If we have an equivalent key binding, use that. */
7997 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, keyeq
);
8000 /* Include this when menu help is implemented.
8001 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
8002 if (!(NILP (tem) || STRINGP (tem)))
8004 tem = menu_item_eval_property (tem);
8007 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
8011 /* Handle radio buttons or toggle boxes. */
8012 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
8014 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
8015 menu_item_eval_property (tem
));
8022 /***********************************************************************
8024 ***********************************************************************/
8026 /* A vector holding tool bar items while they are parsed in function
8027 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
8030 static Lisp_Object tool_bar_items_vector
;
8032 /* A vector holding the result of parse_tool_bar_item. Layout is like
8033 the one for a single item in tool_bar_items_vector. */
8035 static Lisp_Object tool_bar_item_properties
;
8037 /* Next free index in tool_bar_items_vector. */
8039 static int ntool_bar_items
;
8041 /* The symbols `:image' and `:rtl'. */
8043 Lisp_Object QCimage
;
8046 /* Function prototypes. */
8048 static void init_tool_bar_items (Lisp_Object
);
8049 static void process_tool_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
8050 static int parse_tool_bar_item (Lisp_Object
, Lisp_Object
);
8051 static void append_tool_bar_item (void);
8054 /* Return a vector of tool bar items for keymaps currently in effect.
8055 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
8056 tool bar items found. */
8059 tool_bar_items (Lisp_Object reuse
, int *nitems
)
8068 /* In order to build the menus, we need to call the keymap
8069 accessors. They all call QUIT. But this function is called
8070 during redisplay, during which a quit is fatal. So inhibit
8071 quitting while building the menus. We do this instead of
8072 specbind because (1) errors will clear it anyway and (2) this
8073 avoids risk of specpdl overflow. */
8074 oquit
= Vinhibit_quit
;
8077 /* Initialize tool_bar_items_vector and protect it from GC. */
8078 init_tool_bar_items (reuse
);
8080 /* Build list of keymaps in maps. Set nmaps to the number of maps
8083 /* Should overriding-terminal-local-map and overriding-local-map apply? */
8084 if (!NILP (Voverriding_local_map_menu_flag
))
8086 /* Yes, use them (if non-nil) as well as the global map. */
8087 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
8089 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8090 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8091 if (!NILP (Voverriding_local_map
))
8092 maps
[nmaps
++] = Voverriding_local_map
;
8096 /* No, so use major and minor mode keymaps and keymap property.
8097 Note that tool-bar bindings in the local-map and keymap
8098 properties may not work reliable, as they are only
8099 recognized when the tool-bar (or mode-line) is updated,
8100 which does not normally happen after every command. */
8103 nminor
= current_minor_maps (NULL
, &tmaps
);
8104 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
8106 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
8107 maps
[nmaps
++] = tem
;
8108 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
8110 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
8113 /* Add global keymap at the end. */
8114 maps
[nmaps
++] = current_global_map
;
8116 /* Process maps in reverse order and look up in each map the prefix
8118 for (i
= nmaps
- 1; i
>= 0; --i
)
8119 if (!NILP (maps
[i
]))
8123 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
8125 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
8128 Vinhibit_quit
= oquit
;
8129 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
8130 return tool_bar_items_vector
;
8134 /* Process the definition of KEY which is DEF. */
8137 process_tool_bar_item (Lisp_Object key
, Lisp_Object def
, Lisp_Object data
, void *args
)
8140 struct gcpro gcpro1
, gcpro2
;
8142 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
8146 if (EQ (def
, Qundefined
))
8148 /* If a map has an explicit `undefined' as definition,
8149 discard any previously made item. */
8150 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
8152 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
8154 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
8156 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
8157 memmove (v
, v
+ TOOL_BAR_ITEM_NSLOTS
,
8158 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
8159 * sizeof (Lisp_Object
)));
8160 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
8165 else if (parse_tool_bar_item (key
, def
))
8166 /* Append a new tool bar item to tool_bar_items_vector. Accept
8167 more than one definition for the same key. */
8168 append_tool_bar_item ();
8174 /* Parse a tool bar item specification ITEM for key KEY and return the
8175 result in tool_bar_item_properties. Value is zero if ITEM is
8178 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
8180 CAPTION is the caption of the item, If it's not a string, it is
8181 evaluated to get a string.
8183 BINDING is the tool bar item's binding. Tool-bar items with keymaps
8184 as binding are currently ignored.
8186 The following properties are recognized:
8190 FORM is evaluated and specifies whether the tool bar item is
8191 enabled or disabled.
8195 FORM is evaluated and specifies whether the tool bar item is visible.
8197 - `:filter FUNCTION'
8199 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8200 result is stored as the new binding.
8202 - `:button (TYPE SELECTED)'
8204 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8205 and specifies whether the button is selected (pressed) or not.
8209 IMAGES is either a single image specification or a vector of four
8210 image specifications. See enum tool_bar_item_images.
8212 - `:help HELP-STRING'.
8214 Gives a help string to display for the tool bar item.
8216 - `:label LABEL-STRING'.
8218 A text label to show with the tool bar button if labels are enabled. */
8221 parse_tool_bar_item (Lisp_Object key
, Lisp_Object item
)
8223 /* Access slot with index IDX of vector tool_bar_item_properties. */
8224 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8226 Lisp_Object filter
= Qnil
;
8227 Lisp_Object caption
;
8228 int i
, have_label
= 0;
8230 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8231 Rule out items that aren't lists, don't start with
8232 `menu-item' or whose rest following `tool-bar-item' is not a
8235 || !EQ (XCAR (item
), Qmenu_item
)
8236 || (item
= XCDR (item
),
8240 /* Create tool_bar_item_properties vector if necessary. Reset it to
8242 if (VECTORP (tool_bar_item_properties
))
8244 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8248 tool_bar_item_properties
8249 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8252 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8253 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8255 /* Get the caption of the item. If the caption is not a string,
8256 evaluate it to get a string. If we don't get a string, skip this
8258 caption
= XCAR (item
);
8259 if (!STRINGP (caption
))
8261 caption
= menu_item_eval_property (caption
);
8262 if (!STRINGP (caption
))
8265 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8267 /* Give up if rest following the caption is not a list. */
8272 /* Store the binding. */
8273 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8276 /* Ignore cached key binding, if any. */
8277 if (CONSP (item
) && CONSP (XCAR (item
)))
8280 /* Process the rest of the properties. */
8281 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8283 Lisp_Object key
, value
;
8286 value
= XCAR (XCDR (item
));
8288 if (EQ (key
, QCenable
))
8290 /* `:enable FORM'. */
8291 if (!NILP (Venable_disabled_menus_and_buttons
))
8292 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8294 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8296 else if (EQ (key
, QCvisible
))
8298 /* `:visible FORM'. If got a visible property and that
8299 evaluates to nil then ignore this item. */
8300 if (NILP (menu_item_eval_property (value
)))
8303 else if (EQ (key
, QChelp
))
8304 /* `:help HELP-STRING'. */
8305 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8306 else if (EQ (key
, QClabel
))
8308 const char *bad_label
= "!!?GARBLED ITEM?!!";
8309 /* `:label LABEL-STRING'. */
8310 PROP (TOOL_BAR_ITEM_HELP
) = STRINGP (value
)
8312 : make_string (bad_label
, strlen (bad_label
));
8315 else if (EQ (key
, QCfilter
))
8316 /* ':filter FORM'. */
8318 else if (EQ (key
, QCbutton
) && CONSP (value
))
8320 /* `:button (TYPE . SELECTED)'. */
8321 Lisp_Object type
, selected
;
8323 type
= XCAR (value
);
8324 selected
= XCDR (value
);
8325 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8327 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8328 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8331 else if (EQ (key
, QCimage
)
8333 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8334 /* Value is either a single image specification or a vector
8335 of 4 such specifications for the different button states. */
8336 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8337 else if (EQ (key
, Qrtl
))
8339 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8345 /* Try to make one from caption and key. */
8346 Lisp_Object key
= PROP (TOOL_BAR_ITEM_KEY
);
8347 Lisp_Object capt
= PROP (TOOL_BAR_ITEM_CAPTION
);
8348 const char *label
= SYMBOLP (key
) ? (char *) SDATA (SYMBOL_NAME (key
)) : "";
8349 const char *caption
= STRINGP (capt
) ? (char *) SDATA (capt
) : "";
8350 EMACS_INT max_lbl
= 2 * tool_bar_max_label_size
;
8351 char *buf
= (char *) xmalloc (max_lbl
+ 1);
8352 Lisp_Object new_lbl
;
8353 size_t caption_len
= strlen (caption
);
8355 if (caption_len
<= max_lbl
&& caption
[0] != '\0')
8357 strcpy (buf
, caption
);
8358 while (caption_len
> 0 && buf
[caption_len
- 1] == '.')
8360 buf
[caption_len
] = '\0';
8361 label
= caption
= buf
;
8364 if (strlen (label
) <= max_lbl
&& label
[0] != '\0')
8368 strcpy (buf
, label
);
8370 for (i
= 0; buf
[i
] != '\0'; ++i
)
8379 new_lbl
= Fupcase_initials (make_string (label
, strlen (label
)));
8380 if (SCHARS (new_lbl
) <= tool_bar_max_label_size
)
8381 PROP (TOOL_BAR_ITEM_LABEL
) = new_lbl
;
8383 PROP (TOOL_BAR_ITEM_LABEL
) = make_string ("", 0);
8387 /* If got a filter apply it on binding. */
8389 PROP (TOOL_BAR_ITEM_BINDING
)
8390 = menu_item_eval_property (list2 (filter
,
8392 PROP (TOOL_BAR_ITEM_BINDING
))));
8394 /* See if the binding is a keymap. Give up if it is. */
8395 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8398 /* Enable or disable selection of item. */
8399 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8400 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8401 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8403 /* Handle radio buttons or toggle boxes. */
8404 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8405 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8406 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8414 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8415 that can be reused. */
8418 init_tool_bar_items (Lisp_Object reuse
)
8420 if (VECTORP (reuse
))
8421 tool_bar_items_vector
= reuse
;
8423 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8424 ntool_bar_items
= 0;
8428 /* Append parsed tool bar item properties from
8429 tool_bar_item_properties */
8432 append_tool_bar_item (void)
8434 Lisp_Object
*to
, *from
;
8436 /* Enlarge tool_bar_items_vector if necessary. */
8437 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8438 >= XVECTOR (tool_bar_items_vector
)->size
)
8439 tool_bar_items_vector
8440 = larger_vector (tool_bar_items_vector
,
8441 2 * XVECTOR (tool_bar_items_vector
)->size
, Qnil
);
8443 /* Append entries from tool_bar_item_properties to the end of
8444 tool_bar_items_vector. */
8445 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8446 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8447 memcpy (to
, from
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8448 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8455 /* Read a character using menus based on maps in the array MAPS.
8456 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8457 Return t if we displayed a menu but the user rejected it.
8459 PREV_EVENT is the previous input event, or nil if we are reading
8460 the first event of a key sequence.
8462 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8463 if we used a mouse menu to read the input, or zero otherwise. If
8464 USED_MOUSE_MENU is null, we don't dereference it.
8466 The prompting is done based on the prompt-string of the map
8467 and the strings associated with various map elements.
8469 This can be done with X menus or with menus put in the minibuf.
8470 These are done in different ways, depending on how the input will be read.
8471 Menus using X are done after auto-saving in read-char, getting the input
8472 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8473 and do auto-saving in the inner call of read_char. */
8476 read_char_x_menu_prompt (int nmaps
, Lisp_Object
*maps
, Lisp_Object prev_event
,
8477 int *used_mouse_menu
)
8481 if (used_mouse_menu
)
8482 *used_mouse_menu
= 0;
8484 /* Use local over global Menu maps */
8486 if (! menu_prompting
)
8489 /* Optionally disregard all but the global map. */
8490 if (inhibit_local_menu_bar_menus
)
8492 maps
+= (nmaps
- 1);
8497 /* If we got to this point via a mouse click,
8498 use a real menu for mouse selection. */
8499 if (EVENT_HAS_PARAMETERS (prev_event
)
8500 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8501 && !EQ (XCAR (prev_event
), Qtool_bar
))
8503 /* Display the menu and get the selection. */
8504 Lisp_Object
*realmaps
8505 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8509 /* Use the maps that are not nil. */
8510 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8511 if (!NILP (maps
[mapno
]))
8512 realmaps
[nmaps1
++] = maps
[mapno
];
8514 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8519 record_menu_key (XCAR (value
));
8521 /* If we got multiple events, unread all but
8523 There is no way to prevent those unread events
8524 from showing up later in last_nonmenu_event.
8525 So turn symbol and integer events into lists,
8526 to indicate that they came from a mouse menu,
8527 so that when present in last_nonmenu_event
8528 they won't confuse things. */
8529 for (tem
= XCDR (value
); CONSP (tem
); tem
= XCDR (tem
))
8531 record_menu_key (XCAR (tem
));
8532 if (SYMBOLP (XCAR (tem
))
8533 || INTEGERP (XCAR (tem
)))
8534 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8537 /* If we got more than one event, put all but the first
8538 onto this list to be read later.
8539 Return just the first event now. */
8540 Vunread_command_events
8541 = nconc2 (XCDR (value
), Vunread_command_events
);
8542 value
= XCAR (value
);
8544 else if (NILP (value
))
8546 if (used_mouse_menu
)
8547 *used_mouse_menu
= 1;
8550 #endif /* HAVE_MENUS */
8554 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8555 We make this bigger when necessary, and never free it. */
8556 static char *read_char_minibuf_menu_text
;
8557 /* Size of that buffer. */
8558 static int read_char_minibuf_menu_width
;
8561 read_char_minibuf_menu_prompt (int commandflag
, int nmaps
, Lisp_Object
*maps
)
8564 register Lisp_Object name
;
8566 /* FIXME: Use the minibuffer's frame width. */
8567 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8570 Lisp_Object rest
, vector
;
8576 if (! menu_prompting
)
8579 /* Get the menu name from the first map that has one (a prompt string). */
8580 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8582 name
= Fkeymap_prompt (maps
[mapno
]);
8587 /* If we don't have any menus, just read a character normally. */
8588 if (!STRINGP (name
))
8591 /* Make sure we have a big enough buffer for the menu text. */
8592 width
= max (width
, SBYTES (name
));
8593 if (read_char_minibuf_menu_text
== 0)
8595 read_char_minibuf_menu_width
= width
+ 4;
8596 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8598 else if (width
+ 4 > read_char_minibuf_menu_width
)
8600 read_char_minibuf_menu_width
= width
+ 4;
8601 read_char_minibuf_menu_text
8602 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8604 menu
= read_char_minibuf_menu_text
;
8606 /* Prompt string always starts with map's prompt, and a space. */
8607 strcpy (menu
, SDATA (name
));
8608 nlength
= SBYTES (name
);
8609 menu
[nlength
++] = ':';
8610 menu
[nlength
++] = ' ';
8613 /* Start prompting at start of first map. */
8617 /* Present the documented bindings, a line at a time. */
8624 Lisp_Object orig_defn_macro
;
8626 /* Loop over elements of map. */
8631 /* If reached end of map, start at beginning of next map. */
8635 /* At end of last map, wrap around to first map if just starting,
8636 or end this line if already have something on it. */
8640 if (notfirst
|| nobindings
) break;
8645 /* Look at the next element of the map. */
8647 elt
= XVECTOR (vector
)->contents
[idx
];
8649 elt
= Fcar_safe (rest
);
8651 if (idx
< 0 && VECTORP (elt
))
8653 /* If we found a dense table in the keymap,
8654 advanced past it, but start scanning its contents. */
8655 rest
= Fcdr_safe (rest
);
8661 /* An ordinary element. */
8662 Lisp_Object event
, tem
;
8666 event
= Fcar_safe (elt
); /* alist */
8667 elt
= Fcdr_safe (elt
);
8671 XSETINT (event
, idx
); /* vector */
8674 /* Ignore the element if it has no prompt string. */
8675 if (INTEGERP (event
) && parse_menu_item (elt
, -1))
8677 /* 1 if the char to type matches the string. */
8679 Lisp_Object upcased_event
, downcased_event
;
8680 Lisp_Object desc
= Qnil
;
8682 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8684 upcased_event
= Fupcase (event
);
8685 downcased_event
= Fdowncase (event
);
8686 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8687 || XINT (downcased_event
) == SREF (s
, 0));
8689 desc
= Fsingle_key_description (event
, Qnil
);
8691 #if 0 /* It is redundant to list the equivalent key bindings because
8692 the prefix is what the user has already typed. */
8694 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8696 /* Insert equivalent keybinding. */
8697 s
= concat2 (s
, tem
);
8700 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8701 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8703 /* Insert button prefix. */
8704 Lisp_Object selected
8705 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8706 if (EQ (tem
, QCradio
))
8707 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8709 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8710 s
= concat2 (tem
, s
);
8714 /* If we have room for the prompt string, add it to this line.
8715 If this is the first on the line, always add it. */
8716 if ((SCHARS (s
) + i
+ 2
8717 + (char_matches
? 0 : SCHARS (desc
) + 3))
8723 /* Punctuate between strings. */
8726 strcpy (menu
+ i
, ", ");
8732 /* If the char to type doesn't match the string's
8733 first char, explicitly show what char to type. */
8736 /* Add as much of string as fits. */
8737 thiswidth
= SCHARS (desc
);
8738 if (thiswidth
+ i
> width
)
8739 thiswidth
= width
- i
;
8740 memcpy (menu
+ i
, SDATA (desc
), thiswidth
);
8742 strcpy (menu
+ i
, " = ");
8746 /* Add as much of string as fits. */
8747 thiswidth
= SCHARS (s
);
8748 if (thiswidth
+ i
> width
)
8749 thiswidth
= width
- i
;
8750 memcpy (menu
+ i
, SDATA (s
), thiswidth
);
8756 /* If this element does not fit, end the line now,
8757 and save the element for the next line. */
8758 strcpy (menu
+ i
, "...");
8763 /* Move past this element. */
8764 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8765 /* Handle reaching end of dense table. */
8770 rest
= Fcdr_safe (rest
);
8774 /* Prompt with that and read response. */
8775 message2_nolog (menu
, strlen (menu
),
8776 ! NILP (current_buffer
->enable_multibyte_characters
));
8778 /* Make believe its not a keyboard macro in case the help char
8779 is pressed. Help characters are not recorded because menu prompting
8780 is not used on replay.
8782 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8783 current_kboard
->defining_kbd_macro
= Qnil
;
8785 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8786 while (BUFFERP (obj
));
8787 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8789 if (!INTEGERP (obj
))
8791 else if (XINT (obj
) == -2)
8796 if (! EQ (obj
, menu_prompt_more_char
)
8797 && (!INTEGERP (menu_prompt_more_char
)
8798 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8800 if (!NILP (current_kboard
->defining_kbd_macro
))
8801 store_kbd_macro_char (obj
);
8804 /* Help char - go round again */
8808 /* Reading key sequences. */
8810 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8811 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8812 keymap, or nil otherwise. Return the index of the first keymap in
8813 which KEY has any binding, or NMAPS if no map has a binding.
8815 If KEY is a meta ASCII character, treat it like meta-prefix-char
8816 followed by the corresponding non-meta character. Keymaps in
8817 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8820 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8823 NEXT may be the same array as CURRENT. */
8826 follow_key (Lisp_Object key
, int nmaps
, Lisp_Object
*current
, Lisp_Object
*defs
,
8829 int i
, first_binding
;
8831 first_binding
= nmaps
;
8832 for (i
= nmaps
- 1; i
>= 0; i
--)
8834 if (! NILP (current
[i
]))
8836 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8837 if (! NILP (defs
[i
]))
8844 /* Given the set of bindings we've found, produce the next set of maps. */
8845 if (first_binding
< nmaps
)
8846 for (i
= 0; i
< nmaps
; i
++)
8847 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8849 return first_binding
;
8852 /* Structure used to keep track of partial application of key remapping
8853 such as Vfunction_key_map and Vkey_translation_map. */
8854 typedef struct keyremap
8856 /* This is the map originally specified for this use. */
8858 /* This is a submap reached by looking up, in PARENT,
8859 the events from START to END. */
8861 /* Positions [START, END) in the key sequence buffer
8862 are the key that we have scanned so far.
8863 Those events are the ones that we will replace
8864 if PAREHT maps them into a key sequence. */
8868 /* Lookup KEY in MAP.
8869 MAP is a keymap mapping keys to key vectors or functions.
8870 If the mapping is a function and DO_FUNCTION is non-zero, then
8871 the function is called with PROMPT as parameter and its return
8872 value is used as the return value of this function (after checking
8873 that it is indeed a vector). */
8876 access_keymap_keyremap (Lisp_Object map
, Lisp_Object key
, Lisp_Object prompt
,
8881 next
= access_keymap (map
, key
, 1, 0, 1);
8883 /* Handle symbol with autoload definition. */
8884 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8885 && CONSP (XSYMBOL (next
)->function
)
8886 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8887 do_autoload (XSYMBOL (next
)->function
, next
);
8889 /* Handle a symbol whose function definition is a keymap
8891 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8892 && (ARRAYP (XSYMBOL (next
)->function
)
8893 || KEYMAPP (XSYMBOL (next
)->function
)))
8894 next
= XSYMBOL (next
)->function
;
8896 /* If the keymap gives a function, not an
8897 array, then call the function with one arg and use
8898 its value instead. */
8899 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8904 next
= call1 (next
, prompt
);
8905 /* If the function returned something invalid,
8906 barf--don't ignore it.
8907 (To ignore it safely, we would need to gcpro a bunch of
8908 other variables.) */
8909 if (! (VECTORP (next
) || STRINGP (next
)))
8910 error ("Function %s returns invalid key sequence", tem
);
8915 /* Do one step of the key remapping used for function-key-map and
8916 key-translation-map:
8917 KEYBUF is the buffer holding the input events.
8918 BUFSIZE is its maximum size.
8919 FKEY is a pointer to the keyremap structure to use.
8920 INPUT is the index of the last element in KEYBUF.
8921 DOIT if non-zero says that the remapping can actually take place.
8922 DIFF is used to return the number of keys added/removed by the remapping.
8923 PARENT is the root of the keymap.
8924 PROMPT is the prompt to use if the remapping happens through a function.
8925 The return value is non-zero if the remapping actually took place. */
8928 keyremap_step (Lisp_Object
*keybuf
, int bufsize
, volatile keyremap
*fkey
,
8929 int input
, int doit
, int *diff
, Lisp_Object prompt
)
8931 Lisp_Object next
, key
;
8933 key
= keybuf
[fkey
->end
++];
8935 if (KEYMAPP (fkey
->parent
))
8936 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8940 /* If keybuf[fkey->start..fkey->end] is bound in the
8941 map and we're in a position to do the key remapping, replace it with
8942 the binding and restart with fkey->start at the end. */
8943 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8945 int len
= XFASTINT (Flength (next
));
8948 *diff
= len
- (fkey
->end
- fkey
->start
);
8950 if (input
+ *diff
>= bufsize
)
8951 error ("Key sequence too long");
8953 /* Shift the keys that follow fkey->end. */
8955 for (i
= fkey
->end
; i
< input
; i
++)
8956 keybuf
[i
+ *diff
] = keybuf
[i
];
8958 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8959 keybuf
[i
+ *diff
] = keybuf
[i
];
8960 /* Overwrite the old keys with the new ones. */
8961 for (i
= 0; i
< len
; i
++)
8962 keybuf
[fkey
->start
+ i
]
8963 = Faref (next
, make_number (i
));
8965 fkey
->start
= fkey
->end
+= *diff
;
8966 fkey
->map
= fkey
->parent
;
8971 fkey
->map
= get_keymap (next
, 0, 1);
8973 /* If we no longer have a bound suffix, try a new position for
8975 if (!CONSP (fkey
->map
))
8977 fkey
->end
= ++fkey
->start
;
8978 fkey
->map
= fkey
->parent
;
8983 /* Read a sequence of keys that ends with a non prefix character,
8984 storing it in KEYBUF, a buffer of size BUFSIZE.
8986 Return the length of the key sequence stored.
8987 Return -1 if the user rejected a command menu.
8989 Echo starting immediately unless `prompt' is 0.
8991 Where a key sequence ends depends on the currently active keymaps.
8992 These include any minor mode keymaps active in the current buffer,
8993 the current buffer's local map, and the global map.
8995 If a key sequence has no other bindings, we check Vfunction_key_map
8996 to see if some trailing subsequence might be the beginning of a
8997 function key's sequence. If so, we try to read the whole function
8998 key, and substitute its symbolic name into the key sequence.
9000 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
9001 `double-' events into similar click events, if that would make them
9002 bound. We try to turn `triple-' events first into `double-' events,
9005 If we get a mouse click in a mode line, vertical divider, or other
9006 non-text area, we treat the click as if it were prefixed by the
9007 symbol denoting that area - `mode-line', `vertical-line', or
9010 If the sequence starts with a mouse click, we read the key sequence
9011 with respect to the buffer clicked on, not the current buffer.
9013 If the user switches frames in the midst of a key sequence, we put
9014 off the switch-frame event until later; the next call to
9015 read_char will return it.
9017 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
9018 from the selected window's buffer. */
9021 read_key_sequence (Lisp_Object
*keybuf
, int bufsize
, Lisp_Object prompt
,
9022 int dont_downcase_last
, int can_return_switch_frame
,
9023 int fix_current_buffer
)
9025 Lisp_Object from_string
;
9026 int count
= SPECPDL_INDEX ();
9028 /* How many keys there are in the current key sequence. */
9031 /* The length of the echo buffer when we started reading, and
9032 the length of this_command_keys when we started reading. */
9036 /* The number of keymaps we're scanning right now, and the number of
9037 keymaps we have allocated space for. */
9039 int nmaps_allocated
= 0;
9041 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
9042 the current keymaps. */
9043 Lisp_Object
*defs
= NULL
;
9045 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
9046 in the current keymaps, or nil where it is not a prefix. */
9047 Lisp_Object
*submaps
= NULL
;
9049 /* The local map to start out with at start of key sequence. */
9050 Lisp_Object orig_local_map
;
9052 /* The map from the `keymap' property to start out with at start of
9054 Lisp_Object orig_keymap
;
9056 /* 1 if we have already considered switching to the local-map property
9057 of the place where a mouse click occurred. */
9058 int localized_local_map
= 0;
9060 /* The index in submaps[] of the first keymap that has a binding for
9061 this key sequence. In other words, the lowest i such that
9062 submaps[i] is non-nil. */
9064 /* Index of the first key that has no binding.
9065 It is useless to try fkey.start larger than that. */
9068 /* If t < mock_input, then KEYBUF[t] should be read as the next
9071 We use this to recover after recognizing a function key. Once we
9072 realize that a suffix of the current key sequence is actually a
9073 function key's escape sequence, we replace the suffix with the
9074 function key's binding from Vfunction_key_map. Now keybuf
9075 contains a new and different key sequence, so the echo area,
9076 this_command_keys, and the submaps and defs arrays are wrong. In
9077 this situation, we set mock_input to t, set t to 0, and jump to
9078 restart_sequence; the loop will read keys from keybuf up until
9079 mock_input, thus rebuilding the state; and then it will resume
9080 reading characters from the keyboard. */
9083 /* If the sequence is unbound in submaps[], then
9084 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
9085 and fkey.map is its binding.
9087 These might be > t, indicating that all function key scanning
9088 should hold off until t reaches them. We do this when we've just
9089 recognized a function key, to avoid searching for the function
9090 key's again in Vfunction_key_map. */
9093 /* Likewise, for key_translation_map and input-decode-map. */
9094 keyremap keytran
, indec
;
9096 /* Non-zero if we are trying to map a key by changing an upper-case
9097 letter to lower case, or a shifted function key to an unshifted
9099 int shift_translated
= 0;
9101 /* If we receive a `switch-frame' or `select-window' event in the middle of
9102 a key sequence, we put it off for later.
9103 While we're reading, we keep the event here. */
9104 Lisp_Object delayed_switch_frame
;
9106 /* See the comment below... */
9107 #if defined (GOBBLE_FIRST_EVENT)
9108 Lisp_Object first_event
;
9111 Lisp_Object original_uppercase
;
9112 int original_uppercase_position
= -1;
9114 /* Gets around Microsoft compiler limitations. */
9117 struct buffer
*starting_buffer
;
9119 /* List of events for which a fake prefix key has been generated. */
9120 Lisp_Object fake_prefixed_keys
= Qnil
;
9122 #if defined (GOBBLE_FIRST_EVENT)
9126 struct gcpro gcpro1
;
9128 GCPRO1 (fake_prefixed_keys
);
9129 raw_keybuf_count
= 0;
9131 last_nonmenu_event
= Qnil
;
9133 delayed_switch_frame
= Qnil
;
9138 echo_prompt (prompt
);
9139 else if (cursor_in_echo_area
9140 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9141 && NILP (Fzerop (Vecho_keystrokes
)))
9142 /* This doesn't put in a dash if the echo buffer is empty, so
9143 you don't always see a dash hanging out in the minibuffer. */
9147 /* Record the initial state of the echo area and this_command_keys;
9148 we will need to restore them if we replay a key sequence. */
9150 echo_start
= echo_length ();
9151 keys_start
= this_command_key_count
;
9152 this_single_command_key_start
= keys_start
;
9154 #if defined (GOBBLE_FIRST_EVENT)
9155 /* This doesn't quite work, because some of the things that read_char
9156 does cannot safely be bypassed. It seems too risky to try to make
9159 /* Read the first char of the sequence specially, before setting
9160 up any keymaps, in case a filter runs and switches buffers on us. */
9161 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9163 #endif /* GOBBLE_FIRST_EVENT */
9165 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9166 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9169 /* We jump here when we need to reinitialize fkey and keytran; this
9170 happens if we switch keyboards between rescans. */
9171 replay_entire_sequence
:
9173 indec
.map
= indec
.parent
= current_kboard
->Vinput_decode_map
;
9174 fkey
.map
= fkey
.parent
= current_kboard
->Vlocal_function_key_map
;
9175 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
9176 indec
.start
= indec
.end
= 0;
9177 fkey
.start
= fkey
.end
= 0;
9178 keytran
.start
= keytran
.end
= 0;
9180 /* We jump here when the key sequence has been thoroughly changed, and
9181 we need to rescan it starting from the beginning. When we jump here,
9182 keybuf[0..mock_input] holds the sequence we should reread. */
9185 starting_buffer
= current_buffer
;
9186 first_unbound
= bufsize
+ 1;
9188 /* Build our list of keymaps.
9189 If we recognize a function key and replace its escape sequence in
9190 keybuf with its symbol, or if the sequence starts with a mouse
9191 click and we need to switch buffers, we jump back here to rebuild
9192 the initial keymaps from the current buffer. */
9195 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
9197 if (2 > nmaps_allocated
)
9199 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9200 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9201 nmaps_allocated
= 2;
9203 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
9205 else if (!NILP (Voverriding_local_map
))
9207 if (2 > nmaps_allocated
)
9209 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9210 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9211 nmaps_allocated
= 2;
9213 submaps
[nmaps
++] = Voverriding_local_map
;
9221 nminor
= current_minor_maps (0, &maps
);
9222 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9224 if (total
> nmaps_allocated
)
9226 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9227 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9228 nmaps_allocated
= total
;
9231 if (!NILP (orig_keymap
))
9232 submaps
[nmaps
++] = orig_keymap
;
9234 memcpy (submaps
+ nmaps
, maps
, nminor
* sizeof (submaps
[0]));
9238 submaps
[nmaps
++] = orig_local_map
;
9240 submaps
[nmaps
++] = current_global_map
;
9242 /* Find an accurate initial value for first_binding. */
9243 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9244 if (! NILP (submaps
[first_binding
]))
9247 /* Start from the beginning in keybuf. */
9250 /* These are no-ops the first time through, but if we restart, they
9251 revert the echo area and this_command_keys to their original state. */
9252 this_command_key_count
= keys_start
;
9253 if (INTERACTIVE
&& t
< mock_input
)
9254 echo_truncate (echo_start
);
9256 /* If the best binding for the current key sequence is a keymap, or
9257 we may be looking at a function key's escape sequence, keep on
9259 while (first_binding
< nmaps
9260 /* Keep reading as long as there's a prefix binding. */
9261 ? !NILP (submaps
[first_binding
])
9262 /* Don't return in the middle of a possible function key sequence,
9263 if the only bindings we found were via case conversion.
9264 Thus, if ESC O a has a function-key-map translation
9265 and ESC o has a binding, don't return after ESC O,
9266 so that we can translate ESC O plus the next character. */
9267 : (/* indec.start < t || fkey.start < t || */ keytran
.start
< t
))
9270 int used_mouse_menu
= 0;
9272 /* Where the last real key started. If we need to throw away a
9273 key that has expanded into more than one element of keybuf
9274 (say, a mouse click on the mode line which is being treated
9275 as [mode-line (mouse-...)], then we backtrack to this point
9277 int last_real_key_start
;
9279 /* These variables are analogous to echo_start and keys_start;
9280 while those allow us to restart the entire key sequence,
9281 echo_local_start and keys_local_start allow us to throw away
9283 int echo_local_start
, keys_local_start
, local_first_binding
;
9285 eassert (indec
.end
== t
|| (indec
.end
> t
&& indec
.end
<= mock_input
));
9286 eassert (indec
.start
<= indec
.end
);
9287 eassert (fkey
.start
<= fkey
.end
);
9288 eassert (keytran
.start
<= keytran
.end
);
9289 /* key-translation-map is applied *after* function-key-map
9290 which is itself applied *after* input-decode-map. */
9291 eassert (fkey
.end
<= indec
.start
);
9292 eassert (keytran
.end
<= fkey
.start
);
9294 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9295 first_unbound
< keytran
.start
)
9296 { /* The prefix upto first_unbound has no binding and has
9297 no translation left to do either, so we know it's unbound.
9298 If we don't stop now, we risk staying here indefinitely
9299 (if the user keeps entering fkey or keytran prefixes
9300 like C-c ESC ESC ESC ESC ...) */
9302 for (i
= first_unbound
+ 1; i
< t
; i
++)
9303 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9304 mock_input
= t
- first_unbound
- 1;
9305 indec
.end
= indec
.start
-= first_unbound
+ 1;
9306 indec
.map
= indec
.parent
;
9307 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9308 fkey
.map
= fkey
.parent
;
9309 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9310 keytran
.map
= keytran
.parent
;
9311 goto replay_sequence
;
9315 error ("Key sequence too long");
9318 echo_local_start
= echo_length ();
9319 keys_local_start
= this_command_key_count
;
9320 local_first_binding
= first_binding
;
9323 /* These are no-ops, unless we throw away a keystroke below and
9324 jumped back up to replay_key; in that case, these restore the
9325 variables to their original state, allowing us to replay the
9327 if (INTERACTIVE
&& t
< mock_input
)
9328 echo_truncate (echo_local_start
);
9329 this_command_key_count
= keys_local_start
;
9330 first_binding
= local_first_binding
;
9332 /* By default, assume each event is "real". */
9333 last_real_key_start
= t
;
9335 /* Does mock_input indicate that we are re-reading a key sequence? */
9339 add_command_key (key
);
9340 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9341 && NILP (Fzerop (Vecho_keystrokes
)))
9345 /* If not, we should actually read a character. */
9349 KBOARD
*interrupted_kboard
= current_kboard
;
9350 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9351 key
= read_char (NILP (prompt
), nmaps
,
9352 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9353 &used_mouse_menu
, NULL
);
9354 if ((INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9355 /* When switching to a new tty (with a new keyboard),
9356 read_char returns the new buffer, rather than -2
9357 (Bug#5095). This is because `terminal-init-xterm'
9358 calls read-char, which eats the wrong_kboard_jmpbuf
9359 return. Any better way to fix this? -- cyd */
9360 || (interrupted_kboard
!= current_kboard
))
9365 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9366 if (k
== interrupted_kboard
)
9371 /* Don't touch interrupted_kboard when it's been
9373 delayed_switch_frame
= Qnil
;
9374 goto replay_entire_sequence
;
9377 if (!NILP (delayed_switch_frame
))
9379 interrupted_kboard
->kbd_queue
9380 = Fcons (delayed_switch_frame
,
9381 interrupted_kboard
->kbd_queue
);
9382 delayed_switch_frame
= Qnil
;
9386 interrupted_kboard
->kbd_queue
9387 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
9389 /* If the side queue is non-empty, ensure it begins with a
9390 switch-frame, so we'll replay it in the right context. */
9391 if (CONSP (interrupted_kboard
->kbd_queue
)
9392 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
9393 !(EVENT_HAS_PARAMETERS (key
)
9394 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9398 XSETFRAME (frame
, interrupted_frame
);
9399 interrupted_kboard
->kbd_queue
9400 = Fcons (make_lispy_switch_frame (frame
),
9401 interrupted_kboard
->kbd_queue
);
9404 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9405 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9406 goto replay_entire_sequence
;
9410 /* read_char returns t when it shows a menu and the user rejects it.
9414 unbind_to (count
, Qnil
);
9419 /* read_char returns -1 at the end of a macro.
9420 Emacs 18 handles this by returning immediately with a
9421 zero, so that's what we'll do. */
9422 if (INTEGERP (key
) && XINT (key
) == -1)
9425 /* The Microsoft C compiler can't handle the goto that
9431 /* If the current buffer has been changed from under us, the
9432 keymap may have changed, so replay the sequence. */
9435 timer_resume_idle ();
9438 /* Reset the current buffer from the selected window
9439 in case something changed the former and not the latter.
9440 This is to be more consistent with the behavior
9441 of the command_loop_1. */
9442 if (fix_current_buffer
)
9444 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9446 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9447 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9450 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9451 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9452 goto replay_sequence
;
9455 /* If we have a quit that was typed in another frame, and
9456 quit_throw_to_read_char switched buffers,
9457 replay to get the right keymap. */
9459 && XINT (key
) == quit_char
9460 && current_buffer
!= starting_buffer
)
9463 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9467 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9468 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9469 goto replay_sequence
;
9474 if (EVENT_HAS_PARAMETERS (key
)
9475 /* Either a `switch-frame' or a `select-window' event. */
9476 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9478 /* If we're at the beginning of a key sequence, and the caller
9479 says it's okay, go ahead and return this event. If we're
9480 in the midst of a key sequence, delay it until the end. */
9481 if (t
> 0 || !can_return_switch_frame
)
9483 delayed_switch_frame
= key
;
9489 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9493 /* Clicks in non-text areas get prefixed by the symbol
9494 in their CHAR-ADDRESS field. For example, a click on
9495 the mode line is prefixed by the symbol `mode-line'.
9497 Furthermore, key sequences beginning with mouse clicks
9498 are read using the keymaps of the buffer clicked on, not
9499 the current buffer. So we may have to switch the buffer
9502 When we turn one event into two events, we must make sure
9503 that neither of the two looks like the original--so that,
9504 if we replay the events, they won't be expanded again.
9505 If not for this, such reexpansion could happen either here
9506 or when user programs play with this-command-keys. */
9507 if (EVENT_HAS_PARAMETERS (key
))
9512 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9513 if (EQ (kind
, Qmouse_click
))
9515 Lisp_Object window
, posn
;
9517 window
= POSN_WINDOW (EVENT_START (key
));
9518 posn
= POSN_POSN (EVENT_START (key
));
9521 || (!NILP (fake_prefixed_keys
)
9522 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9524 /* We're looking a second time at an event for which
9525 we generated a fake prefix key. Set
9526 last_real_key_start appropriately. */
9528 last_real_key_start
= t
- 1;
9531 /* Key sequences beginning with mouse clicks are
9532 read using the keymaps in the buffer clicked on,
9533 not the current buffer. If we're at the
9534 beginning of a key sequence, switch buffers. */
9535 if (last_real_key_start
== 0
9537 && BUFFERP (XWINDOW (window
)->buffer
)
9538 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9540 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9544 /* Arrange to go back to the original buffer once we're
9545 done reading the key sequence. Note that we can't
9546 use save_excursion_{save,restore} here, because they
9547 save point as well as the current buffer; we don't
9548 want to save point, because redisplay may change it,
9549 to accommodate a Fset_window_start or something. We
9550 don't want to do this at the top of the function,
9551 because we may get input from a subprocess which
9552 wants to change the selected window and stuff (say,
9554 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9556 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9558 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9559 orig_local_map
= get_local_map (PT
, current_buffer
,
9561 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9562 goto replay_sequence
;
9565 /* For a mouse click, get the local text-property keymap
9566 of the place clicked on, rather than point. */
9567 if (last_real_key_start
== 0
9568 && CONSP (XCDR (key
))
9569 && ! localized_local_map
)
9571 Lisp_Object map_here
, start
, pos
;
9573 localized_local_map
= 1;
9574 start
= EVENT_START (key
);
9576 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9578 pos
= POSN_BUFFER_POSN (start
);
9580 && XINT (pos
) >= BEGV
9581 && XINT (pos
) <= ZV
)
9583 map_here
= get_local_map (XINT (pos
),
9584 current_buffer
, Qlocal_map
);
9585 if (!EQ (map_here
, orig_local_map
))
9587 orig_local_map
= map_here
;
9588 ++localized_local_map
;
9591 map_here
= get_local_map (XINT (pos
),
9592 current_buffer
, Qkeymap
);
9593 if (!EQ (map_here
, orig_keymap
))
9595 orig_keymap
= map_here
;
9596 ++localized_local_map
;
9599 if (localized_local_map
> 1)
9604 goto replay_sequence
;
9610 /* Expand mode-line and scroll-bar events into two events:
9611 use posn as a fake prefix key. */
9613 && (NILP (fake_prefixed_keys
)
9614 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9616 if (t
+ 1 >= bufsize
)
9617 error ("Key sequence too long");
9620 keybuf
[t
+ 1] = key
;
9623 /* Record that a fake prefix key has been generated
9624 for KEY. Don't modify the event; this would
9625 prevent proper action when the event is pushed
9626 back into unread-command-events. */
9627 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9629 /* If on a mode line string with a local keymap,
9630 reconsider the key sequence with that keymap. */
9631 if (string
= POSN_STRING (EVENT_START (key
)),
9632 (CONSP (string
) && STRINGP (XCAR (string
))))
9634 Lisp_Object pos
, map
, map2
;
9636 pos
= XCDR (string
);
9637 string
= XCAR (string
);
9639 && XINT (pos
) < SCHARS (string
))
9641 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9643 orig_local_map
= map
;
9644 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9647 if (!NILP (map
) || !NILP (map2
))
9648 goto replay_sequence
;
9654 else if (NILP (from_string
)
9655 && (string
= POSN_STRING (EVENT_START (key
)),
9656 (CONSP (string
) && STRINGP (XCAR (string
)))))
9658 /* For a click on a string, i.e. overlay string or a
9659 string displayed via the `display' property,
9660 consider `local-map' and `keymap' properties of
9662 Lisp_Object pos
, map
, map2
;
9664 pos
= XCDR (string
);
9665 string
= XCAR (string
);
9667 && XINT (pos
) < SCHARS (string
))
9669 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9671 orig_local_map
= map
;
9672 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9676 if (!NILP (map
) || !NILP (map2
))
9678 from_string
= string
;
9681 goto replay_sequence
;
9686 else if (CONSP (XCDR (key
))
9687 && CONSP (EVENT_START (key
))
9688 && CONSP (XCDR (EVENT_START (key
))))
9692 posn
= POSN_POSN (EVENT_START (key
));
9693 /* Handle menu-bar events:
9694 insert the dummy prefix event `menu-bar'. */
9695 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9697 if (t
+ 1 >= bufsize
)
9698 error ("Key sequence too long");
9702 /* Zap the position in key, so we know that we've
9703 expanded it, and don't try to do so again. */
9704 POSN_SET_POSN (EVENT_START (key
),
9705 Fcons (posn
, Qnil
));
9708 goto replay_sequence
;
9710 else if (CONSP (posn
))
9712 /* We're looking at the second event of a
9713 sequence which we expanded before. Set
9714 last_real_key_start appropriately. */
9715 if (last_real_key_start
== t
&& t
> 0)
9716 last_real_key_start
= t
- 1;
9721 /* We have finally decided that KEY is something we might want
9723 first_binding
= (follow_key (key
,
9724 nmaps
- first_binding
,
9725 submaps
+ first_binding
,
9726 defs
+ first_binding
,
9727 submaps
+ first_binding
)
9730 /* If KEY wasn't bound, we'll try some fallbacks. */
9731 if (first_binding
< nmaps
)
9732 /* This is needed for the following scenario:
9733 event 0: a down-event that gets dropped by calling replay_key.
9734 event 1: some normal prefix like C-h.
9735 After event 0, first_unbound is 0, after event 1 indec.start,
9736 fkey.start, and keytran.start are all 1, so when we see that
9737 C-h is bound, we need to update first_unbound. */
9738 first_unbound
= max (t
+ 1, first_unbound
);
9743 /* Remember the position to put an upper bound on indec.start. */
9744 first_unbound
= min (t
, first_unbound
);
9746 head
= EVENT_HEAD (key
);
9747 if (help_char_p (head
) && t
> 0)
9749 read_key_sequence_cmd
= Vprefix_help_command
;
9751 last_nonmenu_event
= key
;
9752 /* The Microsoft C compiler can't handle the goto that
9760 Lisp_Object breakdown
;
9763 breakdown
= parse_modifiers (head
);
9764 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9765 /* Attempt to reduce an unbound mouse event to a simpler
9766 event that is bound:
9767 Drags reduce to clicks.
9768 Double-clicks reduce to clicks.
9769 Triple-clicks reduce to double-clicks, then to clicks.
9770 Down-clicks are eliminated.
9771 Double-downs reduce to downs, then are eliminated.
9772 Triple-downs reduce to double-downs, then to downs,
9773 then are eliminated. */
9774 if (modifiers
& (down_modifier
| drag_modifier
9775 | double_modifier
| triple_modifier
))
9777 while (modifiers
& (down_modifier
| drag_modifier
9778 | double_modifier
| triple_modifier
))
9780 Lisp_Object new_head
, new_click
;
9781 if (modifiers
& triple_modifier
)
9782 modifiers
^= (double_modifier
| triple_modifier
);
9783 else if (modifiers
& double_modifier
)
9784 modifiers
&= ~double_modifier
;
9785 else if (modifiers
& drag_modifier
)
9786 modifiers
&= ~drag_modifier
;
9789 /* Dispose of this `down' event by simply jumping
9790 back to replay_key, to get another event.
9792 Note that if this event came from mock input,
9793 then just jumping back to replay_key will just
9794 hand it to us again. So we have to wipe out any
9797 We could delete keybuf[t] and shift everything
9798 after that to the left by one spot, but we'd also
9799 have to fix up any variable that points into
9800 keybuf, and shifting isn't really necessary
9803 Adding prefixes for non-textual mouse clicks
9804 creates two characters of mock input, and both
9805 must be thrown away. If we're only looking at
9806 the prefix now, we can just jump back to
9807 replay_key. On the other hand, if we've already
9808 processed the prefix, and now the actual click
9809 itself is giving us trouble, then we've lost the
9810 state of the keymaps we want to backtrack to, and
9811 we need to replay the whole sequence to rebuild
9814 Beyond that, only function key expansion could
9815 create more than two keys, but that should never
9816 generate mouse events, so it's okay to zero
9817 mock_input in that case too.
9819 FIXME: The above paragraph seems just plain
9820 wrong, if you consider things like
9821 xterm-mouse-mode. -stef
9823 Isn't this just the most wonderful code ever? */
9825 /* If mock_input > t + 1, the above simplification
9826 will actually end up dropping keys on the floor.
9827 This is probably OK for now, but even
9828 if mock_input <= t + 1, we need to adjust indec,
9830 Typical case [header-line down-mouse-N]:
9831 mock_input = 2, t = 1, fkey.end = 1,
9832 last_real_key_start = 0. */
9833 if (indec
.end
> last_real_key_start
)
9835 indec
.end
= indec
.start
9836 = min (last_real_key_start
, indec
.start
);
9837 indec
.map
= indec
.parent
;
9838 if (fkey
.end
> last_real_key_start
)
9840 fkey
.end
= fkey
.start
9841 = min (last_real_key_start
, fkey
.start
);
9842 fkey
.map
= fkey
.parent
;
9843 if (keytran
.end
> last_real_key_start
)
9845 keytran
.end
= keytran
.start
9846 = min (last_real_key_start
, keytran
.start
);
9847 keytran
.map
= keytran
.parent
;
9851 if (t
== last_real_key_start
)
9858 mock_input
= last_real_key_start
;
9859 goto replay_sequence
;
9864 = apply_modifiers (modifiers
, XCAR (breakdown
));
9866 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9868 /* Look for a binding for this new key. follow_key
9869 promises that it didn't munge submaps the
9870 last time we called it, since key was unbound. */
9872 = (follow_key (new_click
,
9873 nmaps
- local_first_binding
,
9874 submaps
+ local_first_binding
,
9875 defs
+ local_first_binding
,
9876 submaps
+ local_first_binding
)
9877 + local_first_binding
);
9879 /* If that click is bound, go for it. */
9880 if (first_binding
< nmaps
)
9885 /* Otherwise, we'll leave key set to the drag event. */
9892 /* Normally, last_nonmenu_event gets the previous key we read.
9893 But when a mouse popup menu is being used,
9894 we don't update last_nonmenu_event; it continues to hold the mouse
9895 event that preceded the first level of menu. */
9896 if (!used_mouse_menu
)
9897 last_nonmenu_event
= key
;
9899 /* Record what part of this_command_keys is the current key sequence. */
9900 this_single_command_key_start
= this_command_key_count
- t
;
9902 /* Look for this sequence in input-decode-map.
9903 Scan from indec.end until we find a bound suffix. */
9904 while (indec
.end
< t
)
9906 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9909 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9910 done
= keyremap_step (keybuf
, bufsize
, &indec
, max (t
, mock_input
),
9915 mock_input
= diff
+ max (t
, mock_input
);
9916 goto replay_sequence
;
9920 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
])
9921 && indec
.start
>= t
)
9922 /* There is a binding and it's not a prefix.
9923 (and it doesn't have any input-decode-map translation pending).
9924 There is thus no function-key in this sequence.
9925 Moving fkey.start is important in this case to allow keytran.start
9926 to go over the sequence before we return (since we keep the
9927 invariant that keytran.end <= fkey.start). */
9930 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9933 /* If the sequence is unbound, see if we can hang a function key
9934 off the end of it. */
9935 /* Continue scan from fkey.end until we find a bound suffix. */
9936 while (fkey
.end
< indec
.start
)
9938 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9941 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9942 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9943 max (t
, mock_input
),
9944 /* If there's a binding (i.e.
9945 first_binding >= nmaps) we don't want
9946 to apply this function-key-mapping. */
9947 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9952 mock_input
= diff
+ max (t
, mock_input
);
9953 /* Adjust the input-decode-map counters. */
9955 indec
.start
+= diff
;
9957 goto replay_sequence
;
9961 /* Look for this sequence in key-translation-map.
9962 Scan from keytran.end until we find a bound suffix. */
9963 while (keytran
.end
< fkey
.start
)
9965 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9968 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9969 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9974 mock_input
= diff
+ max (t
, mock_input
);
9975 /* Adjust the function-key-map and input-decode-map counters. */
9977 indec
.start
+= diff
;
9981 goto replay_sequence
;
9985 /* If KEY is not defined in any of the keymaps,
9986 and cannot be part of a function key or translation,
9987 and is an upper case letter
9988 use the corresponding lower-case letter instead. */
9989 if (first_binding
>= nmaps
9990 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
9992 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9993 && UPPERCASEP (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9994 || (XINT (key
) & shift_modifier
)))
9996 Lisp_Object new_key
;
9998 original_uppercase
= key
;
9999 original_uppercase_position
= t
- 1;
10001 if (XINT (key
) & shift_modifier
)
10002 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
10004 XSETINT (new_key
, (DOWNCASE (XINT (key
) & ~CHAR_MODIFIER_MASK
)
10005 | (XINT (key
) & CHAR_MODIFIER_MASK
)));
10007 /* We have to do this unconditionally, regardless of whether
10008 the lower-case char is defined in the keymaps, because they
10009 might get translated through function-key-map. */
10010 keybuf
[t
- 1] = new_key
;
10011 mock_input
= max (t
, mock_input
);
10012 shift_translated
= 1;
10014 goto replay_sequence
;
10016 /* If KEY is not defined in any of the keymaps,
10017 and cannot be part of a function key or translation,
10018 and is a shifted function key,
10019 use the corresponding unshifted function key instead. */
10020 if (first_binding
>= nmaps
10021 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
)
10023 Lisp_Object breakdown
= parse_modifiers (key
);
10025 = CONSP (breakdown
) ? (XINT (XCAR (XCDR (breakdown
)))) : 0;
10027 if (modifiers
& shift_modifier
10028 /* Treat uppercase keys as shifted. */
10030 && (KEY_TO_CHAR (key
)
10031 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
10032 && UPPERCASEP (KEY_TO_CHAR (key
))))
10034 Lisp_Object new_key
10035 = (modifiers
& shift_modifier
10036 ? apply_modifiers (modifiers
& ~shift_modifier
,
10038 : make_number (DOWNCASE (KEY_TO_CHAR (key
)) | modifiers
));
10040 original_uppercase
= key
;
10041 original_uppercase_position
= t
- 1;
10043 /* We have to do this unconditionally, regardless of whether
10044 the lower-case char is defined in the keymaps, because they
10045 might get translated through function-key-map. */
10046 keybuf
[t
- 1] = new_key
;
10047 mock_input
= max (t
, mock_input
);
10048 /* Reset fkey (and consequently keytran) to apply
10049 function-key-map on the result, so that S-backspace is
10050 correctly mapped to DEL (via backspace). OTOH,
10051 input-decode-map doesn't need to go through it again. */
10052 fkey
.start
= fkey
.end
= 0;
10053 keytran
.start
= keytran
.end
= 0;
10054 shift_translated
= 1;
10056 goto replay_sequence
;
10061 read_key_sequence_cmd
= (first_binding
< nmaps
10062 ? defs
[first_binding
]
10065 unread_switch_frame
= delayed_switch_frame
;
10066 unbind_to (count
, Qnil
);
10068 /* Don't downcase the last character if the caller says don't.
10069 Don't downcase it if the result is undefined, either. */
10070 if ((dont_downcase_last
|| first_binding
>= nmaps
)
10072 && t
- 1 == original_uppercase_position
)
10074 keybuf
[t
- 1] = original_uppercase
;
10075 shift_translated
= 0;
10078 if (shift_translated
)
10079 Vthis_command_keys_shift_translated
= Qt
;
10081 /* Occasionally we fabricate events, perhaps by expanding something
10082 according to function-key-map, or by adding a prefix symbol to a
10083 mouse click in the scroll bar or modeline. In this cases, return
10084 the entire generated key sequence, even if we hit an unbound
10085 prefix or a definition before the end. This means that you will
10086 be able to push back the event properly, and also means that
10087 read-key-sequence will always return a logical unit.
10090 for (; t
< mock_input
; t
++)
10092 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
10093 && NILP (Fzerop (Vecho_keystrokes
)))
10094 echo_char (keybuf
[t
]);
10095 add_command_key (keybuf
[t
]);
10102 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
10103 doc
: /* Read a sequence of keystrokes and return as a string or vector.
10104 The sequence is sufficient to specify a non-prefix command in the
10105 current local and global maps.
10107 First arg PROMPT is a prompt string. If nil, do not prompt specially.
10108 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
10109 as a continuation of the previous key.
10111 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
10112 convert the last event to lower case. (Normally any upper case event
10113 is converted to lower case if the original event is undefined and the lower
10114 case equivalent is defined.) A non-nil value is appropriate for reading
10115 a key sequence to be defined.
10117 A C-g typed while in this function is treated like any other character,
10118 and `quit-flag' is not set.
10120 If the key sequence starts with a mouse click, then the sequence is read
10121 using the keymaps of the buffer of the window clicked in, not the buffer
10122 of the selected window as normal.
10124 `read-key-sequence' drops unbound button-down events, since you normally
10125 only care about the click or drag events which follow them. If a drag
10126 or multi-click event is unbound, but the corresponding click event would
10127 be bound, `read-key-sequence' turns the event into a click event at the
10128 drag's starting position. This means that you don't have to distinguish
10129 between click and drag, double, or triple events unless you want to.
10131 `read-key-sequence' prefixes mouse events on mode lines, the vertical
10132 lines separating windows, and scroll bars with imaginary keys
10133 `mode-line', `vertical-line', and `vertical-scroll-bar'.
10135 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
10136 function will process a switch-frame event if the user switches frames
10137 before typing anything. If the user switches frames in the middle of a
10138 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
10139 is nil, then the event will be put off until after the current key sequence.
10141 `read-key-sequence' checks `function-key-map' for function key
10142 sequences, where they wouldn't conflict with ordinary bindings. See
10143 `function-key-map' for more details.
10145 The optional fifth argument COMMAND-LOOP, if non-nil, means
10146 that this key sequence is being read by something that will
10147 read commands one after another. It should be nil if the caller
10148 will read just one key sequence. */)
10149 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object command_loop
)
10151 Lisp_Object keybuf
[30];
10153 struct gcpro gcpro1
;
10154 int count
= SPECPDL_INDEX ();
10156 if (!NILP (prompt
))
10157 CHECK_STRING (prompt
);
10160 specbind (Qinput_method_exit_on_first_char
,
10161 (NILP (command_loop
) ? Qt
: Qnil
));
10162 specbind (Qinput_method_use_echo_area
,
10163 (NILP (command_loop
) ? Qt
: Qnil
));
10165 memset (keybuf
, 0, sizeof keybuf
);
10166 GCPRO1 (keybuf
[0]);
10167 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10169 if (NILP (continue_echo
))
10171 this_command_key_count
= 0;
10172 this_command_key_count_reset
= 0;
10173 this_single_command_key_start
= 0;
10176 #ifdef HAVE_WINDOW_SYSTEM
10177 if (display_hourglass_p
)
10178 cancel_hourglass ();
10181 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10182 prompt
, ! NILP (dont_downcase_last
),
10183 ! NILP (can_return_switch_frame
), 0);
10185 #if 0 /* The following is fine for code reading a key sequence and
10186 then proceeding with a lenghty computation, but it's not good
10187 for code reading keys in a loop, like an input method. */
10188 #ifdef HAVE_WINDOW_SYSTEM
10189 if (display_hourglass_p
)
10190 start_hourglass ();
10200 return unbind_to (count
, make_event_array (i
, keybuf
));
10203 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10204 Sread_key_sequence_vector
, 1, 5, 0,
10205 doc
: /* Like `read-key-sequence' but always return a vector. */)
10206 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object command_loop
)
10208 Lisp_Object keybuf
[30];
10210 struct gcpro gcpro1
;
10211 int count
= SPECPDL_INDEX ();
10213 if (!NILP (prompt
))
10214 CHECK_STRING (prompt
);
10217 specbind (Qinput_method_exit_on_first_char
,
10218 (NILP (command_loop
) ? Qt
: Qnil
));
10219 specbind (Qinput_method_use_echo_area
,
10220 (NILP (command_loop
) ? Qt
: Qnil
));
10222 memset (keybuf
, 0, sizeof keybuf
);
10223 GCPRO1 (keybuf
[0]);
10224 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10226 if (NILP (continue_echo
))
10228 this_command_key_count
= 0;
10229 this_command_key_count_reset
= 0;
10230 this_single_command_key_start
= 0;
10233 #ifdef HAVE_WINDOW_SYSTEM
10234 if (display_hourglass_p
)
10235 cancel_hourglass ();
10238 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10239 prompt
, ! NILP (dont_downcase_last
),
10240 ! NILP (can_return_switch_frame
), 0);
10242 #ifdef HAVE_WINDOW_SYSTEM
10243 if (display_hourglass_p
)
10244 start_hourglass ();
10253 return unbind_to (count
, Fvector (i
, keybuf
));
10256 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10257 doc
: /* Execute CMD as an editor command.
10258 CMD must be a symbol that satisfies the `commandp' predicate.
10259 Optional second arg RECORD-FLAG non-nil
10260 means unconditionally put this command in `command-history'.
10261 Otherwise, that is done only if an arg is read using the minibuffer.
10262 The argument KEYS specifies the value to use instead of (this-command-keys)
10263 when reading the arguments; if it is nil, (this-command-keys) is used.
10264 The argument SPECIAL, if non-nil, means that this command is executing
10265 a special event, so ignore the prefix argument and don't clear it. */)
10266 (Lisp_Object cmd
, Lisp_Object record_flag
, Lisp_Object keys
, Lisp_Object special
)
10268 register Lisp_Object final
;
10269 register Lisp_Object tem
;
10270 Lisp_Object prefixarg
;
10272 debug_on_next_call
= 0;
10274 if (NILP (special
))
10276 prefixarg
= current_kboard
->Vprefix_arg
;
10277 Vcurrent_prefix_arg
= prefixarg
;
10278 current_kboard
->Vprefix_arg
= Qnil
;
10285 tem
= Fget (cmd
, Qdisabled
);
10286 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10288 tem
= Fsymbol_value (Qdisabled_command_function
);
10290 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10296 final
= Findirect_function (cmd
, Qnil
);
10298 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10300 struct gcpro gcpro1
, gcpro2
;
10302 GCPRO2 (cmd
, prefixarg
);
10303 do_autoload (final
, cmd
);
10310 if (STRINGP (final
) || VECTORP (final
))
10312 /* If requested, place the macro in the command history. For
10313 other sorts of commands, call-interactively takes care of
10315 if (!NILP (record_flag
))
10318 = Fcons (Fcons (Qexecute_kbd_macro
,
10319 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10322 /* Don't keep command history around forever. */
10323 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10325 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10327 XSETCDR (tem
, Qnil
);
10331 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10334 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10335 /* Don't call Fcall_interactively directly because we want to make
10336 sure the backtrace has an entry for `call-interactively'.
10337 For the same reason, pass `cmd' rather than `final'. */
10338 return call3 (Qcall_interactively
, cmd
, record_flag
, keys
);
10345 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10347 doc
: /* Read function name, then read its arguments and call it.
10349 To pass a numeric argument to the command you are invoking with, specify
10350 the numeric argument to this command.
10352 Noninteractively, the argument PREFIXARG is the prefix argument to
10353 give to the command you invoke, if it asks for an argument. */)
10354 (Lisp_Object prefixarg
)
10356 Lisp_Object function
;
10357 int saved_last_point_position
;
10358 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10359 Lisp_Object bindings
, value
;
10360 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10361 #ifdef HAVE_WINDOW_SYSTEM
10362 /* The call to Fcompleting_read will start and cancel the hourglass,
10363 but if the hourglass was already scheduled, this means that no
10364 hourglass will be shown for the actual M-x command itself.
10365 So we restart it if it is already scheduled. Note that checking
10366 hourglass_shown_p is not enough, normally the hourglass is not shown,
10367 just scheduled to be shown. */
10368 int hstarted
= hourglass_started ();
10371 saved_keys
= Fvector (this_command_key_count
,
10372 XVECTOR (this_command_keys
)->contents
);
10373 saved_last_point_position_buffer
= last_point_position_buffer
;
10374 saved_last_point_position
= last_point_position
;
10375 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10377 function
= call0 (intern ("read-extended-command"));
10379 #ifdef HAVE_WINDOW_SYSTEM
10380 if (hstarted
) start_hourglass ();
10383 if (STRINGP (function
) && SCHARS (function
) == 0)
10384 error ("No command name given");
10386 /* Set this_command_keys to the concatenation of saved_keys and
10387 function, followed by a RET. */
10392 this_command_key_count
= 0;
10393 this_command_key_count_reset
= 0;
10394 this_single_command_key_start
= 0;
10396 keys
= XVECTOR (saved_keys
)->contents
;
10397 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10398 add_command_key (keys
[i
]);
10400 for (i
= 0; i
< SCHARS (function
); i
++)
10401 add_command_key (Faref (function
, make_number (i
)));
10403 add_command_key (make_number ('\015'));
10406 last_point_position
= saved_last_point_position
;
10407 last_point_position_buffer
= saved_last_point_position_buffer
;
10411 function
= Fintern (function
, Qnil
);
10412 current_kboard
->Vprefix_arg
= prefixarg
;
10413 Vthis_command
= function
;
10414 real_this_command
= function
;
10416 /* If enabled, show which key runs this command. */
10417 if (!NILP (Vsuggest_key_bindings
)
10418 && NILP (Vexecuting_kbd_macro
)
10419 && SYMBOLP (function
))
10420 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10426 GCPRO3 (bindings
, value
, function
);
10427 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10429 /* If the command has a key binding, print it now. */
10430 if (!NILP (bindings
)
10431 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10434 /* But first wait, and skip the message if there is input. */
10435 Lisp_Object waited
;
10437 /* If this command displayed something in the echo area;
10438 wait a few seconds, then display our suggestion message. */
10439 if (NILP (echo_area_buffer
[0]))
10440 waited
= sit_for (make_number (0), 0, 2);
10441 else if (NUMBERP (Vsuggest_key_bindings
))
10442 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10444 waited
= sit_for (make_number (2), 0, 2);
10446 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10448 Lisp_Object binding
;
10450 int message_p
= push_message ();
10451 int count
= SPECPDL_INDEX ();
10453 record_unwind_protect (pop_message_unwind
, Qnil
);
10454 binding
= Fkey_description (bindings
, Qnil
);
10457 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10460 sprintf (newmessage
, "You can run the command `%s' with %s",
10461 SDATA (SYMBOL_NAME (function
)),
10463 message2_nolog (newmessage
,
10464 strlen (newmessage
),
10465 STRING_MULTIBYTE (binding
));
10466 if (NUMBERP (Vsuggest_key_bindings
))
10467 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10469 waited
= sit_for (make_number (2), 0, 2);
10471 if (!NILP (waited
) && message_p
)
10472 restore_message ();
10474 unbind_to (count
, Qnil
);
10478 RETURN_UNGCPRO (value
);
10482 /* Return nonzero if input events are pending. */
10485 detect_input_pending (void)
10487 if (!input_pending
)
10488 get_input_pending (&input_pending
, 0);
10490 return input_pending
;
10493 /* Return nonzero if input events other than mouse movements are
10497 detect_input_pending_ignore_squeezables (void)
10499 if (!input_pending
)
10500 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10502 return input_pending
;
10505 /* Return nonzero if input events are pending, and run any pending timers. */
10508 detect_input_pending_run_timers (int do_display
)
10510 int old_timers_run
= timers_run
;
10512 if (!input_pending
)
10513 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10515 if (old_timers_run
!= timers_run
&& do_display
)
10517 redisplay_preserve_echo_area (8);
10518 /* The following fixes a bug when using lazy-lock with
10519 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10520 from an idle timer function. The symptom of the bug is that
10521 the cursor sometimes doesn't become visible until the next X
10522 event is processed. --gerd. */
10524 Lisp_Object tail
, frame
;
10525 FOR_EACH_FRAME (tail
, frame
)
10526 if (FRAME_RIF (XFRAME (frame
)))
10527 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10531 return input_pending
;
10534 /* This is called in some cases before a possible quit.
10535 It cases the next call to detect_input_pending to recompute input_pending.
10536 So calling this function unnecessarily can't do any harm. */
10539 clear_input_pending (void)
10544 /* Return nonzero if there are pending requeued events.
10545 This isn't used yet. The hope is to make wait_reading_process_output
10546 call it, and return if it runs Lisp code that unreads something.
10547 The problem is, kbd_buffer_get_event needs to be fixed to know what
10548 to do in that case. It isn't trivial. */
10551 requeued_events_pending_p (void)
10553 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10557 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10558 doc
: /* Return t if command input is currently available with no wait.
10559 Actually, the value is nil only if we can be sure that no input is available;
10560 if there is a doubt, the value is t. */)
10563 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10564 || !NILP (Vunread_post_input_method_events
)
10565 || !NILP (Vunread_input_method_events
))
10568 get_input_pending (&input_pending
,
10569 READABLE_EVENTS_DO_TIMERS_NOW
10570 | READABLE_EVENTS_FILTER_EVENTS
);
10571 return input_pending
> 0 ? Qt
: Qnil
;
10574 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10575 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10578 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10581 if (total_keys
< NUM_RECENT_KEYS
)
10582 return Fvector (total_keys
, keys
);
10585 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10586 memcpy (XVECTOR (val
)->contents
, keys
+ recent_keys_index
,
10587 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10588 memcpy (XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10589 keys
, recent_keys_index
* sizeof (Lisp_Object
));
10594 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10595 doc
: /* Return the key sequence that invoked this command.
10596 However, if the command has called `read-key-sequence', it returns
10597 the last key sequence that has been read.
10598 The value is a string or a vector.
10600 See also `this-command-keys-vector'. */)
10603 return make_event_array (this_command_key_count
,
10604 XVECTOR (this_command_keys
)->contents
);
10607 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10608 doc
: /* Return the key sequence that invoked this command, as a vector.
10609 However, if the command has called `read-key-sequence', it returns
10610 the last key sequence that has been read.
10612 See also `this-command-keys'. */)
10615 return Fvector (this_command_key_count
,
10616 XVECTOR (this_command_keys
)->contents
);
10619 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10620 Sthis_single_command_keys
, 0, 0, 0,
10621 doc
: /* Return the key sequence that invoked this command.
10622 More generally, it returns the last key sequence read, either by
10623 the command loop or by `read-key-sequence'.
10624 Unlike `this-command-keys', this function's value
10625 does not include prefix arguments.
10626 The value is always a vector. */)
10629 return Fvector (this_command_key_count
10630 - this_single_command_key_start
,
10631 (XVECTOR (this_command_keys
)->contents
10632 + this_single_command_key_start
));
10635 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10636 Sthis_single_command_raw_keys
, 0, 0, 0,
10637 doc
: /* Return the raw events that were read for this command.
10638 More generally, it returns the last key sequence read, either by
10639 the command loop or by `read-key-sequence'.
10640 Unlike `this-single-command-keys', this function's value
10641 shows the events before all translations (except for input methods).
10642 The value is always a vector. */)
10645 return Fvector (raw_keybuf_count
,
10646 (XVECTOR (raw_keybuf
)->contents
));
10649 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10650 Sreset_this_command_lengths
, 0, 0, 0,
10651 doc
: /* Make the unread events replace the last command and echo.
10652 Used in `universal-argument-other-key'.
10654 `universal-argument-other-key' rereads the event just typed.
10655 It then gets translated through `function-key-map'.
10656 The translated event has to replace the real events,
10657 both in the value of (this-command-keys) and in echoing.
10658 To achieve this, `universal-argument-other-key' calls
10659 `reset-this-command-lengths', which discards the record of reading
10660 these events the first time. */)
10663 this_command_key_count
= before_command_key_count
;
10664 if (this_command_key_count
< this_single_command_key_start
)
10665 this_single_command_key_start
= this_command_key_count
;
10667 echo_truncate (before_command_echo_length
);
10669 /* Cause whatever we put into unread-command-events
10670 to echo as if it were being freshly read from the keyboard. */
10671 this_command_key_count_reset
= 1;
10676 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10677 Sclear_this_command_keys
, 0, 1, 0,
10678 doc
: /* Clear out the vector that `this-command-keys' returns.
10679 Also clear the record of the last 100 events, unless optional arg
10680 KEEP-RECORD is non-nil. */)
10681 (Lisp_Object keep_record
)
10685 this_command_key_count
= 0;
10686 this_command_key_count_reset
= 0;
10688 if (NILP (keep_record
))
10690 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10691 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10693 recent_keys_index
= 0;
10698 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10699 doc
: /* Return the current depth in recursive edits. */)
10703 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10707 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10708 "FOpen dribble file: ",
10709 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10710 If FILE is nil, close any open dribble file. */)
10722 file
= Fexpand_file_name (file
, Qnil
);
10723 dribble
= fopen (SDATA (file
), "w");
10725 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10730 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10731 doc
: /* Discard the contents of the terminal input buffer.
10732 Also end any kbd macro being defined. */)
10735 if (!NILP (current_kboard
->defining_kbd_macro
))
10737 /* Discard the last command from the macro. */
10738 Fcancel_kbd_macro_events ();
10742 update_mode_lines
++;
10744 Vunread_command_events
= Qnil
;
10745 unread_command_char
= -1;
10747 discard_tty_input ();
10749 kbd_fetch_ptr
= kbd_store_ptr
;
10755 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10756 doc
: /* Stop Emacs and return to superior process. You can resume later.
10757 If `cannot-suspend' is non-nil, or if the system doesn't support job
10758 control, run a subshell instead.
10760 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10761 to be read as terminal input by Emacs's parent, after suspension.
10763 Before suspending, run the normal hook `suspend-hook'.
10764 After resumption run the normal hook `suspend-resume-hook'.
10766 Some operating systems cannot stop the Emacs process and resume it later.
10767 On such systems, Emacs starts a subshell instead of suspending. */)
10768 (Lisp_Object stuffstring
)
10770 int count
= SPECPDL_INDEX ();
10771 int old_height
, old_width
;
10773 struct gcpro gcpro1
;
10775 if (tty_list
&& tty_list
->next
)
10776 error ("There are other tty frames open; close them before suspending Emacs");
10778 if (!NILP (stuffstring
))
10779 CHECK_STRING (stuffstring
);
10781 /* Run the functions in suspend-hook. */
10782 if (!NILP (Vrun_hooks
))
10783 call1 (Vrun_hooks
, intern ("suspend-hook"));
10785 GCPRO1 (stuffstring
);
10786 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
10787 reset_all_sys_modes ();
10788 /* sys_suspend can get an error if it tries to fork a subshell
10789 and the system resources aren't available for that. */
10790 record_unwind_protect ((Lisp_Object (*) (Lisp_Object
)) init_all_sys_modes
,
10792 stuff_buffered_input (stuffstring
);
10793 if (cannot_suspend
)
10797 unbind_to (count
, Qnil
);
10799 /* Check if terminal/window size has changed.
10800 Note that this is not useful when we are running directly
10801 with a window system; but suspend should be disabled in that case. */
10802 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
10803 if (width
!= old_width
|| height
!= old_height
)
10804 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10806 /* Run suspend-resume-hook. */
10807 if (!NILP (Vrun_hooks
))
10808 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10814 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10815 Then in any case stuff anything Emacs has read ahead and not used. */
10818 stuff_buffered_input (Lisp_Object stuffstring
)
10820 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10821 register unsigned char *p
;
10823 if (STRINGP (stuffstring
))
10825 register int count
;
10827 p
= SDATA (stuffstring
);
10828 count
= SBYTES (stuffstring
);
10829 while (count
-- > 0)
10834 /* Anything we have read ahead, put back for the shell to read. */
10835 /* ?? What should this do when we have multiple keyboards??
10836 Should we ignore anything that was typed in at the "wrong" kboard?
10838 rms: we should stuff everything back into the kboard
10840 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10843 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10844 kbd_fetch_ptr
= kbd_buffer
;
10845 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10846 stuff_char (kbd_fetch_ptr
->code
);
10848 clear_event (kbd_fetch_ptr
);
10852 #endif /* SIGTSTP */
10856 set_waiting_for_input (struct timeval
*time_to_clear
)
10858 input_available_clear_time
= time_to_clear
;
10860 /* Tell handle_interrupt to throw back to read_char, */
10861 waiting_for_input
= 1;
10863 /* If handle_interrupt was called before and buffered a C-g,
10864 make it run again now, to avoid timing error. */
10865 if (!NILP (Vquit_flag
))
10866 quit_throw_to_read_char ();
10870 clear_waiting_for_input (void)
10872 /* Tell handle_interrupt not to throw back to read_char, */
10873 waiting_for_input
= 0;
10874 input_available_clear_time
= 0;
10877 /* The SIGINT handler.
10879 If we have a frame on the controlling tty, we assume that the
10880 SIGINT was generated by C-g, so we call handle_interrupt.
10881 Otherwise, the handler kills Emacs. */
10884 interrupt_signal (int signalnum
) /* If we don't have an argument, some */
10885 /* compilers complain in signal calls. */
10887 /* Must preserve main program's value of errno. */
10888 int old_errno
= errno
;
10889 struct terminal
*terminal
;
10891 SIGNAL_THREAD_CHECK (signalnum
);
10893 /* See if we have an active terminal on our controlling tty. */
10894 terminal
= get_named_tty ("/dev/tty");
10897 /* If there are no frames there, let's pretend that we are a
10898 well-behaving UN*X program and quit. */
10899 Fkill_emacs (Qnil
);
10903 /* Otherwise, the SIGINT was probably generated by C-g. */
10905 /* Set internal_last_event_frame to the top frame of the
10906 controlling tty, if we have a frame there. We disable the
10907 interrupt key on secondary ttys, so the SIGINT must have come
10908 from the controlling tty. */
10909 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
10911 handle_interrupt ();
10917 /* This routine is called at interrupt level in response to C-g.
10919 It is called from the SIGINT handler or kbd_buffer_store_event.
10921 If `waiting_for_input' is non zero, then unless `echoing' is
10922 nonzero, immediately throw back to read_char.
10924 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10925 eval to throw, when it gets a chance. If quit-flag is already
10926 non-nil, it stops the job right away. */
10929 handle_interrupt (void)
10935 /* XXX This code needs to be revised for multi-tty support. */
10936 if (!NILP (Vquit_flag
) && get_named_tty ("/dev/tty"))
10938 /* If SIGINT isn't blocked, don't let us be interrupted by
10939 another SIGINT, it might be harmful due to non-reentrancy
10940 in I/O functions. */
10941 sigblock (sigmask (SIGINT
));
10944 reset_all_sys_modes ();
10946 #ifdef SIGTSTP /* Support possible in later USG versions */
10948 * On systems which can suspend the current process and return to the original
10949 * shell, this command causes the user to end up back at the shell.
10950 * The "Auto-save" and "Abort" questions are not asked until
10951 * the user elects to return to emacs, at which point he can save the current
10952 * job and either dump core or continue.
10956 /* Perhaps should really fork an inferior shell?
10957 But that would not provide any way to get back
10958 to the original shell, ever. */
10959 printf ("No support for stopping a process on this operating system;\n");
10960 printf ("you can continue or abort.\n");
10961 #endif /* not SIGTSTP */
10963 /* We must remain inside the screen area when the internal terminal
10964 is used. Note that [Enter] is not echoed by dos. */
10965 cursor_to (SELECTED_FRAME (), 0, 0);
10967 /* It doesn't work to autosave while GC is in progress;
10968 the code used for auto-saving doesn't cope with the mark bit. */
10969 if (!gc_in_progress
)
10971 printf ("Auto-save? (y or n) ");
10973 if (((c
= getchar ()) & ~040) == 'Y')
10975 Fdo_auto_save (Qt
, Qnil
);
10977 printf ("\r\nAuto-save done");
10978 #else /* not MSDOS */
10979 printf ("Auto-save done\n");
10980 #endif /* not MSDOS */
10982 while (c
!= '\n') c
= getchar ();
10986 /* During GC, it must be safe to reenable quitting again. */
10987 Vinhibit_quit
= Qnil
;
10990 #endif /* not MSDOS */
10991 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10992 printf ("but will instead do a real quit after garbage collection ends\r\n");
10997 printf ("\r\nAbort? (y or n) ");
10998 #else /* not MSDOS */
10999 printf ("Abort (and dump core)? (y or n) ");
11000 #endif /* not MSDOS */
11002 if (((c
= getchar ()) & ~040) == 'Y')
11004 while (c
!= '\n') c
= getchar ();
11006 printf ("\r\nContinuing...\r\n");
11007 #else /* not MSDOS */
11008 printf ("Continuing...\n");
11009 #endif /* not MSDOS */
11011 init_all_sys_modes ();
11016 /* If executing a function that wants to be interrupted out of
11017 and the user has not deferred quitting by binding `inhibit-quit'
11018 then quit right away. */
11019 if (immediate_quit
&& NILP (Vinhibit_quit
))
11021 struct gl_state_s saved
;
11022 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
11024 immediate_quit
= 0;
11027 GCPRO4 (saved
.object
, saved
.global_code
,
11028 saved
.current_syntax_table
, saved
.old_prop
);
11029 Fsignal (Qquit
, Qnil
);
11030 /* FIXME: AFAIK, `quit' can never return, so this code is dead! */
11035 /* Else request quit when it's safe */
11039 /* TODO: The longjmp in this call throws the NS event loop integration off,
11040 and it seems to do fine without this. Probably some attention
11041 needs to be paid to the setting of waiting_for_input in
11042 wait_reading_process_output() under HAVE_NS because of the call
11043 to ns_select there (needed because otherwise events aren't picked up
11044 outside of polling since we don't get SIGIO like X and we don't have a
11045 separate event loop thread like W32. */
11047 if (waiting_for_input
&& !echoing
)
11048 quit_throw_to_read_char ();
11052 /* Handle a C-g by making read_char return C-g. */
11055 quit_throw_to_read_char (void)
11058 /* Prevent another signal from doing this before we finish. */
11059 clear_waiting_for_input ();
11062 Vunread_command_events
= Qnil
;
11063 unread_command_char
= -1;
11065 #if 0 /* Currently, sit_for is called from read_char without turning
11066 off polling. And that can call set_waiting_for_input.
11067 It seems to be harmless. */
11068 #ifdef POLL_FOR_INPUT
11069 /* May be > 1 if in recursive minibuffer. */
11070 if (poll_suppress_count
== 0)
11074 if (FRAMEP (internal_last_event_frame
)
11075 && !EQ (internal_last_event_frame
, selected_frame
))
11076 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
11079 _longjmp (getcjmp
, 1);
11082 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
, Sset_input_interrupt_mode
, 1, 1, 0,
11083 doc
: /* Set interrupt mode of reading keyboard input.
11084 If INTERRUPT is non-nil, Emacs will use input interrupts;
11085 otherwise Emacs uses CBREAK mode.
11087 See also `current-input-mode'. */)
11088 (Lisp_Object interrupt
)
11090 int new_interrupt_input
;
11092 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11093 #ifdef HAVE_X_WINDOWS
11094 if (x_display_list
!= NULL
)
11096 /* When using X, don't give the user a real choice,
11097 because we haven't implemented the mechanisms to support it. */
11098 new_interrupt_input
= 1;
11101 #endif /* HAVE_X_WINDOWS */
11102 new_interrupt_input
= !NILP (interrupt
);
11103 #else /* not SIGIO */
11104 new_interrupt_input
= 0;
11105 #endif /* not SIGIO */
11107 if (new_interrupt_input
!= interrupt_input
)
11109 #ifdef POLL_FOR_INPUT
11113 /* this causes startup screen to be restored and messes with the mouse */
11114 reset_all_sys_modes ();
11116 interrupt_input
= new_interrupt_input
;
11118 init_all_sys_modes ();
11121 #ifdef POLL_FOR_INPUT
11122 poll_suppress_count
= 1;
11129 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
11130 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
11131 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
11132 C-q in key sequences.
11134 This setting only has an effect on tty terminals and only when
11135 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
11137 See also `current-input-mode'. */)
11138 (Lisp_Object flow
, Lisp_Object terminal
)
11140 struct terminal
*t
= get_terminal (terminal
, 1);
11141 struct tty_display_info
*tty
;
11142 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11144 tty
= t
->display_info
.tty
;
11146 if (tty
->flow_control
!= !NILP (flow
))
11149 /* this causes startup screen to be restored and messes with the mouse */
11150 reset_sys_modes (tty
);
11153 tty
->flow_control
= !NILP (flow
);
11156 init_sys_modes (tty
);
11162 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11163 doc
: /* Enable or disable 8-bit input on TERMINAL.
11164 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11165 bit as the Meta modifier.
11167 If META is nil, Emacs will ignore the top bit, on the assumption it is
11170 Otherwise, Emacs will accept and pass through 8-bit input without
11171 specially interpreting the top bit.
11173 This setting only has an effect on tty terminal devices.
11175 Optional parameter TERMINAL specifies the tty terminal device to use.
11176 It may be a terminal object, a frame, or nil for the terminal used by
11177 the currently selected frame.
11179 See also `current-input-mode'. */)
11180 (Lisp_Object meta
, Lisp_Object terminal
)
11182 struct terminal
*t
= get_terminal (terminal
, 1);
11183 struct tty_display_info
*tty
;
11186 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11188 tty
= t
->display_info
.tty
;
11192 else if (EQ (meta
, Qt
))
11197 if (tty
->meta_key
!= new_meta
)
11200 /* this causes startup screen to be restored and messes with the mouse */
11201 reset_sys_modes (tty
);
11204 tty
->meta_key
= new_meta
;
11207 init_sys_modes (tty
);
11213 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11214 doc
: /* Specify character used for quitting.
11215 QUIT must be an ASCII character.
11217 This function only has an effect on the controlling tty of the Emacs
11220 See also `current-input-mode'. */)
11223 struct terminal
*t
= get_named_tty ("/dev/tty");
11224 struct tty_display_info
*tty
;
11225 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11227 tty
= t
->display_info
.tty
;
11229 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11230 error ("QUIT must be an ASCII character");
11233 /* this causes startup screen to be restored and messes with the mouse */
11234 reset_sys_modes (tty
);
11237 /* Don't let this value be out of range. */
11238 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11241 init_sys_modes (tty
);
11247 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11248 doc
: /* Set mode of reading keyboard input.
11249 First arg INTERRUPT non-nil means use input interrupts;
11250 nil means use CBREAK mode.
11251 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11252 (no effect except in CBREAK mode).
11253 Third arg META t means accept 8-bit input (for a Meta key).
11254 META nil means ignore the top bit, on the assumption it is parity.
11255 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11256 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11257 See also `current-input-mode'. */)
11258 (Lisp_Object interrupt
, Lisp_Object flow
, Lisp_Object meta
, Lisp_Object quit
)
11260 Fset_input_interrupt_mode (interrupt
);
11261 Fset_output_flow_control (flow
, Qnil
);
11262 Fset_input_meta_mode (meta
, Qnil
);
11264 Fset_quit_char (quit
);
11268 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11269 doc
: /* Return information about the way Emacs currently reads keyboard input.
11270 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11271 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11272 nil, Emacs is using CBREAK mode.
11273 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11274 terminal; this does not apply if Emacs uses interrupt-driven input.
11275 META is t if accepting 8-bit input with 8th bit as Meta flag.
11276 META nil means ignoring the top bit, on the assumption it is parity.
11277 META is neither t nor nil if accepting 8-bit input and using
11278 all 8 bits as the character code.
11279 QUIT is the character Emacs currently uses to quit.
11280 The elements of this list correspond to the arguments of
11281 `set-input-mode'. */)
11284 Lisp_Object val
[4];
11285 struct frame
*sf
= XFRAME (selected_frame
);
11287 val
[0] = interrupt_input
? Qt
: Qnil
;
11288 if (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
11290 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11291 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11293 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11300 XSETFASTINT (val
[3], quit_char
);
11302 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11305 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11306 doc
: /* Return position information for pixel coordinates X and Y.
11307 By default, X and Y are relative to text area of the selected window.
11308 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11309 If optional fourth arg WHOLE is non-nil, X is relative to the left
11310 edge of the window.
11312 The return value is similar to a mouse click position:
11313 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11314 IMAGE (DX . DY) (WIDTH . HEIGHT))
11315 The `posn-' functions access elements of such lists. */)
11316 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame_or_window
, Lisp_Object whole
)
11321 if (NILP (frame_or_window
))
11322 frame_or_window
= selected_window
;
11324 if (WINDOWP (frame_or_window
))
11328 CHECK_LIVE_WINDOW (frame_or_window
);
11330 w
= XWINDOW (frame_or_window
);
11331 XSETINT (x
, (XINT (x
)
11332 + WINDOW_LEFT_EDGE_X (w
)
11334 ? window_box_left_offset (w
, TEXT_AREA
)
11336 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11337 frame_or_window
= w
->frame
;
11340 CHECK_LIVE_FRAME (frame_or_window
);
11342 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
11345 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11346 doc
: /* Return position information for buffer POS in WINDOW.
11347 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11349 Return nil if position is not visible in window. Otherwise,
11350 the return value is similar to that returned by `event-start' for
11351 a mouse click at the upper left corner of the glyph corresponding
11352 to the given buffer position:
11353 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11354 IMAGE (DX . DY) (WIDTH . HEIGHT))
11355 The `posn-' functions access elements of such lists. */)
11356 (Lisp_Object pos
, Lisp_Object window
)
11361 window
= selected_window
;
11363 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11366 Lisp_Object x
= XCAR (tem
);
11367 Lisp_Object y
= XCAR (XCDR (tem
));
11369 /* Point invisible due to hscrolling? */
11372 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11380 * Set up a new kboard object with reasonable initial values.
11383 init_kboard (KBOARD
*kb
)
11385 kb
->Voverriding_terminal_local_map
= Qnil
;
11386 kb
->Vlast_command
= Qnil
;
11387 kb
->Vreal_last_command
= Qnil
;
11388 kb
->Vkeyboard_translate_table
= Qnil
;
11389 kb
->Vlast_repeatable_command
= Qnil
;
11390 kb
->Vprefix_arg
= Qnil
;
11391 kb
->Vlast_prefix_arg
= Qnil
;
11392 kb
->kbd_queue
= Qnil
;
11393 kb
->kbd_queue_has_data
= 0;
11394 kb
->immediate_echo
= 0;
11395 kb
->echo_string
= Qnil
;
11396 kb
->echo_after_prompt
= -1;
11397 kb
->kbd_macro_buffer
= 0;
11398 kb
->kbd_macro_bufsize
= 0;
11399 kb
->defining_kbd_macro
= Qnil
;
11400 kb
->Vlast_kbd_macro
= Qnil
;
11401 kb
->reference_count
= 0;
11402 kb
->Vsystem_key_alist
= Qnil
;
11403 kb
->system_key_syms
= Qnil
;
11404 kb
->Vwindow_system
= Qt
; /* Unset. */
11405 kb
->Vinput_decode_map
= Fmake_sparse_keymap (Qnil
);
11406 kb
->Vlocal_function_key_map
= Fmake_sparse_keymap (Qnil
);
11407 Fset_keymap_parent (kb
->Vlocal_function_key_map
, Vfunction_key_map
);
11408 kb
->Vdefault_minibuffer_frame
= Qnil
;
11412 * Destroy the contents of a kboard object, but not the object itself.
11413 * We use this just before deleting it, or if we're going to initialize
11414 * it a second time.
11417 wipe_kboard (KBOARD
*kb
)
11419 xfree (kb
->kbd_macro_buffer
);
11422 /* Free KB and memory referenced from it. */
11425 delete_kboard (KBOARD
*kb
)
11429 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11432 *kbp
= kb
->next_kboard
;
11434 /* Prevent a dangling reference to KB. */
11435 if (kb
== current_kboard
11436 && FRAMEP (selected_frame
)
11437 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11439 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11441 if (current_kboard
== kb
)
11450 init_keyboard (void)
11452 /* This is correct before outermost invocation of the editor loop */
11453 command_loop_level
= -1;
11454 immediate_quit
= 0;
11455 quit_char
= Ctl ('g');
11456 Vunread_command_events
= Qnil
;
11457 unread_command_char
= -1;
11458 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11460 recent_keys_index
= 0;
11461 kbd_fetch_ptr
= kbd_buffer
;
11462 kbd_store_ptr
= kbd_buffer
;
11463 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11464 do_mouse_tracking
= Qnil
;
11467 interrupt_input_blocked
= 0;
11468 interrupt_input_pending
= 0;
11470 pending_signals
= 0;
11473 /* This means that command_loop_1 won't try to select anything the first
11475 internal_last_event_frame
= Qnil
;
11476 Vlast_event_frame
= internal_last_event_frame
;
11478 current_kboard
= initial_kboard
;
11479 /* Re-initialize the keyboard again. */
11480 wipe_kboard (current_kboard
);
11481 init_kboard (current_kboard
);
11482 /* A value of nil for Vwindow_system normally means a tty, but we also use
11483 it for the initial terminal since there is no window system there. */
11484 current_kboard
->Vwindow_system
= Qnil
;
11486 if (!noninteractive
)
11488 /* Before multi-tty support, these handlers used to be installed
11489 only if the current session was a tty session. Now an Emacs
11490 session may have multiple display types, so we always handle
11491 SIGINT. There is special code in interrupt_signal to exit
11492 Emacs on SIGINT when there are no termcap frames on the
11493 controlling terminal. */
11494 signal (SIGINT
, interrupt_signal
);
11496 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11497 SIGQUIT and we can't tell which one it will give us. */
11498 signal (SIGQUIT
, interrupt_signal
);
11499 #endif /* not DOS_NT */
11501 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11503 if (!noninteractive
)
11504 signal (SIGIO
, input_available_signal
);
11507 /* Use interrupt input by default, if it works and noninterrupt input
11508 has deficiencies. */
11510 #ifdef INTERRUPT_INPUT
11511 interrupt_input
= 1;
11513 interrupt_input
= 0;
11519 if (keyboard_init_hook
)
11520 (*keyboard_init_hook
) ();
11522 #ifdef POLL_FOR_INPUT
11524 poll_suppress_count
= 1;
11529 /* This type's only use is in syms_of_keyboard, to initialize the
11530 event header symbols and put properties on them. */
11531 struct event_head
{
11537 static const struct event_head head_table
[] = {
11538 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11539 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11540 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11541 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11542 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11543 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11544 /* `select-window' should be handled just like `switch-frame'
11545 in read_key_sequence. */
11546 {&Qselect_window
, "select-window", &Qswitch_frame
}
11550 syms_of_keyboard (void)
11552 pending_funcalls
= Qnil
;
11553 staticpro (&pending_funcalls
);
11555 Vlispy_mouse_stem
= make_pure_c_string ("mouse");
11556 staticpro (&Vlispy_mouse_stem
);
11559 QCimage
= intern_c_string (":image");
11560 staticpro (&QCimage
);
11562 staticpro (&Qhelp_echo
);
11563 Qhelp_echo
= intern_c_string ("help-echo");
11566 Qrtl
= intern_c_string (":rtl");
11568 staticpro (&item_properties
);
11569 item_properties
= Qnil
;
11571 staticpro (&tool_bar_item_properties
);
11572 tool_bar_item_properties
= Qnil
;
11573 staticpro (&tool_bar_items_vector
);
11574 tool_bar_items_vector
= Qnil
;
11576 staticpro (&real_this_command
);
11577 real_this_command
= Qnil
;
11579 Qtimer_event_handler
= intern_c_string ("timer-event-handler");
11580 staticpro (&Qtimer_event_handler
);
11582 Qdisabled_command_function
= intern_c_string ("disabled-command-function");
11583 staticpro (&Qdisabled_command_function
);
11585 Qself_insert_command
= intern_c_string ("self-insert-command");
11586 staticpro (&Qself_insert_command
);
11588 Qforward_char
= intern_c_string ("forward-char");
11589 staticpro (&Qforward_char
);
11591 Qbackward_char
= intern_c_string ("backward-char");
11592 staticpro (&Qbackward_char
);
11594 Qdisabled
= intern_c_string ("disabled");
11595 staticpro (&Qdisabled
);
11597 Qundefined
= intern_c_string ("undefined");
11598 staticpro (&Qundefined
);
11600 Qpre_command_hook
= intern_c_string ("pre-command-hook");
11601 staticpro (&Qpre_command_hook
);
11603 Qpost_command_hook
= intern_c_string ("post-command-hook");
11604 staticpro (&Qpost_command_hook
);
11606 Qdeferred_action_function
= intern_c_string ("deferred-action-function");
11607 staticpro (&Qdeferred_action_function
);
11609 Qcommand_hook_internal
= intern_c_string ("command-hook-internal");
11610 staticpro (&Qcommand_hook_internal
);
11612 Qfunction_key
= intern_c_string ("function-key");
11613 staticpro (&Qfunction_key
);
11614 Qmouse_click
= intern_c_string ("mouse-click");
11615 staticpro (&Qmouse_click
);
11616 #if defined (WINDOWSNT)
11617 Qlanguage_change
= intern_c_string ("language-change");
11618 staticpro (&Qlanguage_change
);
11620 Qdrag_n_drop
= intern_c_string ("drag-n-drop");
11621 staticpro (&Qdrag_n_drop
);
11623 Qsave_session
= intern_c_string ("save-session");
11624 staticpro (&Qsave_session
);
11627 Qdbus_event
= intern_c_string ("dbus-event");
11628 staticpro (&Qdbus_event
);
11631 Qxwidget_event
= intern ("xwidget-event");
11632 staticpro (&Qxwidget_event
);
11635 Qmenu_enable
= intern ("menu-enable");
11636 Qconfig_changed_event
= intern_c_string ("config-changed-event");
11637 staticpro (&Qconfig_changed_event
);
11639 Qmenu_enable
= intern_c_string ("menu-enable");
11640 staticpro (&Qmenu_enable
);
11641 QCenable
= intern_c_string (":enable");
11642 staticpro (&QCenable
);
11643 QCvisible
= intern_c_string (":visible");
11644 staticpro (&QCvisible
);
11645 QChelp
= intern_c_string (":help");
11646 staticpro (&QChelp
);
11647 QCfilter
= intern_c_string (":filter");
11648 staticpro (&QCfilter
);
11649 QCbutton
= intern_c_string (":button");
11650 staticpro (&QCbutton
);
11651 QCkeys
= intern_c_string (":keys");
11652 staticpro (&QCkeys
);
11653 QCkey_sequence
= intern_c_string (":key-sequence");
11654 staticpro (&QCkey_sequence
);
11655 QCtoggle
= intern_c_string (":toggle");
11656 staticpro (&QCtoggle
);
11657 QCradio
= intern_c_string (":radio");
11658 staticpro (&QCradio
);
11659 QClabel
= intern_c_string (":label");
11660 staticpro (&QClabel
);
11662 Qmode_line
= intern_c_string ("mode-line");
11663 staticpro (&Qmode_line
);
11664 Qvertical_line
= intern_c_string ("vertical-line");
11665 staticpro (&Qvertical_line
);
11666 Qvertical_scroll_bar
= intern_c_string ("vertical-scroll-bar");
11667 staticpro (&Qvertical_scroll_bar
);
11668 Qmenu_bar
= intern_c_string ("menu-bar");
11669 staticpro (&Qmenu_bar
);
11671 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11672 Qmouse_fixup_help_message
= intern_c_string ("mouse-fixup-help-message");
11673 staticpro (&Qmouse_fixup_help_message
);
11676 Qabove_handle
= intern_c_string ("above-handle");
11677 staticpro (&Qabove_handle
);
11678 Qhandle
= intern_c_string ("handle");
11679 staticpro (&Qhandle
);
11680 Qbelow_handle
= intern_c_string ("below-handle");
11681 staticpro (&Qbelow_handle
);
11682 Qup
= intern_c_string ("up");
11684 Qdown
= intern_c_string ("down");
11685 staticpro (&Qdown
);
11686 Qtop
= intern_c_string ("top");
11688 Qbottom
= intern_c_string ("bottom");
11689 staticpro (&Qbottom
);
11690 Qend_scroll
= intern_c_string ("end-scroll");
11691 staticpro (&Qend_scroll
);
11692 Qratio
= intern_c_string ("ratio");
11693 staticpro (&Qratio
);
11695 Qevent_kind
= intern_c_string ("event-kind");
11696 staticpro (&Qevent_kind
);
11697 Qevent_symbol_elements
= intern_c_string ("event-symbol-elements");
11698 staticpro (&Qevent_symbol_elements
);
11699 Qevent_symbol_element_mask
= intern_c_string ("event-symbol-element-mask");
11700 staticpro (&Qevent_symbol_element_mask
);
11701 Qmodifier_cache
= intern_c_string ("modifier-cache");
11702 staticpro (&Qmodifier_cache
);
11704 Qrecompute_lucid_menubar
= intern_c_string ("recompute-lucid-menubar");
11705 staticpro (&Qrecompute_lucid_menubar
);
11706 Qactivate_menubar_hook
= intern_c_string ("activate-menubar-hook");
11707 staticpro (&Qactivate_menubar_hook
);
11709 Qpolling_period
= intern_c_string ("polling-period");
11710 staticpro (&Qpolling_period
);
11712 Qinput_method_function
= intern_c_string ("input-method-function");
11713 staticpro (&Qinput_method_function
);
11715 Qx_set_selection
= intern_c_string ("x-set-selection");
11716 staticpro (&Qx_set_selection
);
11717 QPRIMARY
= intern_c_string ("PRIMARY");
11718 staticpro (&QPRIMARY
);
11719 Qhandle_switch_frame
= intern_c_string ("handle-switch-frame");
11720 staticpro (&Qhandle_switch_frame
);
11722 Qinput_method_exit_on_first_char
= intern_c_string ("input-method-exit-on-first-char");
11723 staticpro (&Qinput_method_exit_on_first_char
);
11724 Qinput_method_use_echo_area
= intern_c_string ("input-method-use-echo-area");
11725 staticpro (&Qinput_method_use_echo_area
);
11727 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11728 Fset (Qinput_method_use_echo_area
, Qnil
);
11730 last_point_position_buffer
= Qnil
;
11731 last_point_position_window
= Qnil
;
11734 const struct event_head
*p
;
11736 for (p
= head_table
;
11737 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
11740 *p
->var
= intern_c_string (p
->name
);
11741 staticpro (p
->var
);
11742 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11743 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11747 button_down_location
= Fmake_vector (make_number (5), Qnil
);
11748 staticpro (&button_down_location
);
11749 mouse_syms
= Fmake_vector (make_number (5), Qnil
);
11750 staticpro (&mouse_syms
);
11751 wheel_syms
= Fmake_vector (make_number (sizeof (lispy_wheel_names
)
11752 / sizeof (lispy_wheel_names
[0])),
11754 staticpro (&wheel_syms
);
11758 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11760 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11761 for (i
= 0; i
< len
; i
++)
11762 if (modifier_names
[i
])
11763 XVECTOR (modifier_symbols
)->contents
[i
] = intern_c_string (modifier_names
[i
]);
11764 staticpro (&modifier_symbols
);
11767 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11768 staticpro (&recent_keys
);
11770 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11771 staticpro (&this_command_keys
);
11773 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11774 staticpro (&raw_keybuf
);
11776 Qextended_command_history
= intern_c_string ("extended-command-history");
11777 Fset (Qextended_command_history
, Qnil
);
11778 staticpro (&Qextended_command_history
);
11780 accent_key_syms
= Qnil
;
11781 staticpro (&accent_key_syms
);
11783 func_key_syms
= Qnil
;
11784 staticpro (&func_key_syms
);
11786 drag_n_drop_syms
= Qnil
;
11787 staticpro (&drag_n_drop_syms
);
11789 unread_switch_frame
= Qnil
;
11790 staticpro (&unread_switch_frame
);
11792 internal_last_event_frame
= Qnil
;
11793 staticpro (&internal_last_event_frame
);
11795 read_key_sequence_cmd
= Qnil
;
11796 staticpro (&read_key_sequence_cmd
);
11798 menu_bar_one_keymap_changed_items
= Qnil
;
11799 staticpro (&menu_bar_one_keymap_changed_items
);
11801 menu_bar_items_vector
= Qnil
;
11802 staticpro (&menu_bar_items_vector
);
11804 help_form_saved_window_configs
= Qnil
;
11805 staticpro (&help_form_saved_window_configs
);
11807 defsubr (&Scurrent_idle_time
);
11808 defsubr (&Sevent_symbol_parse_modifiers
);
11809 defsubr (&Sevent_convert_list
);
11810 defsubr (&Sread_key_sequence
);
11811 defsubr (&Sread_key_sequence_vector
);
11812 defsubr (&Srecursive_edit
);
11813 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11814 defsubr (&Strack_mouse
);
11816 defsubr (&Sinput_pending_p
);
11817 defsubr (&Scommand_execute
);
11818 defsubr (&Srecent_keys
);
11819 defsubr (&Sthis_command_keys
);
11820 defsubr (&Sthis_command_keys_vector
);
11821 defsubr (&Sthis_single_command_keys
);
11822 defsubr (&Sthis_single_command_raw_keys
);
11823 defsubr (&Sreset_this_command_lengths
);
11824 defsubr (&Sclear_this_command_keys
);
11825 defsubr (&Ssuspend_emacs
);
11826 defsubr (&Sabort_recursive_edit
);
11827 defsubr (&Sexit_recursive_edit
);
11828 defsubr (&Srecursion_depth
);
11829 defsubr (&Stop_level
);
11830 defsubr (&Sdiscard_input
);
11831 defsubr (&Sopen_dribble_file
);
11832 defsubr (&Sset_input_interrupt_mode
);
11833 defsubr (&Sset_output_flow_control
);
11834 defsubr (&Sset_input_meta_mode
);
11835 defsubr (&Sset_quit_char
);
11836 defsubr (&Sset_input_mode
);
11837 defsubr (&Scurrent_input_mode
);
11838 defsubr (&Sexecute_extended_command
);
11839 defsubr (&Sposn_at_point
);
11840 defsubr (&Sposn_at_x_y
);
11842 DEFVAR_LISP ("last-command-event", &last_command_event
,
11843 doc
: /* Last input event that was part of a command. */);
11845 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11846 doc
: /* Last input event in a command, except for mouse menu events.
11847 Mouse menus give back keys that don't look like mouse events;
11848 this variable holds the actual mouse event that led to the menu,
11849 so that you can determine whether the command was run by mouse or not. */);
11851 DEFVAR_LISP ("last-input-event", &last_input_event
,
11852 doc
: /* Last input event. */);
11854 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11855 doc
: /* List of events to be read as the command input.
11856 These events are processed first, before actual keyboard input.
11857 Events read from this list are not normally added to `this-command-keys',
11858 as they will already have been added once as they were read for the first time.
11859 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11860 Vunread_command_events
= Qnil
;
11862 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11863 doc
: /* If not -1, an object to be read as next command input event. */);
11865 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11866 doc
: /* List of events to be processed as input by input methods.
11867 These events are processed before `unread-command-events'
11868 and actual keyboard input, but are not given to `input-method-function'. */);
11869 Vunread_post_input_method_events
= Qnil
;
11871 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
11872 doc
: /* List of events to be processed as input by input methods.
11873 These events are processed after `unread-command-events', but
11874 before actual keyboard input.
11875 If there's an active input method, the events are given to
11876 `input-method-function'. */);
11877 Vunread_input_method_events
= Qnil
;
11879 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
11880 doc
: /* Meta-prefix character code.
11881 Meta-foo as command input turns into this character followed by foo. */);
11882 XSETINT (meta_prefix_char
, 033);
11884 DEFVAR_KBOARD ("last-command", Vlast_command
,
11885 doc
: /* The last command executed.
11886 Normally a symbol with a function definition, but can be whatever was found
11887 in the keymap, or whatever the variable `this-command' was set to by that
11890 The value `mode-exit' is special; it means that the previous command
11891 read an event that told it to exit, and it did so and unread that event.
11892 In other words, the present command is the event that made the previous
11895 The value `kill-region' is special; it means that the previous command
11896 was a kill command.
11898 `last-command' has a separate binding for each terminal device.
11899 See Info node `(elisp)Multiple Terminals'. */);
11901 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11902 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11904 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command
,
11905 doc
: /* Last command that may be repeated.
11906 The last command executed that was not bound to an input event.
11907 This is the command `repeat' will try to repeat. */);
11909 DEFVAR_LISP ("this-command", &Vthis_command
,
11910 doc
: /* The command now being executed.
11911 The command can set this variable; whatever is put here
11912 will be in `last-command' during the following command. */);
11913 Vthis_command
= Qnil
;
11915 DEFVAR_LISP ("this-command-keys-shift-translated",
11916 &Vthis_command_keys_shift_translated
,
11917 doc
: /* Non-nil if the key sequence activating this command was shift-translated.
11918 Shift-translation occurs when there is no binding for the key sequence
11919 as entered, but a binding was found by changing an upper-case letter
11920 to lower-case, or a shifted function key to an unshifted one. */);
11921 Vthis_command_keys_shift_translated
= Qnil
;
11923 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
11924 doc
: /* The command bound to the current key sequence before remapping.
11925 It equals `this-command' if the original command was not remapped through
11926 any of the active keymaps. Otherwise, the value of `this-command' is the
11927 result of looking up the original command in the active keymaps. */);
11928 Vthis_original_command
= Qnil
;
11930 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
11931 doc
: /* *Number of input events between auto-saves.
11932 Zero means disable autosaving due to number of characters typed. */);
11933 auto_save_interval
= 300;
11935 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
11936 doc
: /* *Number of seconds idle time before auto-save.
11937 Zero or nil means disable auto-saving due to idleness.
11938 After auto-saving due to this many seconds of idle time,
11939 Emacs also does a garbage collection if that seems to be warranted. */);
11940 XSETFASTINT (Vauto_save_timeout
, 30);
11942 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11943 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11944 The value may be integer or floating point. */);
11945 Vecho_keystrokes
= make_number (1);
11947 DEFVAR_INT ("polling-period", &polling_period
,
11948 doc
: /* *Interval between polling for input during Lisp execution.
11949 The reason for polling is to make C-g work to stop a running program.
11950 Polling is needed only when using X windows and SIGIO does not work.
11951 Polling is automatically disabled in all other cases. */);
11952 polling_period
= 2;
11954 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
11955 doc
: /* *Maximum time between mouse clicks to make a double-click.
11956 Measured in milliseconds. The value nil means disable double-click
11957 recognition; t means double-clicks have no time limit and are detected
11958 by position only. */);
11959 Vdouble_click_time
= make_number (500);
11961 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
11962 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11963 On window-system frames, value is the number of pixels the mouse may have
11964 moved horizontally or vertically between two clicks to make a double-click.
11965 On non window-system frames, value is interpreted in units of 1/8 characters
11968 This variable is also the threshold for motion of the mouse
11969 to count as a drag. */);
11970 double_click_fuzz
= 3;
11972 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
11973 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11974 inhibit_local_menu_bar_menus
= 0;
11976 DEFVAR_INT ("num-input-keys", &num_input_keys
,
11977 doc
: /* Number of complete key sequences read as input so far.
11978 This includes key sequences read from keyboard macros.
11979 The number is effectively the number of interactive command invocations. */);
11980 num_input_keys
= 0;
11982 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
11983 doc
: /* Number of input events read from the keyboard so far.
11984 This does not include events generated by keyboard macros. */);
11985 num_nonmacro_input_events
= 0;
11987 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
11988 doc
: /* The frame in which the most recently read event occurred.
11989 If the last event came from a keyboard macro, this is set to `macro'. */);
11990 Vlast_event_frame
= Qnil
;
11992 /* This variable is set up in sysdep.c. */
11993 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
11994 doc
: /* The ERASE character as set by the user with stty. */);
11996 DEFVAR_LISP ("help-char", &Vhelp_char
,
11997 doc
: /* Character to recognize as meaning Help.
11998 When it is read, do `(eval help-form)', and display result if it's a string.
11999 If the value of `help-form' is nil, this char can be read normally. */);
12000 XSETINT (Vhelp_char
, Ctl ('H'));
12002 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
12003 doc
: /* List of input events to recognize as meaning Help.
12004 These work just like the value of `help-char' (see that). */);
12005 Vhelp_event_list
= Qnil
;
12007 DEFVAR_LISP ("help-form", &Vhelp_form
,
12008 doc
: /* Form to execute when character `help-char' is read.
12009 If the form returns a string, that string is displayed.
12010 If `help-form' is nil, the help char is not recognized. */);
12013 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
12014 doc
: /* Command to run when `help-char' character follows a prefix key.
12015 This command is used only when there is no actual binding
12016 for that character after that prefix key. */);
12017 Vprefix_help_command
= Qnil
;
12019 DEFVAR_LISP ("top-level", &Vtop_level
,
12020 doc
: /* Form to evaluate when Emacs starts up.
12021 Useful to set before you dump a modified Emacs. */);
12024 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
12025 doc
: /* Translate table for local keyboard input, or nil.
12026 If non-nil, the value should be a char-table. Each character read
12027 from the keyboard is looked up in this char-table. If the value found
12028 there is non-nil, then it is used instead of the actual input character.
12030 The value can also be a string or vector, but this is considered obsolete.
12031 If it is a string or vector of length N, character codes N and up are left
12032 untranslated. In a vector, an element which is nil means "no translation".
12034 This is applied to the characters supplied to input methods, not their
12035 output. See also `translation-table-for-input'.
12037 This variable has a separate binding for each terminal.
12038 See Info node `(elisp)Multiple Terminals'. */);
12040 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
12041 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
12042 \(Even if the operating system has support for stopping a process.\) */);
12043 cannot_suspend
= 0;
12045 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
12046 doc
: /* Non-nil means prompt with menus when appropriate.
12047 This is done when reading from a keymap that has a prompt string,
12048 for elements that have prompt strings.
12049 The menu is displayed on the screen
12050 if X menus were enabled at configuration
12051 time and the previous event was a mouse click prefix key.
12052 Otherwise, menu prompting uses the echo area. */);
12053 menu_prompting
= 1;
12055 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
12056 doc
: /* Character to see next line of menu prompt.
12057 Type this character while in a menu prompt to rotate around the lines of it. */);
12058 XSETINT (menu_prompt_more_char
, ' ');
12060 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
12061 doc
: /* A mask of additional modifier keys to use with every keyboard character.
12062 Emacs applies the modifiers of the character stored here to each keyboard
12063 character it reads. For example, after evaluating the expression
12064 (setq extra-keyboard-modifiers ?\\C-x)
12065 all input characters will have the control modifier applied to them.
12067 Note that the character ?\\C-@, equivalent to the integer zero, does
12068 not count as a control character; rather, it counts as a character
12069 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
12070 cancels any modification. */);
12071 extra_keyboard_modifiers
= 0;
12073 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
12074 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
12075 The command loop sets this to nil before each command,
12076 and tests the value when the command returns.
12077 Buffer modification stores t in this variable. */);
12078 Vdeactivate_mark
= Qnil
;
12079 Qdeactivate_mark
= intern_c_string ("deactivate-mark");
12080 staticpro (&Qdeactivate_mark
);
12082 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
12083 doc
: /* Temporary storage of `pre-command-hook' or `post-command-hook'. */);
12084 Vcommand_hook_internal
= Qnil
;
12086 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
12087 doc
: /* Normal hook run before each command is executed.
12088 If an unhandled error happens in running this hook,
12089 the hook value is set to nil, since otherwise the error
12090 might happen repeatedly and make Emacs nonfunctional. */);
12091 Vpre_command_hook
= Qnil
;
12093 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
12094 doc
: /* Normal hook run after each command is executed.
12095 If an unhandled error happens in running this hook,
12096 the hook value is set to nil, since otherwise the error
12097 might happen repeatedly and make Emacs nonfunctional. */);
12098 Vpost_command_hook
= Qnil
;
12101 DEFVAR_LISP ("echo-area-clear-hook", ...,
12102 doc
: /* Normal hook run when clearing the echo area. */);
12104 Qecho_area_clear_hook
= intern_c_string ("echo-area-clear-hook");
12105 staticpro (&Qecho_area_clear_hook
);
12106 Fset (Qecho_area_clear_hook
, Qnil
);
12108 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
12109 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
12110 Vlucid_menu_bar_dirty_flag
= Qnil
;
12112 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
12113 doc
: /* List of menu bar items to move to the end of the menu bar.
12114 The elements of the list are event types that may have menu bar bindings. */);
12115 Vmenu_bar_final_items
= Qnil
;
12117 DEFVAR_KBOARD ("overriding-terminal-local-map",
12118 Voverriding_terminal_local_map
,
12119 doc
: /* Per-terminal keymap that overrides all other local keymaps.
12120 If this variable is non-nil, it is used as a keymap instead of the
12121 buffer's local map, and the minor mode keymaps and text property keymaps.
12122 It also replaces `overriding-local-map'.
12124 This variable is intended to let commands such as `universal-argument'
12125 set up a different keymap for reading the next command.
12127 `overriding-terminal-local-map' has a separate binding for each
12129 See Info node `(elisp)Multiple Terminals'. */);
12131 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
12132 doc
: /* Keymap that overrides all other local keymaps.
12133 If this variable is non-nil, it is used as a keymap--replacing the
12134 buffer's local map, the minor mode keymaps, and char property keymaps. */);
12135 Voverriding_local_map
= Qnil
;
12137 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
12138 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
12139 Otherwise, the menu bar continues to reflect the buffer's local map
12140 and the minor mode maps regardless of `overriding-local-map'. */);
12141 Voverriding_local_map_menu_flag
= Qnil
;
12143 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
12144 doc
: /* Keymap defining bindings for special events to execute at low level. */);
12145 Vspecial_event_map
= Fcons (intern_c_string ("keymap"), Qnil
);
12147 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
12148 doc
: /* *Non-nil means generate motion events for mouse motion. */);
12150 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
12151 doc
: /* Alist of system-specific X windows key symbols.
12152 Each element should have the form (N . SYMBOL) where N is the
12153 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12154 and SYMBOL is its name.
12156 `system-key-alist' has a separate binding for each terminal device.
12157 See Info node `(elisp)Multiple Terminals'. */);
12159 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
12160 doc
: /* Keymap that translates key sequences to key sequences during input.
12161 This is used mainly for mapping key sequences into some preferred
12162 key events (symbols).
12164 The `read-key-sequence' function replaces any subsequence bound by
12165 `local-function-key-map' with its binding. More precisely, when the
12166 active keymaps have no binding for the current key sequence but
12167 `local-function-key-map' binds a suffix of the sequence to a vector or
12168 string, `read-key-sequence' replaces the matching suffix with its
12169 binding, and continues with the new sequence.
12171 If the binding is a function, it is called with one argument (the prompt)
12172 and its return value (a key sequence) is used.
12174 The events that come from bindings in `local-function-key-map' are not
12175 themselves looked up in `local-function-key-map'.
12177 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12178 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12179 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12180 typing `ESC O P x' would return [f1 x].
12182 `local-function-key-map' has a separate binding for each terminal
12183 device. See Info node `(elisp)Multiple Terminals'. If you need to
12184 define a binding on all terminals, change `function-key-map'
12185 instead. Initially, `local-function-key-map' is an empty keymap that
12186 has `function-key-map' as its parent on all terminal devices. */);
12188 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map
,
12189 doc
: /* Keymap that decodes input escape sequences.
12190 This is used mainly for mapping ASCII function key sequences into
12191 real Emacs function key events (symbols).
12193 The `read-key-sequence' function replaces any subsequence bound by
12194 `input-decode-map' with its binding. Contrary to `function-key-map',
12195 this map applies its rebinding regardless of the presence of an ordinary
12196 binding. So it is more like `key-translation-map' except that it applies
12197 before `function-key-map' rather than after.
12199 If the binding is a function, it is called with one argument (the prompt)
12200 and its return value (a key sequence) is used.
12202 The events that come from bindings in `input-decode-map' are not
12203 themselves looked up in `input-decode-map'.
12205 This variable is keyboard-local. */);
12207 DEFVAR_LISP ("function-key-map", &Vfunction_key_map
,
12208 doc
: /* The parent keymap of all `local-function-key-map' instances.
12209 Function key definitions that apply to all terminal devices should go
12210 here. If a mapping is defined in both the current
12211 `local-function-key-map' binding and this variable, then the local
12212 definition will take precendence. */);
12213 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12215 DEFVAR_LISP ("key-translation-map", &Vkey_translation_map
,
12216 doc
: /* Keymap of key translations that can override keymaps.
12217 This keymap works like `function-key-map', but comes after that,
12218 and its non-prefix bindings override ordinary bindings.
12219 Another difference is that it is global rather than keyboard-local. */);
12220 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12222 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
12223 doc
: /* List of deferred actions to be performed at a later time.
12224 The precise format isn't relevant here; we just check whether it is nil. */);
12225 Vdeferred_action_list
= Qnil
;
12227 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
12228 doc
: /* Function to call to handle deferred actions, after each command.
12229 This function is called with no arguments after each command
12230 whenever `deferred-action-list' is non-nil. */);
12231 Vdeferred_action_function
= Qnil
;
12233 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
12234 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12235 The value can be a length of time to show the message for.
12236 If the value is non-nil and not a number, we wait 2 seconds. */);
12237 Vsuggest_key_bindings
= Qt
;
12239 DEFVAR_LISP ("timer-list", &Vtimer_list
,
12240 doc
: /* List of active absolute time timers in order of increasing time. */);
12241 Vtimer_list
= Qnil
;
12243 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
12244 doc
: /* List of active idle-time timers in order of increasing time. */);
12245 Vtimer_idle_list
= Qnil
;
12247 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
12248 doc
: /* If non-nil, the function that implements the current input method.
12249 It's called with one argument, a printing character that was just read.
12250 \(That means a character with code 040...0176.)
12251 Typically this function uses `read-event' to read additional events.
12252 When it does so, it should first bind `input-method-function' to nil
12253 so it will not be called recursively.
12255 The function should return a list of zero or more events
12256 to be used as input. If it wants to put back some events
12257 to be reconsidered, separately, by the input method,
12258 it can add them to the beginning of `unread-command-events'.
12260 The input method function can find in `input-method-previous-message'
12261 the previous echo area message.
12263 The input method function should refer to the variables
12264 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12265 for guidance on what to do. */);
12266 Vinput_method_function
= Qnil
;
12268 DEFVAR_LISP ("input-method-previous-message",
12269 &Vinput_method_previous_message
,
12270 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12271 This variable exists because `read-event' clears the echo area
12272 before running the input method. It is nil if there was no message. */);
12273 Vinput_method_previous_message
= Qnil
;
12275 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
12276 doc
: /* If non-nil, the function that implements the display of help.
12277 It's called with one argument, the help string to display. */);
12278 Vshow_help_function
= Qnil
;
12280 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
12281 doc
: /* If non-nil, suppress point adjustment after executing a command.
12283 After a command is executed, if point is moved into a region that has
12284 special properties (e.g. composition, display), we adjust point to
12285 the boundary of the region. But, when a command sets this variable to
12286 non-nil, we suppress the point adjustment.
12288 This variable is set to nil before reading a command, and is checked
12289 just after executing the command. */);
12290 Vdisable_point_adjustment
= Qnil
;
12292 DEFVAR_LISP ("global-disable-point-adjustment",
12293 &Vglobal_disable_point_adjustment
,
12294 doc
: /* *If non-nil, always suppress point adjustment.
12296 The default value is nil, in which case, point adjustment are
12297 suppressed only after special commands that set
12298 `disable-point-adjustment' (which see) to non-nil. */);
12299 Vglobal_disable_point_adjustment
= Qnil
;
12301 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
12302 doc
: /* *How long to display an echo-area message when the minibuffer is active.
12303 If the value is not a number, such messages don't time out. */);
12304 Vminibuffer_message_timeout
= make_number (2);
12306 DEFVAR_LISP ("throw-on-input", &Vthrow_on_input
,
12307 doc
: /* If non-nil, any keyboard input throws to this symbol.
12308 The value of that variable is passed to `quit-flag' and later causes a
12309 peculiar kind of quitting. */);
12310 Vthrow_on_input
= Qnil
;
12312 DEFVAR_LISP ("command-error-function", &Vcommand_error_function
,
12313 doc
: /* If non-nil, function to output error messages.
12314 The arguments are the error data, a list of the form
12315 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12316 such as just as `condition-case' would bind its variable to,
12317 the context (a string which normally goes at the start of the message),
12318 and the Lisp function within which the error was signaled. */);
12319 Vcommand_error_function
= Qnil
;
12321 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12322 &Venable_disabled_menus_and_buttons
,
12323 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12325 Help functions bind this to allow help on disabled menu items
12326 and tool-bar buttons. */);
12327 Venable_disabled_menus_and_buttons
= Qnil
;
12329 DEFVAR_LISP ("select-active-regions",
12330 &Vselect_active_regions
,
12331 doc
: /* If non-nil, an active region automatically becomes the window selection.
12332 If the value is `only', only temporarily active regions (usually made
12333 by mouse-dragging or shift-selection) set the window selection.
12335 This takes effect only when Transient Mark mode is enabled. */);
12336 Vselect_active_regions
= Qt
;
12338 DEFVAR_LISP ("saved-region-selection",
12339 &Vsaved_region_selection
,
12340 doc
: /* Contents of active region prior to buffer modification.
12341 If `select-active-regions' is non-nil, Emacs sets this to the
12342 text in the region before modifying the buffer. The next
12343 `deactivate-mark' call uses this to set the window selection. */);
12344 Vsaved_region_selection
= Qnil
;
12346 /* Create the initial keyboard. */
12347 initial_kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12348 init_kboard (initial_kboard
);
12349 /* Vwindow_system is left at t for now. */
12350 initial_kboard
->next_kboard
= all_kboards
;
12351 all_kboards
= initial_kboard
;
12355 keys_of_keyboard (void)
12357 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12358 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12359 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12360 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12361 initial_define_key (meta_map
, 'x', "execute-extended-command");
12363 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12364 "handle-delete-frame");
12365 initial_define_lispy_key (Vspecial_event_map
, "ns-put-working-text",
12366 "ns-put-working-text");
12367 initial_define_lispy_key (Vspecial_event_map
, "ns-unput-working-text",
12368 "ns-unput-working-text");
12369 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12370 current-prefix-arg, as is done in `handle-switch-frame'.
12371 But `handle-switch-frame is not run from the special-map.
12372 Commands from that map are run in a special way that automatically
12373 preserves the prefix-arg. Restoring the prefix arg here is not just
12374 redundant but harmful:
12376 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12377 - after the first prompt, the exit-minibuffer-hook is run which may
12378 iconify a frame and thus push a `iconify-frame' event.
12379 - after running exit-minibuffer-hook, current-prefix-arg is
12380 restored to the non-nil value it had before the prompt.
12381 - we enter the second prompt.
12382 current-prefix-arg is non-nil, prefix-arg is nil.
12383 - before running the first real event, we run the special iconify-frame
12384 event, but we pass the `special' arg to execute-command so
12385 current-prefix-arg and prefix-arg are left untouched.
12386 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12387 - the next key event will have a spuriously non-nil current-prefix-arg. */
12388 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12390 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12392 /* Handling it at such a low-level causes read_key_sequence to get
12393 * confused because it doesn't realize that the current_buffer was
12394 * changed by read_char.
12396 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12397 * "handle-select-window"); */
12398 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12399 "handle-save-session");
12402 /* Define a special event which is raised for dbus callback
12404 initial_define_lispy_key (Vspecial_event_map
, "dbus-event",
12405 "dbus-handle-event");
12408 initial_define_lispy_key (Vspecial_event_map
, "config-changed-event",
12412 /* Mark the pointers in the kboard objects.
12413 Called by the Fgarbage_collector. */
12415 mark_kboards (void)
12419 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12421 if (kb
->kbd_macro_buffer
)
12422 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12424 mark_object (kb
->Voverriding_terminal_local_map
);
12425 mark_object (kb
->Vlast_command
);
12426 mark_object (kb
->Vreal_last_command
);
12427 mark_object (kb
->Vkeyboard_translate_table
);
12428 mark_object (kb
->Vlast_repeatable_command
);
12429 mark_object (kb
->Vprefix_arg
);
12430 mark_object (kb
->Vlast_prefix_arg
);
12431 mark_object (kb
->kbd_queue
);
12432 mark_object (kb
->defining_kbd_macro
);
12433 mark_object (kb
->Vlast_kbd_macro
);
12434 mark_object (kb
->Vsystem_key_alist
);
12435 mark_object (kb
->system_key_syms
);
12436 mark_object (kb
->Vwindow_system
);
12437 mark_object (kb
->Vinput_decode_map
);
12438 mark_object (kb
->Vlocal_function_key_map
);
12439 mark_object (kb
->Vdefault_minibuffer_frame
);
12440 mark_object (kb
->echo_string
);
12443 struct input_event
*event
;
12444 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12446 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12447 event
= kbd_buffer
;
12448 if (event
->kind
!= SELECTION_REQUEST_EVENT
12449 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12451 mark_object (event
->x
);
12452 mark_object (event
->y
);
12454 mark_object (event
->frame_or_window
);
12455 mark_object (event
->arg
);
12460 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
12461 (do not change this comment) */