1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99,2000,01,02,03,04
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "termhooks.h"
35 #include "character.h"
37 #include "dispextern.h"
39 #include "intervals.h"
41 #include "blockinput.h"
53 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
60 #include <sys/types.h>
65 /* This is to get the definitions of the XK_ symbols. */
72 #endif /* HAVE_NTGUI */
82 /* Variables for blockinput.h: */
84 /* Non-zero if interrupt input is blocked right now. */
85 int interrupt_input_blocked
;
87 /* Nonzero means an input interrupt has arrived
88 during the current critical section. */
89 int interrupt_input_pending
;
92 /* File descriptor to use for input. */
95 #ifdef HAVE_WINDOW_SYSTEM
96 /* Make all keyboard buffers much bigger when using X windows. */
98 /* But not too big (local data > 32K error) if on Mac OS Classic. */
99 #define KBD_BUFFER_SIZE 512
101 #define KBD_BUFFER_SIZE 4096
103 #else /* No X-windows, character input */
104 #define KBD_BUFFER_SIZE 4096
105 #endif /* No X-windows */
107 #define abs(x) ((x) >= 0 ? (x) : -(x))
109 /* Following definition copied from eval.c */
113 struct backtrace
*next
;
114 Lisp_Object
*function
;
115 Lisp_Object
*args
; /* Points to vector of args. */
116 int nargs
; /* length of vector. If nargs is UNEVALLED,
117 args points to slot holding list of
120 /* Nonzero means call value of debugger when done with this operation. */
125 KBOARD
*initial_kboard
;
126 KBOARD
*current_kboard
;
130 KBOARD the_only_kboard
;
133 /* Non-nil disable property on a command means
134 do not execute it; call disabled-command-hook's value instead. */
135 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
137 #define NUM_RECENT_KEYS (100)
138 int recent_keys_index
; /* Index for storing next element into recent_keys */
139 int total_keys
; /* Total number of elements stored into recent_keys */
140 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
142 /* Vector holding the key sequence that invoked the current command.
143 It is reused for each command, and it may be longer than the current
144 sequence; this_command_key_count indicates how many elements
145 actually mean something.
146 It's easier to staticpro a single Lisp_Object than an array. */
147 Lisp_Object this_command_keys
;
148 int this_command_key_count
;
150 /* 1 after calling Freset_this_command_lengths.
152 int this_command_key_count_reset
;
154 /* This vector is used as a buffer to record the events that were actually read
155 by read_key_sequence. */
156 Lisp_Object raw_keybuf
;
157 int raw_keybuf_count
;
159 #define GROW_RAW_KEYBUF \
160 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
162 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
164 new = Fmake_vector (make_number (newsize), Qnil); \
165 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
166 raw_keybuf_count * sizeof (Lisp_Object)); \
170 /* Number of elements of this_command_keys
171 that precede this key sequence. */
172 int this_single_command_key_start
;
174 /* Record values of this_command_key_count and echo_length ()
175 before this command was read. */
176 static int before_command_key_count
;
177 static int before_command_echo_length
;
179 extern int minbuf_level
;
181 extern int message_enable_multibyte
;
183 extern struct backtrace
*backtrace_list
;
185 /* If non-nil, the function that implements the display of help.
186 It's called with one argument, the help string to display. */
188 Lisp_Object Vshow_help_function
;
190 /* If a string, the message displayed before displaying a help-echo
193 Lisp_Object Vpre_help_message
;
195 /* Nonzero means do menu prompting. */
197 static int menu_prompting
;
199 /* Character to see next line of menu prompt. */
201 static Lisp_Object menu_prompt_more_char
;
203 /* For longjmp to where kbd input is being done. */
205 static jmp_buf getcjmp
;
207 /* True while doing kbd input. */
208 int waiting_for_input
;
210 /* True while displaying for echoing. Delays C-g throwing. */
214 /* Non-null means we can start echoing at the next input pause even
215 though there is something in the echo area. */
217 static struct kboard
*ok_to_echo_at_next_pause
;
219 /* The kboard last echoing, or null for none. Reset to 0 in
220 cancel_echoing. If non-null, and a current echo area message
221 exists, and echo_message_buffer is eq to the current message
222 buffer, we know that the message comes from echo_kboard. */
224 struct kboard
*echo_kboard
;
226 /* The buffer used for echoing. Set in echo_now, reset in
229 Lisp_Object echo_message_buffer
;
231 /* Nonzero means disregard local maps for the menu bar. */
232 static int inhibit_local_menu_bar_menus
;
234 /* Nonzero means C-g should cause immediate error-signal. */
237 /* The user's ERASE setting. */
238 Lisp_Object Vtty_erase_char
;
240 /* Character to recognize as the help char. */
241 Lisp_Object Vhelp_char
;
243 /* List of other event types to recognize as meaning "help". */
244 Lisp_Object Vhelp_event_list
;
246 /* Form to execute when help char is typed. */
247 Lisp_Object Vhelp_form
;
249 /* Command to run when the help character follows a prefix key. */
250 Lisp_Object Vprefix_help_command
;
252 /* List of items that should move to the end of the menu bar. */
253 Lisp_Object Vmenu_bar_final_items
;
255 /* Non-nil means show the equivalent key-binding for
256 any M-x command that has one.
257 The value can be a length of time to show the message for.
258 If the value is non-nil and not a number, we wait 2 seconds. */
259 Lisp_Object Vsuggest_key_bindings
;
261 /* How long to display an echo-area message when the minibuffer is active.
262 If the value is not a number, such messages don't time out. */
263 Lisp_Object Vminibuffer_message_timeout
;
265 /* Character that causes a quit. Normally C-g.
267 If we are running on an ordinary terminal, this must be an ordinary
268 ASCII char, since we want to make it our interrupt character.
270 If we are not running on an ordinary terminal, it still needs to be
271 an ordinary ASCII char. This character needs to be recognized in
272 the input interrupt handler. At this point, the keystroke is
273 represented as a struct input_event, while the desired quit
274 character is specified as a lispy event. The mapping from struct
275 input_events to lispy events cannot run in an interrupt handler,
276 and the reverse mapping is difficult for anything but ASCII
279 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
283 extern Lisp_Object current_global_map
;
284 extern int minibuf_level
;
286 /* If non-nil, this is a map that overrides all other local maps. */
287 Lisp_Object Voverriding_local_map
;
289 /* If non-nil, Voverriding_local_map applies to the menu bar. */
290 Lisp_Object Voverriding_local_map_menu_flag
;
292 /* Keymap that defines special misc events that should
293 be processed immediately at a low level. */
294 Lisp_Object Vspecial_event_map
;
296 /* Current depth in recursive edits. */
297 int command_loop_level
;
299 /* Total number of times command_loop has read a key sequence. */
300 EMACS_INT num_input_keys
;
302 /* Last input character read as a command. */
303 Lisp_Object last_command_char
;
305 /* Last input character read as a command, not counting menus
306 reached by the mouse. */
307 Lisp_Object last_nonmenu_event
;
309 /* Last input character read for any purpose. */
310 Lisp_Object last_input_char
;
312 /* If not Qnil, a list of objects to be read as subsequent command input. */
313 Lisp_Object Vunread_command_events
;
315 /* If not Qnil, a list of objects to be read as subsequent command input
316 including input method processing. */
317 Lisp_Object Vunread_input_method_events
;
319 /* If not Qnil, a list of objects to be read as subsequent command input
320 but NOT including input method processing. */
321 Lisp_Object Vunread_post_input_method_events
;
323 /* If not -1, an event to be read as subsequent command input. */
324 EMACS_INT unread_command_char
;
326 /* If not Qnil, this is a switch-frame event which we decided to put
327 off until the end of a key sequence. This should be read as the
328 next command input, after any unread_command_events.
330 read_key_sequence uses this to delay switch-frame events until the
331 end of the key sequence; Fread_char uses it to put off switch-frame
332 events until a non-ASCII event is acceptable as input. */
333 Lisp_Object unread_switch_frame
;
335 /* A mask of extra modifier bits to put into every keyboard char. */
336 EMACS_INT extra_keyboard_modifiers
;
338 /* Char to use as prefix when a meta character is typed in.
339 This is bound on entry to minibuffer in case ESC is changed there. */
341 Lisp_Object meta_prefix_char
;
343 /* Last size recorded for a current buffer which is not a minibuffer. */
344 static int last_non_minibuf_size
;
346 /* Number of idle seconds before an auto-save and garbage collection. */
347 static Lisp_Object Vauto_save_timeout
;
349 /* Total number of times read_char has returned. */
350 int num_input_events
;
352 /* Total number of times read_char has returned, outside of macros. */
353 EMACS_INT num_nonmacro_input_events
;
355 /* Auto-save automatically when this many characters have been typed
356 since the last time. */
358 static EMACS_INT auto_save_interval
;
360 /* Value of num_nonmacro_input_events as of last auto save. */
364 /* The command being executed by the command loop.
365 Commands may set this, and the value set will be copied into
366 current_kboard->Vlast_command instead of the actual command. */
367 Lisp_Object Vthis_command
;
369 /* This is like Vthis_command, except that commands never set it. */
370 Lisp_Object real_this_command
;
372 /* If the lookup of the command returns a binding, the original
373 command is stored in this-original-command. It is nil otherwise. */
374 Lisp_Object Vthis_original_command
;
376 /* The value of point when the last command was executed. */
377 int last_point_position
;
379 /* The buffer that was current when the last command was started. */
380 Lisp_Object last_point_position_buffer
;
382 /* The frame in which the last input event occurred, or Qmacro if the
383 last event came from a macro. We use this to determine when to
384 generate switch-frame events. This may be cleared by functions
385 like Fselect_frame, to make sure that a switch-frame event is
386 generated by the next character. */
387 Lisp_Object internal_last_event_frame
;
389 /* A user-visible version of the above, intended to allow users to
390 figure out where the last event came from, if the event doesn't
391 carry that information itself (i.e. if it was a character). */
392 Lisp_Object Vlast_event_frame
;
394 /* The timestamp of the last input event we received from the X server.
395 X Windows wants this for selection ownership. */
396 unsigned long last_event_timestamp
;
398 Lisp_Object Qself_insert_command
;
399 Lisp_Object Qforward_char
;
400 Lisp_Object Qbackward_char
;
401 Lisp_Object Qundefined
;
402 Lisp_Object Qtimer_event_handler
;
404 /* read_key_sequence stores here the command definition of the
405 key sequence that it reads. */
406 Lisp_Object read_key_sequence_cmd
;
408 /* Echo unfinished commands after this many seconds of pause. */
409 Lisp_Object Vecho_keystrokes
;
411 /* Form to evaluate (if non-nil) when Emacs is started. */
412 Lisp_Object Vtop_level
;
414 /* User-supplied table to translate input characters. */
415 Lisp_Object Vkeyboard_translate_table
;
417 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
418 extern Lisp_Object Vfunction_key_map
;
420 /* Another keymap that maps key sequences into key sequences.
421 This one takes precedence over ordinary definitions. */
422 extern Lisp_Object Vkey_translation_map
;
424 /* If non-nil, this implements the current input method. */
425 Lisp_Object Vinput_method_function
;
426 Lisp_Object Qinput_method_function
;
428 /* When we call Vinput_method_function,
429 this holds the echo area message that was just erased. */
430 Lisp_Object Vinput_method_previous_message
;
432 /* Non-nil means deactivate the mark at end of this command. */
433 Lisp_Object Vdeactivate_mark
;
435 /* Menu bar specified in Lucid Emacs fashion. */
437 Lisp_Object Vlucid_menu_bar_dirty_flag
;
438 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
440 Lisp_Object Qecho_area_clear_hook
;
442 /* Hooks to run before and after each command. */
443 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
444 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
445 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
446 /* Hook run after a command if there's no more input soon. */
447 Lisp_Object Qpost_command_idle_hook
, Vpost_command_idle_hook
;
449 /* Delay time in microseconds before running post-command-idle-hook. */
450 EMACS_INT post_command_idle_delay
;
452 /* List of deferred actions to be performed at a later time.
453 The precise format isn't relevant here; we just check whether it is nil. */
454 Lisp_Object Vdeferred_action_list
;
456 /* Function to call to handle deferred actions, when there are any. */
457 Lisp_Object Vdeferred_action_function
;
458 Lisp_Object Qdeferred_action_function
;
460 Lisp_Object Qinput_method_exit_on_first_char
;
461 Lisp_Object Qinput_method_use_echo_area
;
463 /* File in which we write all commands we read. */
466 /* Nonzero if input is available. */
469 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
470 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
474 /* Non-zero means force key bindings update in parse_menu_item. */
476 int update_menu_bindings
;
478 extern char *pending_malloc_warning
;
480 /* Circular buffer for pre-read keyboard input. */
482 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
484 /* Pointer to next available character in kbd_buffer.
485 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
486 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
487 next available char is in kbd_buffer[0]. */
488 static struct input_event
*kbd_fetch_ptr
;
490 /* Pointer to next place to store character in kbd_buffer. This
491 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
492 character should go in kbd_buffer[0]. */
493 static struct input_event
* volatile kbd_store_ptr
;
495 /* The above pair of variables forms a "queue empty" flag. When we
496 enqueue a non-hook event, we increment kbd_store_ptr. When we
497 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
498 there is input available iff the two pointers are not equal.
500 Why not just have a flag set and cleared by the enqueuing and
501 dequeuing functions? Such a flag could be screwed up by interrupts
502 at inopportune times. */
504 /* If this flag is non-nil, we check mouse_moved to see when the
505 mouse moves, and motion events will appear in the input stream.
506 Otherwise, mouse motion is ignored. */
507 Lisp_Object do_mouse_tracking
;
509 /* Symbols to head events. */
510 Lisp_Object Qmouse_movement
;
511 Lisp_Object Qscroll_bar_movement
;
512 Lisp_Object Qswitch_frame
;
513 Lisp_Object Qdelete_frame
;
514 Lisp_Object Qiconify_frame
;
515 Lisp_Object Qmake_frame_visible
;
516 Lisp_Object Qselect_window
;
517 Lisp_Object Qhelp_echo
;
519 /* Symbols to denote kinds of events. */
520 Lisp_Object Qfunction_key
;
521 Lisp_Object Qmouse_click
;
523 Lisp_Object Qlanguage_change
;
525 Lisp_Object Qdrag_n_drop
;
526 Lisp_Object Qsave_session
;
528 /* Lisp_Object Qmouse_movement; - also an event header */
530 /* Properties of event headers. */
531 Lisp_Object Qevent_kind
;
532 Lisp_Object Qevent_symbol_elements
;
534 /* menu item parts */
535 Lisp_Object Qmenu_alias
;
536 Lisp_Object Qmenu_enable
;
537 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
538 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
539 extern Lisp_Object Vdefine_key_rebound_commands
;
540 extern Lisp_Object Qmenu_item
;
542 /* An event header symbol HEAD may have a property named
543 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
544 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
545 mask of modifiers applied to it. If present, this is used to help
546 speed up parse_modifiers. */
547 Lisp_Object Qevent_symbol_element_mask
;
549 /* An unmodified event header BASE may have a property named
550 Qmodifier_cache, which is an alist mapping modifier masks onto
551 modified versions of BASE. If present, this helps speed up
553 Lisp_Object Qmodifier_cache
;
555 /* Symbols to use for parts of windows. */
556 Lisp_Object Qmode_line
;
557 Lisp_Object Qvertical_line
;
558 Lisp_Object Qvertical_scroll_bar
;
559 Lisp_Object Qmenu_bar
;
560 extern Lisp_Object Qleft_margin
, Qright_margin
;
561 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
562 extern Lisp_Object QCmap
;
564 Lisp_Object
recursive_edit_unwind (), command_loop ();
565 Lisp_Object
Fthis_command_keys ();
566 Lisp_Object Qextended_command_history
;
567 EMACS_TIME
timer_check ();
569 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
571 extern char *x_get_keysym_name ();
573 static void record_menu_key ();
574 static int echo_length ();
576 Lisp_Object Qpolling_period
;
578 /* List of absolute timers. Appears in order of next scheduled event. */
579 Lisp_Object Vtimer_list
;
581 /* List of idle time timers. Appears in order of next scheduled event. */
582 Lisp_Object Vtimer_idle_list
;
584 /* Incremented whenever a timer is run. */
587 extern Lisp_Object Vprint_level
, Vprint_length
;
589 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
591 EMACS_TIME
*input_available_clear_time
;
593 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
594 Default is 1 if INTERRUPT_INPUT is defined. */
597 /* Nonzero while interrupts are temporarily deferred during redisplay. */
598 int interrupts_deferred
;
600 /* Nonzero means use ^S/^Q for flow control. */
603 /* Allow m- file to inhibit use of FIONREAD. */
604 #ifdef BROKEN_FIONREAD
608 /* We are unable to use interrupts if FIONREAD is not available,
609 so flush SIGIO so we won't try. */
616 /* If we support a window system, turn on the code to poll periodically
617 to detect C-g. It isn't actually used when doing interrupt input. */
618 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
619 #define POLL_FOR_INPUT
622 /* After a command is executed, if point is moved into a region that
623 has specific properties (e.g. composition, display), we adjust
624 point to the boundary of the region. But, if a command sets this
625 variable to non-nil, we suppress this point adjustment. This
626 variable is set to nil before reading a command. */
628 Lisp_Object Vdisable_point_adjustment
;
630 /* If non-nil, always disable point adjustment. */
632 Lisp_Object Vglobal_disable_point_adjustment
;
634 /* The time when Emacs started being idle. */
636 static EMACS_TIME timer_idleness_start_time
;
638 /* After Emacs stops being idle, this saves the last value
639 of timer_idleness_start_time from when it was idle. */
641 static EMACS_TIME timer_last_idleness_start_time
;
644 /* Global variable declarations. */
646 /* Function for init_keyboard to call with no args (if nonzero). */
647 void (*keyboard_init_hook
) ();
649 static int read_avail_input
P_ ((int));
650 static void get_input_pending
P_ ((int *, int));
651 static void get_filtered_input_pending
P_ ((int *, int, int));
652 static int readable_events
P_ ((int));
653 static int readable_filtered_events
P_ ((int, int));
654 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
655 Lisp_Object
, int *));
656 static Lisp_Object
read_char_x_menu_prompt ();
657 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
659 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
661 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
662 enum scroll_bar_part
,
663 Lisp_Object
, Lisp_Object
,
666 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
667 Lisp_Object
, char **,
668 Lisp_Object
*, unsigned));
669 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
670 static int parse_solitary_modifier
P_ ((Lisp_Object
));
671 static int parse_solitary_modifier ();
672 static void save_getcjmp
P_ ((jmp_buf));
673 static void save_getcjmp ();
674 static void restore_getcjmp
P_ ((jmp_buf));
675 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
676 static void clear_event
P_ ((struct input_event
*));
677 static void any_kboard_state
P_ ((void));
678 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
680 /* Nonzero means don't try to suspend even if the operating system seems
682 static int cannot_suspend
;
684 extern Lisp_Object Qidentity
, Qonly
;
686 /* Install the string STR as the beginning of the string of echoing,
687 so that it serves as a prompt for the next character.
688 Also start echoing. */
694 current_kboard
->echo_string
= str
;
695 current_kboard
->echo_after_prompt
= SCHARS (str
);
699 /* Add C to the echo string, if echoing is going on.
700 C can be a character, which is printed prettily ("M-C-x" and all that
701 jazz), or a symbol, whose name is printed. */
707 if (current_kboard
->immediate_echo
)
709 int size
= KEY_DESCRIPTION_SIZE
+ 100;
710 char *buffer
= (char *) alloca (size
);
712 Lisp_Object echo_string
;
714 echo_string
= current_kboard
->echo_string
;
716 /* If someone has passed us a composite event, use its head symbol. */
721 ptr
= push_key_description (XINT (c
), ptr
, 1);
723 else if (SYMBOLP (c
))
725 Lisp_Object name
= SYMBOL_NAME (c
);
726 int nbytes
= SBYTES (name
);
728 if (size
- (ptr
- buffer
) < nbytes
)
730 int offset
= ptr
- buffer
;
731 size
= max (2 * size
, size
+ nbytes
);
732 buffer
= (char *) alloca (size
);
733 ptr
= buffer
+ offset
;
736 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
737 STRING_MULTIBYTE (name
), 1);
740 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
743 const char *text
= " (Type ? for further options)";
744 int len
= strlen (text
);
746 if (size
- (ptr
- buffer
) < len
)
748 int offset
= ptr
- buffer
;
750 buffer
= (char *) alloca (size
);
751 ptr
= buffer
+ offset
;
754 bcopy (text
, ptr
, len
);
758 /* Replace a dash from echo_dash with a space, otherwise
759 add a space at the end as a separator between keys. */
760 if (STRINGP (echo_string
)
761 && SCHARS (echo_string
) > 1)
763 Lisp_Object last_char
, prev_char
, idx
;
765 idx
= make_number (SCHARS (echo_string
) - 2);
766 prev_char
= Faref (echo_string
, idx
);
768 idx
= make_number (SCHARS (echo_string
) - 1);
769 last_char
= Faref (echo_string
, idx
);
771 /* We test PREV_CHAR to make sure this isn't the echoing
773 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
774 Faset (echo_string
, idx
, make_number (' '));
776 echo_string
= concat2 (echo_string
, build_string (" "));
779 current_kboard
->echo_string
780 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
786 /* Temporarily add a dash to the end of the echo string if it's not
787 empty, so that it serves as a mini-prompt for the very next character. */
792 /* Do nothing if not echoing at all. */
793 if (NILP (current_kboard
->echo_string
))
796 if (!current_kboard
->immediate_echo
797 && SCHARS (current_kboard
->echo_string
) == 0)
800 /* Do nothing if we just printed a prompt. */
801 if (current_kboard
->echo_after_prompt
802 == SCHARS (current_kboard
->echo_string
))
805 /* Do nothing if we have already put a dash at the end. */
806 if (SCHARS (current_kboard
->echo_string
) > 1)
808 Lisp_Object last_char
, prev_char
, idx
;
810 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 2);
811 prev_char
= Faref (current_kboard
->echo_string
, idx
);
813 idx
= make_number (SCHARS (current_kboard
->echo_string
) - 1);
814 last_char
= Faref (current_kboard
->echo_string
, idx
);
816 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
820 /* Put a dash at the end of the buffer temporarily,
821 but make it go away when the next character is added. */
822 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
827 /* Display the current echo string, and begin echoing if not already
833 if (!current_kboard
->immediate_echo
)
836 current_kboard
->immediate_echo
= 1;
838 for (i
= 0; i
< this_command_key_count
; i
++)
842 /* Set before_command_echo_length to the value that would
843 have been saved before the start of this subcommand in
844 command_loop_1, if we had already been echoing then. */
845 if (i
== this_single_command_key_start
)
846 before_command_echo_length
= echo_length ();
848 c
= XVECTOR (this_command_keys
)->contents
[i
];
849 if (! (EVENT_HAS_PARAMETERS (c
)
850 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
854 /* Set before_command_echo_length to the value that would
855 have been saved before the start of this subcommand in
856 command_loop_1, if we had already been echoing then. */
857 if (this_command_key_count
== this_single_command_key_start
)
858 before_command_echo_length
= echo_length ();
860 /* Put a dash at the end to invite the user to type more. */
865 message3_nolog (current_kboard
->echo_string
,
866 SBYTES (current_kboard
->echo_string
),
867 STRING_MULTIBYTE (current_kboard
->echo_string
));
870 /* Record in what buffer we echoed, and from which kboard. */
871 echo_message_buffer
= echo_area_buffer
[0];
872 echo_kboard
= current_kboard
;
874 if (waiting_for_input
&& !NILP (Vquit_flag
))
875 quit_throw_to_read_char ();
878 /* Turn off echoing, for the start of a new command. */
883 current_kboard
->immediate_echo
= 0;
884 current_kboard
->echo_after_prompt
= -1;
885 current_kboard
->echo_string
= Qnil
;
886 ok_to_echo_at_next_pause
= NULL
;
888 echo_message_buffer
= Qnil
;
891 /* Return the length of the current echo string. */
896 return (STRINGP (current_kboard
->echo_string
)
897 ? SCHARS (current_kboard
->echo_string
)
901 /* Truncate the current echo message to its first LEN chars.
902 This and echo_char get used by read_key_sequence when the user
903 switches frames while entering a key sequence. */
906 echo_truncate (nchars
)
909 if (STRINGP (current_kboard
->echo_string
))
910 current_kboard
->echo_string
911 = Fsubstring (current_kboard
->echo_string
,
912 make_number (0), make_number (nchars
));
913 truncate_echo_area (nchars
);
917 /* Functions for manipulating this_command_keys. */
919 add_command_key (key
)
922 #if 0 /* Not needed after we made Freset_this_command_lengths
923 do the job immediately. */
924 /* If reset-this-command-length was called recently, obey it now.
925 See the doc string of that function for an explanation of why. */
926 if (before_command_restore_flag
)
928 this_command_key_count
= before_command_key_count_1
;
929 if (this_command_key_count
< this_single_command_key_start
)
930 this_single_command_key_start
= this_command_key_count
;
931 echo_truncate (before_command_echo_length_1
);
932 before_command_restore_flag
= 0;
936 if (this_command_key_count
>= ASIZE (this_command_keys
))
937 this_command_keys
= larger_vector (this_command_keys
,
938 2 * ASIZE (this_command_keys
),
941 AREF (this_command_keys
, this_command_key_count
) = key
;
942 ++this_command_key_count
;
949 int count
= SPECPDL_INDEX ();
952 if (command_loop_level
> 0)
954 specbind (Qstandard_output
, Qt
);
955 specbind (Qstandard_input
, Qt
);
958 #ifdef HAVE_X_WINDOWS
959 /* The command loop has started an hourglass timer, so we have to
960 cancel it here, otherwise it will fire because the recursive edit
961 can take some time. Do not check for display_hourglass_p here,
962 because it could already be nil. */
966 /* This function may have been called from a debugger called from
967 within redisplay, for instance by Edebugging a function called
968 from fontification-functions. We want to allow redisplay in
969 the debugging session.
971 The recursive edit is left with a `(throw exit ...)'. The `exit'
972 tag is not caught anywhere in redisplay, i.e. when we leave the
973 recursive edit, the original redisplay leading to the recursive
974 edit will be unwound. The outcome should therefore be safe. */
975 specbind (Qinhibit_redisplay
, Qnil
);
978 val
= command_loop ();
980 Fsignal (Qquit
, Qnil
);
981 /* Handle throw from read_minibuf when using minibuffer
982 while it's active but we're in another window. */
984 Fsignal (Qerror
, Fcons (val
, Qnil
));
986 return unbind_to (count
, Qnil
);
989 /* When an auto-save happens, record the "time", and don't do again soon. */
994 last_auto_save
= num_nonmacro_input_events
;
997 /* Make an auto save happen as soon as possible at command level. */
1000 force_auto_save_soon ()
1002 last_auto_save
= - auto_save_interval
- 1;
1004 record_asynch_buffer_change ();
1007 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
1008 doc
: /* Invoke the editor command loop recursively.
1009 To get out of the recursive edit, a command can do `(throw 'exit nil)';
1010 that tells this function to return.
1011 Alternately, `(throw 'exit t)' makes this function signal an error.
1012 This function is called by the editor initialization to begin editing. */)
1015 int count
= SPECPDL_INDEX ();
1018 /* If we enter while input is blocked, don't lock up here.
1019 This may happen through the debugger during redisplay. */
1020 if (INPUT_BLOCKED_P
)
1023 command_loop_level
++;
1024 update_mode_lines
= 1;
1026 if (command_loop_level
1027 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1028 buffer
= Fcurrent_buffer ();
1032 /* If we leave recursive_edit_1 below with a `throw' for instance,
1033 like it is done in the splash screen display, we have to
1034 make sure that we restore single_kboard as command_loop_1
1035 would have done if it were left normally. */
1036 record_unwind_protect (recursive_edit_unwind
,
1037 Fcons (buffer
, single_kboard
? Qt
: Qnil
));
1039 recursive_edit_1 ();
1040 return unbind_to (count
, Qnil
);
1044 recursive_edit_unwind (info
)
1047 if (BUFFERP (XCAR (info
)))
1048 Fset_buffer (XCAR (info
));
1050 if (NILP (XCDR (info
)))
1051 any_kboard_state ();
1053 single_kboard_state ();
1055 command_loop_level
--;
1056 update_mode_lines
= 1;
1065 #if 0 /* Theory: if there's anything in Vunread_command_events,
1066 it will right away be read by read_key_sequence,
1067 and then if we do switch KBOARDS, it will go into the side
1068 queue then. So we don't need to do anything special here -- rms. */
1069 if (CONSP (Vunread_command_events
))
1071 current_kboard
->kbd_queue
1072 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1073 current_kboard
->kbd_queue_has_data
= 1;
1075 Vunread_command_events
= Qnil
;
1081 /* Switch to the single-kboard state, making current_kboard
1082 the only KBOARD from which further input is accepted. */
1085 single_kboard_state ()
1092 /* Maintain a stack of kboards, so other parts of Emacs
1093 can switch temporarily to the kboard of a given frame
1094 and then revert to the previous status. */
1099 struct kboard_stack
*next
;
1102 static struct kboard_stack
*kboard_stack
;
1105 push_frame_kboard (f
)
1109 struct kboard_stack
*p
1110 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1112 p
->next
= kboard_stack
;
1113 p
->kboard
= current_kboard
;
1116 current_kboard
= FRAME_KBOARD (f
);
1124 struct kboard_stack
*p
= kboard_stack
;
1125 current_kboard
= p
->kboard
;
1126 kboard_stack
= p
->next
;
1131 /* Handle errors that are not handled at inner levels
1132 by printing an error message and returning to the editor command loop. */
1138 Lisp_Object old_level
, old_length
;
1139 char macroerror
[50];
1141 #ifdef HAVE_X_WINDOWS
1142 if (display_hourglass_p
)
1143 cancel_hourglass ();
1146 if (!NILP (executing_macro
))
1148 if (executing_macro_iterations
== 1)
1149 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1151 sprintf (macroerror
, "After %d kbd macro iterations: ",
1152 executing_macro_iterations
);
1157 Vstandard_output
= Qt
;
1158 Vstandard_input
= Qt
;
1159 Vexecuting_macro
= Qnil
;
1160 executing_macro
= Qnil
;
1161 current_kboard
->Vprefix_arg
= Qnil
;
1162 current_kboard
->Vlast_prefix_arg
= Qnil
;
1165 /* Avoid unquittable loop if data contains a circular list. */
1166 old_level
= Vprint_level
;
1167 old_length
= Vprint_length
;
1168 XSETFASTINT (Vprint_level
, 10);
1169 XSETFASTINT (Vprint_length
, 10);
1170 cmd_error_internal (data
, macroerror
);
1171 Vprint_level
= old_level
;
1172 Vprint_length
= old_length
;
1176 Vinhibit_quit
= Qnil
;
1178 if (command_loop_level
== 0 && minibuf_level
== 0)
1179 any_kboard_state ();
1182 return make_number (0);
1185 /* Take actions on handling an error. DATA is the data that describes
1188 CONTEXT is a C-string containing ASCII characters only which
1189 describes the context in which the error happened. If we need to
1190 generalize CONTEXT to allow multibyte characters, make it a Lisp
1194 cmd_error_internal (data
, context
)
1199 int kill_emacs_p
= 0;
1200 struct frame
*sf
= SELECTED_FRAME ();
1204 clear_message (1, 0);
1206 /* If the window system or terminal frame hasn't been initialized
1207 yet, or we're not interactive, it's best to dump this message out
1208 to stderr and exit. */
1209 if (!sf
->glyphs_initialized_p
1210 /* This is the case of the frame dumped with Emacs, when we're
1211 running under a window system. */
1212 || (!NILP (Vwindow_system
)
1213 && !inhibit_window_system
1214 && FRAME_TERMCAP_P (sf
))
1217 stream
= Qexternal_debugging_output
;
1223 message_log_maybe_newline ();
1228 /* The immediate context is not interesting for Quits,
1229 since they are asyncronous. */
1230 if (EQ (XCAR (data
), Qquit
))
1231 Vsignaling_function
= Qnil
;
1233 print_error_message (data
, stream
, context
, Vsignaling_function
);
1235 Vsignaling_function
= Qnil
;
1237 /* If the window system or terminal frame hasn't been initialized
1238 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1242 Fkill_emacs (make_number (-1));
1246 Lisp_Object
command_loop_1 ();
1247 Lisp_Object
command_loop_2 ();
1248 Lisp_Object
top_level_1 ();
1250 /* Entry to editor-command-loop.
1251 This level has the catches for exiting/returning to editor command loop.
1252 It returns nil to exit recursive edit, t to abort it. */
1257 if (command_loop_level
> 0 || minibuf_level
> 0)
1260 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1261 executing_macro
= Qnil
;
1267 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1268 /* Reset single_kboard in case top-level set it while
1269 evaluating an -f option, or we are stuck there for some
1271 any_kboard_state ();
1272 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1273 executing_macro
= Qnil
;
1275 /* End of file in -batch run causes exit here. */
1281 /* Here we catch errors in execution of commands within the
1282 editing loop, and reenter the editing loop.
1283 When there is an error, cmd_error runs and returns a non-nil
1284 value to us. A value of nil means that command_loop_1 itself
1285 returned due to end of file (or end of kbd macro). */
1290 register Lisp_Object val
;
1293 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1294 while (!NILP (val
));
1302 return Feval (Vtop_level
);
1308 /* On entry to the outer level, run the startup file */
1309 if (!NILP (Vtop_level
))
1310 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1311 else if (!NILP (Vpurify_flag
))
1312 message ("Bare impure Emacs (standard Lisp code not loaded)");
1314 message ("Bare Emacs (standard Lisp code not loaded)");
1318 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1319 doc
: /* Exit all recursive editing levels. */)
1322 #ifdef HAVE_X_WINDOWS
1323 if (display_hourglass_p
)
1324 cancel_hourglass ();
1327 /* Unblock input if we enter with input blocked. This may happen if
1328 redisplay traps e.g. during tool-bar update with input blocked. */
1329 while (INPUT_BLOCKED_P
)
1332 return Fthrow (Qtop_level
, Qnil
);
1335 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1336 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1339 if (command_loop_level
> 0 || minibuf_level
> 0)
1340 Fthrow (Qexit
, Qnil
);
1342 error ("No recursive edit is in progress");
1346 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1347 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1350 if (command_loop_level
> 0 || minibuf_level
> 0)
1353 error ("No recursive edit is in progress");
1357 /* This is the actual command reading loop,
1358 sans error-handling encapsulation. */
1360 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1362 void safe_run_hooks
P_ ((Lisp_Object
));
1363 static void adjust_point_for_property
P_ ((int, int));
1365 /* Cancel hourglass from protect_unwind.
1367 #ifdef HAVE_X_WINDOWS
1369 cancel_hourglass_unwind (arg
)
1372 cancel_hourglass ();
1383 Lisp_Object keybuf
[30];
1387 struct buffer
*prev_buffer
= NULL
;
1389 int was_locked
= single_kboard
;
1391 int already_adjusted
;
1393 current_kboard
->Vprefix_arg
= Qnil
;
1394 current_kboard
->Vlast_prefix_arg
= Qnil
;
1395 Vdeactivate_mark
= Qnil
;
1396 waiting_for_input
= 0;
1400 this_command_key_count
= 0;
1401 this_command_key_count_reset
= 0;
1402 this_single_command_key_start
= 0;
1404 if (NILP (Vmemory_full
))
1406 /* Make sure this hook runs after commands that get errors and
1407 throw to top level. */
1408 /* Note that the value cell will never directly contain nil
1409 if the symbol is a local variable. */
1410 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1411 safe_run_hooks (Qpost_command_hook
);
1413 /* If displaying a message, resize the echo area window to fit
1414 that message's size exactly. */
1415 if (!NILP (echo_area_buffer
[0]))
1416 resize_echo_area_exactly ();
1418 if (!NILP (Vdeferred_action_list
))
1419 call0 (Vdeferred_action_function
);
1421 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1423 if (NILP (Vunread_command_events
)
1424 && NILP (Vunread_input_method_events
)
1425 && NILP (Vunread_post_input_method_events
)
1426 && NILP (Vexecuting_macro
)
1427 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1428 safe_run_hooks (Qpost_command_idle_hook
);
1432 Vmemory_full
= Qnil
;
1434 /* Do this after running Vpost_command_hook, for consistency. */
1435 current_kboard
->Vlast_command
= Vthis_command
;
1436 current_kboard
->Vreal_last_command
= real_this_command
;
1440 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1443 /* Make sure the current window's buffer is selected. */
1444 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1445 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1447 /* Display any malloc warning that just came out. Use while because
1448 displaying one warning can cause another. */
1450 while (pending_malloc_warning
)
1451 display_malloc_warning ();
1455 Vdeactivate_mark
= Qnil
;
1457 /* If minibuffer on and echo area in use,
1458 wait a short time and redraw minibuffer. */
1461 && !NILP (echo_area_buffer
[0])
1462 && EQ (minibuf_window
, echo_area_window
)
1463 && NUMBERP (Vminibuffer_message_timeout
))
1465 /* Bind inhibit-quit to t so that C-g gets read in
1466 rather than quitting back to the minibuffer. */
1467 int count
= SPECPDL_INDEX ();
1468 specbind (Qinhibit_quit
, Qt
);
1470 Fsit_for (Vminibuffer_message_timeout
, Qnil
, Qnil
);
1471 /* Clear the echo area. */
1473 safe_run_hooks (Qecho_area_clear_hook
);
1475 unbind_to (count
, Qnil
);
1477 /* If a C-g came in before, treat it as input now. */
1478 if (!NILP (Vquit_flag
))
1481 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1486 alloca (0); /* Cause a garbage collection now */
1487 /* Since we can free the most stuff here. */
1488 #endif /* C_ALLOCA */
1491 /* Select the frame that the last event came from. Usually,
1492 switch-frame events will take care of this, but if some lisp
1493 code swallows a switch-frame event, we'll fix things up here.
1494 Is this a good idea? */
1495 if (FRAMEP (internal_last_event_frame
)
1496 && !EQ (internal_last_event_frame
, selected_frame
))
1497 Fselect_frame (internal_last_event_frame
, Qnil
);
1499 /* If it has changed current-menubar from previous value,
1500 really recompute the menubar from the value. */
1501 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1502 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1503 call0 (Qrecompute_lucid_menubar
);
1505 before_command_key_count
= this_command_key_count
;
1506 before_command_echo_length
= echo_length ();
1508 Vthis_command
= Qnil
;
1509 real_this_command
= Qnil
;
1511 /* Read next key sequence; i gets its length. */
1512 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1515 /* A filter may have run while we were reading the input. */
1516 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1518 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1519 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1523 /* Now we have read a key sequence of length I,
1524 or else I is 0 and we found end of file. */
1526 if (i
== 0) /* End of file -- happens only in */
1527 return Qnil
; /* a kbd macro, at the end. */
1528 /* -1 means read_key_sequence got a menu that was rejected.
1529 Just loop around and read another command. */
1533 this_command_key_count
= 0;
1534 this_command_key_count_reset
= 0;
1535 this_single_command_key_start
= 0;
1539 last_command_char
= keybuf
[i
- 1];
1541 /* If the previous command tried to force a specific window-start,
1542 forget about that, in case this command moves point far away
1543 from that position. But also throw away beg_unchanged and
1544 end_unchanged information in that case, so that redisplay will
1545 update the whole window properly. */
1546 if (!NILP (XWINDOW (selected_window
)->force_start
))
1549 XWINDOW (selected_window
)->force_start
= Qnil
;
1550 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1551 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1554 cmd
= read_key_sequence_cmd
;
1555 if (!NILP (Vexecuting_macro
))
1557 if (!NILP (Vquit_flag
))
1559 Vexecuting_macro
= Qt
;
1560 QUIT
; /* Make some noise. */
1561 /* Will return since macro now empty. */
1565 /* Do redisplay processing after this command except in special
1566 cases identified below. */
1567 prev_buffer
= current_buffer
;
1568 prev_modiff
= MODIFF
;
1569 last_point_position
= PT
;
1570 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1572 /* By default, we adjust point to a boundary of a region that
1573 has such a property that should be treated intangible
1574 (e.g. composition, display). But, some commands will set
1575 this variable differently. */
1576 Vdisable_point_adjustment
= Qnil
;
1578 /* Process filters and timers may have messed with deactivate-mark.
1579 reset it before we execute the command. */
1580 Vdeactivate_mark
= Qnil
;
1582 /* Remap command through active keymaps */
1583 Vthis_original_command
= cmd
;
1587 if (cmd1
= Fcommand_remapping (cmd
), !NILP (cmd1
))
1591 /* Execute the command. */
1593 Vthis_command
= cmd
;
1594 real_this_command
= cmd
;
1595 /* Note that the value cell will never directly contain nil
1596 if the symbol is a local variable. */
1597 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1598 safe_run_hooks (Qpre_command_hook
);
1600 already_adjusted
= 0;
1602 if (NILP (Vthis_command
))
1604 /* nil means key is undefined. */
1606 current_kboard
->defining_kbd_macro
= Qnil
;
1607 update_mode_lines
= 1;
1608 current_kboard
->Vprefix_arg
= Qnil
;
1612 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1614 /* In case we jump to directly_done. */
1615 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1617 /* Recognize some common commands in common situations and
1618 do them directly. */
1619 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1621 struct Lisp_Char_Table
*dp
1622 = window_display_table (XWINDOW (selected_window
));
1623 lose
= FETCH_CHAR (PT_BYTE
);
1625 if (! NILP (Vpost_command_hook
))
1626 /* Put this before calling adjust_point_for_property
1627 so it will only get called once in any case. */
1629 if (current_buffer
== prev_buffer
1630 && last_point_position
!= PT
1631 && NILP (Vdisable_point_adjustment
)
1632 && NILP (Vglobal_disable_point_adjustment
))
1633 adjust_point_for_property (last_point_position
, 0);
1634 already_adjusted
= 1;
1635 if (PT
== last_point_position
+ 1
1637 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1638 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1639 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1640 && (lose
>= 0x20 && lose
< 0x7f)))
1641 : (lose
>= 0x20 && lose
< 0x7f))
1642 /* To extract the case of continuation on
1643 wide-column characters. */
1644 && ASCII_BYTE_P (lose
)
1645 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1647 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1649 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1651 && !windows_or_buffers_changed
1652 && EQ (current_buffer
->selective_display
, Qnil
)
1653 && !detect_input_pending ()
1654 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1655 && NILP (Vexecuting_macro
))
1656 direct_output_forward_char (1);
1659 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1661 struct Lisp_Char_Table
*dp
1662 = window_display_table (XWINDOW (selected_window
));
1664 lose
= FETCH_CHAR (PT_BYTE
);
1665 if (! NILP (Vpost_command_hook
))
1667 if (current_buffer
== prev_buffer
1668 && last_point_position
!= PT
1669 && NILP (Vdisable_point_adjustment
)
1670 && NILP (Vglobal_disable_point_adjustment
))
1671 adjust_point_for_property (last_point_position
, 0);
1672 already_adjusted
= 1;
1673 if (PT
== last_point_position
- 1
1675 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1676 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1677 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1678 && (lose
>= 0x20 && lose
< 0x7f)))
1679 : (lose
>= 0x20 && lose
< 0x7f))
1680 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1682 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1684 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1686 && !windows_or_buffers_changed
1687 && EQ (current_buffer
->selective_display
, Qnil
)
1688 && !detect_input_pending ()
1689 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1690 && NILP (Vexecuting_macro
))
1691 direct_output_forward_char (-1);
1694 else if (EQ (Vthis_command
, Qself_insert_command
)
1695 /* Try this optimization only on char keystrokes. */
1696 && NATNUMP (last_command_char
)
1697 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1700 = translate_char (Vtranslation_table_for_input
,
1701 XFASTINT (last_command_char
));
1703 if (NILP (Vexecuting_macro
)
1704 && !EQ (minibuf_window
, selected_window
))
1706 if (!nonundocount
|| nonundocount
>= 20)
1714 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1716 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1718 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1720 || MODIFF
<= SAVE_MODIFF
1721 || windows_or_buffers_changed
1722 || !EQ (current_buffer
->selective_display
, Qnil
)
1723 || detect_input_pending ()
1724 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1725 || !NILP (Vexecuting_macro
));
1727 value
= internal_self_insert (c
, 0);
1732 if (! NILP (Vpost_command_hook
))
1733 /* Put this before calling adjust_point_for_property
1734 so it will only get called once in any case. */
1737 /* VALUE == 1 when AFTER-CHANGE functions are
1738 installed which is the case most of the time
1739 because FONT-LOCK installs one. */
1740 if (!lose
&& !value
)
1741 direct_output_for_insert (c
);
1746 /* Here for a command that isn't executed directly */
1749 #ifdef HAVE_X_WINDOWS
1750 int scount
= SPECPDL_INDEX ();
1752 if (display_hourglass_p
1753 && NILP (Vexecuting_macro
))
1755 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1761 if (NILP (current_kboard
->Vprefix_arg
))
1763 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1765 #ifdef HAVE_X_WINDOWS
1766 /* Do not check display_hourglass_p here, because
1767 Fcommand_execute could change it, but we should cancel
1768 hourglass cursor anyway.
1769 But don't cancel the hourglass within a macro
1770 just because a command in the macro finishes. */
1771 if (NILP (Vexecuting_macro
))
1772 unbind_to (scount
, Qnil
);
1777 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1779 /* Note that the value cell will never directly contain nil
1780 if the symbol is a local variable. */
1781 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1782 safe_run_hooks (Qpost_command_hook
);
1784 /* If displaying a message, resize the echo area window to fit
1785 that message's size exactly. */
1786 if (!NILP (echo_area_buffer
[0]))
1787 resize_echo_area_exactly ();
1789 if (!NILP (Vdeferred_action_list
))
1790 safe_run_hooks (Qdeferred_action_function
);
1792 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1794 if (NILP (Vunread_command_events
)
1795 && NILP (Vunread_input_method_events
)
1796 && NILP (Vunread_post_input_method_events
)
1797 && NILP (Vexecuting_macro
)
1798 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1799 safe_run_hooks (Qpost_command_idle_hook
);
1802 /* If there is a prefix argument,
1803 1) We don't want Vlast_command to be ``universal-argument''
1804 (that would be dumb), so don't set Vlast_command,
1805 2) we want to leave echoing on so that the prefix will be
1806 echoed as part of this key sequence, so don't call
1808 3) we want to leave this_command_key_count non-zero, so that
1809 read_char will realize that it is re-reading a character, and
1810 not echo it a second time.
1812 If the command didn't actually create a prefix arg,
1813 but is merely a frame event that is transparent to prefix args,
1814 then the above doesn't apply. */
1815 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1817 current_kboard
->Vlast_command
= Vthis_command
;
1818 current_kboard
->Vreal_last_command
= real_this_command
;
1820 this_command_key_count
= 0;
1821 this_command_key_count_reset
= 0;
1822 this_single_command_key_start
= 0;
1825 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1827 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1829 /* We could also call `deactivate'mark'. */
1830 if (EQ (Vtransient_mark_mode
, Qlambda
))
1831 Vtransient_mark_mode
= Qnil
;
1834 current_buffer
->mark_active
= Qnil
;
1835 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1838 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1839 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1842 /* Setting transient-mark-mode to `only' is a way of
1843 turning it on for just one command. */
1844 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1846 if (EQ (Vtransient_mark_mode
, Qidentity
))
1847 Vtransient_mark_mode
= Qnil
;
1848 if (EQ (Vtransient_mark_mode
, Qonly
))
1849 Vtransient_mark_mode
= Qidentity
;
1854 if (current_buffer
== prev_buffer
1855 && last_point_position
!= PT
1856 && NILP (Vdisable_point_adjustment
)
1857 && NILP (Vglobal_disable_point_adjustment
)
1858 && !already_adjusted
)
1859 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
1861 /* Install chars successfully executed in kbd macro. */
1863 if (!NILP (current_kboard
->defining_kbd_macro
)
1864 && NILP (current_kboard
->Vprefix_arg
))
1865 finalize_kbd_macro_chars ();
1869 any_kboard_state ();
1874 extern Lisp_Object Qcomposition
, Qdisplay
;
1876 /* Adjust point to a boundary of a region that has such a property
1877 that should be treated intangible. For the moment, we check
1878 `composition', `display' and `invisible' properties.
1879 LAST_PT is the last position of point. */
1881 extern Lisp_Object Qafter_string
, Qbefore_string
;
1882 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
1885 adjust_point_for_property (last_pt
, modified
)
1890 Lisp_Object val
, overlay
, tmp
;
1891 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
1894 /* FIXME: cycling is probably not necessary because these properties
1895 can't be usefully combined anyway. */
1896 while (check_composition
|| check_display
|| check_invisible
)
1898 if (check_composition
1899 && PT
> BEGV
&& PT
< ZV
1900 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
1901 && COMPOSITION_VALID_P (beg
, end
, val
)
1902 && beg
< PT
/* && end > PT <- It's always the case. */
1903 && (last_pt
<= beg
|| last_pt
>= end
))
1906 SET_PT (PT
< last_pt
? beg
: end
);
1907 check_display
= check_invisible
= 1;
1909 check_composition
= 0;
1911 && PT
> BEGV
&& PT
< ZV
1912 && !NILP (val
= get_char_property_and_overlay
1913 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1914 && display_prop_intangible_p (val
)
1915 && (!OVERLAYP (overlay
)
1916 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1917 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1918 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1919 && beg
< PT
) /* && end > PT <- It's always the case. */
1922 SET_PT (PT
< last_pt
? beg
: end
);
1923 check_composition
= check_invisible
= 1;
1926 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1928 int inv
, ellipsis
= 0;
1931 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1933 && !NILP (val
= get_char_property_and_overlay
1934 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1935 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1937 ellipsis
= ellipsis
|| inv
> 1
1938 || (OVERLAYP (overlay
)
1939 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1940 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1941 tmp
= Fnext_single_char_property_change
1942 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1943 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1946 && !NILP (val
= get_char_property_and_overlay
1947 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1948 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1950 ellipsis
= ellipsis
|| inv
> 1
1951 || (OVERLAYP (overlay
)
1952 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1953 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1954 tmp
= Fprevious_single_char_property_change
1955 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1956 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1959 /* Move away from the inside area. */
1960 if (beg
< PT
&& end
> PT
)
1962 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1963 /* We haven't moved yet (so we don't need to fear
1964 infinite-looping) and we were outside the range
1965 before (so either end of the range still corresponds
1966 to a move in the right direction): pretend we moved
1967 less than we actually did, so that we still have
1968 more freedom below in choosing which end of the range
1970 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1971 /* We either have moved already or the last point
1972 was already in the range: we don't get to choose
1973 which end of the range we have to go to. */
1974 : (PT
< last_pt
? beg
: end
));
1975 check_composition
= check_display
= 1;
1977 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
1978 the point to something other than its argument, due to
1979 point-motion hooks, intangibility, etc. */
1980 xassert (PT
== beg
|| PT
== end
);
1983 /* Pretend the area doesn't exist if the buffer is not
1985 if (!modified
&& !ellipsis
&& beg
< end
)
1987 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1988 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1989 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1990 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1991 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1992 /* We've already moved as far as we can. Trying to go
1993 to the other end would mean moving backwards and thus
1994 could lead to an infinite loop. */
1996 else if (val
= get_pos_property (make_number (PT
),
1998 TEXT_PROP_MEANS_INVISIBLE (val
)
1999 && (val
= get_pos_property
2000 (make_number (PT
== beg
? end
: beg
),
2002 !TEXT_PROP_MEANS_INVISIBLE (val
)))
2003 (check_composition
= check_display
= 1,
2004 SET_PT (PT
== beg
? end
: beg
));
2007 check_invisible
= 0;
2011 /* Subroutine for safe_run_hooks: run the hook HOOK. */
2014 safe_run_hooks_1 (hook
)
2017 return call1 (Vrun_hooks
, Vinhibit_quit
);
2020 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
2023 safe_run_hooks_error (data
)
2026 Lisp_Object args
[3];
2027 args
[0] = build_string ("Error in %s: %s");
2028 args
[1] = Vinhibit_quit
;
2031 return Fset (Vinhibit_quit
, Qnil
);
2034 /* If we get an error while running the hook, cause the hook variable
2035 to be nil. Also inhibit quits, so that C-g won't cause the hook
2036 to mysteriously evaporate. */
2039 safe_run_hooks (hook
)
2042 int count
= SPECPDL_INDEX ();
2043 specbind (Qinhibit_quit
, hook
);
2045 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2047 unbind_to (count
, Qnil
);
2051 /* Number of seconds between polling for input. This is a Lisp
2052 variable that can be bound. */
2054 EMACS_INT polling_period
;
2056 /* Nonzero means polling for input is temporarily suppressed. */
2058 int poll_suppress_count
;
2060 /* Asynchronous timer for polling. */
2062 struct atimer
*poll_timer
;
2065 #ifdef POLL_FOR_INPUT
2067 /* Poll for input, so what we catch a C-g if it comes in. This
2068 function is called from x_make_frame_visible, see comment
2074 if (interrupt_input_blocked
== 0
2075 && !waiting_for_input
)
2076 read_avail_input (0);
2079 /* Timer callback function for poll_timer. TIMER is equal to
2083 poll_for_input (timer
)
2084 struct atimer
*timer
;
2086 if (poll_suppress_count
== 0)
2087 poll_for_input_1 ();
2090 #endif /* POLL_FOR_INPUT */
2092 /* Begin signals to poll for input, if they are appropriate.
2093 This function is called unconditionally from various places. */
2098 #ifdef POLL_FOR_INPUT
2099 if (read_socket_hook
&& !interrupt_input
)
2101 /* Turn alarm handling on unconditionally. It might have
2102 been turned off in process.c. */
2103 turn_on_atimers (1);
2105 /* If poll timer doesn't exist, are we need one with
2106 a different interval, start a new one. */
2107 if (poll_timer
== NULL
2108 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2110 EMACS_TIME interval
;
2113 cancel_atimer (poll_timer
);
2115 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2116 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2117 poll_for_input
, NULL
);
2120 /* Let the timer's callback function poll for input
2121 if this becomes zero. */
2122 --poll_suppress_count
;
2127 /* Nonzero if we are using polling to handle input asynchronously. */
2130 input_polling_used ()
2132 #ifdef POLL_FOR_INPUT
2133 return read_socket_hook
&& !interrupt_input
;
2139 /* Turn off polling. */
2144 #ifdef POLL_FOR_INPUT
2145 if (read_socket_hook
&& !interrupt_input
)
2146 ++poll_suppress_count
;
2150 /* Set the value of poll_suppress_count to COUNT
2151 and start or stop polling accordingly. */
2154 set_poll_suppress_count (count
)
2157 #ifdef POLL_FOR_INPUT
2158 if (count
== 0 && poll_suppress_count
!= 0)
2160 poll_suppress_count
= 1;
2163 else if (count
!= 0 && poll_suppress_count
== 0)
2167 poll_suppress_count
= count
;
2171 /* Bind polling_period to a value at least N.
2172 But don't decrease it. */
2175 bind_polling_period (n
)
2178 #ifdef POLL_FOR_INPUT
2179 int new = polling_period
;
2184 stop_other_atimers (poll_timer
);
2186 specbind (Qpolling_period
, make_number (new));
2187 /* Start a new alarm with the new period. */
2192 /* Apply the control modifier to CHARACTER. */
2198 /* Save the upper bits here. */
2199 int upper
= c
& ~0177;
2203 /* Everything in the columns containing the upper-case letters
2204 denotes a control character. */
2205 if (c
>= 0100 && c
< 0140)
2209 /* Set the shift modifier for a control char
2210 made from a shifted letter. But only for letters! */
2211 if (oc
>= 'A' && oc
<= 'Z')
2212 c
|= shift_modifier
;
2215 /* The lower-case letters denote control characters too. */
2216 else if (c
>= 'a' && c
<= 'z')
2219 /* Include the bits for control and shift
2220 only if the basic ASCII code can't indicate them. */
2224 /* Replace the high bits. */
2225 c
|= (upper
& ~ctrl_modifier
);
2230 /* Display help echo in the echo area.
2232 HELP a string means display that string, HELP nil means clear the
2233 help echo. If HELP is a function, call it with OBJECT and POS as
2234 arguments; the function should return a help string or nil for
2235 none. For all other types of HELP evaluate it to obtain a string.
2237 WINDOW is the window in which the help was generated, if any.
2238 It is nil if not in a window.
2240 If OBJECT is a buffer, POS is the position in the buffer where the
2241 `help-echo' text property was found.
2243 If OBJECT is an overlay, that overlay has a `help-echo' property,
2244 and POS is the position in the overlay's buffer under the mouse.
2246 If OBJECT is a string (an overlay string or a string displayed with
2247 the `display' property). POS is the position in that string under
2250 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2251 echo overwrites a keystroke echo currently displayed in the echo
2254 Note: this function may only be called with HELP nil or a string
2255 from X code running asynchronously. */
2258 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2259 Lisp_Object help
, window
, object
, pos
;
2260 int ok_to_overwrite_keystroke_echo
;
2262 if (!NILP (help
) && !STRINGP (help
))
2264 if (FUNCTIONP (help
))
2266 Lisp_Object args
[4];
2271 help
= safe_call (4, args
);
2274 help
= safe_eval (help
);
2276 if (!STRINGP (help
))
2280 if (STRINGP (help
) || NILP (help
))
2282 if (!NILP (Vshow_help_function
))
2283 call1 (Vshow_help_function
, help
);
2284 else if (/* Don't overwrite minibuffer contents. */
2285 !MINI_WINDOW_P (XWINDOW (selected_window
))
2286 /* Don't overwrite a keystroke echo. */
2287 && (NILP (echo_message_buffer
)
2288 || ok_to_overwrite_keystroke_echo
)
2289 /* Don't overwrite a prompt. */
2290 && !cursor_in_echo_area
)
2294 int count
= SPECPDL_INDEX ();
2296 if (!help_echo_showing_p
)
2297 Vpre_help_message
= current_message ();
2299 specbind (Qmessage_truncate_lines
, Qt
);
2300 message3_nolog (help
, SBYTES (help
),
2301 STRING_MULTIBYTE (help
));
2302 unbind_to (count
, Qnil
);
2304 else if (STRINGP (Vpre_help_message
))
2306 message3_nolog (Vpre_help_message
,
2307 SBYTES (Vpre_help_message
),
2308 STRING_MULTIBYTE (Vpre_help_message
));
2309 Vpre_help_message
= Qnil
;
2315 help_echo_showing_p
= STRINGP (help
);
2321 /* Input of single characters from keyboard */
2323 Lisp_Object
print_help ();
2324 static Lisp_Object
kbd_buffer_get_event ();
2325 static void record_char ();
2328 static jmp_buf wrong_kboard_jmpbuf
;
2331 #define STOP_POLLING \
2332 do { if (! polling_stopped_here) stop_polling (); \
2333 polling_stopped_here = 1; } while (0)
2335 #define RESUME_POLLING \
2336 do { if (polling_stopped_here) start_polling (); \
2337 polling_stopped_here = 0; } while (0)
2339 /* read a character from the keyboard; call the redisplay if needed */
2340 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2341 -1 means do not do redisplay, but do do autosaving.
2344 /* The arguments MAPS and NMAPS are for menu prompting.
2345 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2347 PREV_EVENT is the previous input event, or nil if we are reading
2348 the first event of a key sequence (or not reading a key sequence).
2349 If PREV_EVENT is t, that is a "magic" value that says
2350 not to run input methods, but in other respects to act as if
2351 not reading a key sequence.
2353 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2354 if we used a mouse menu to read the input, or zero otherwise. If
2355 USED_MOUSE_MENU is null, we don't dereference it.
2357 Value is t if we showed a menu and the user rejected it. */
2360 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
2364 Lisp_Object prev_event
;
2365 int *used_mouse_menu
;
2367 volatile Lisp_Object c
;
2369 jmp_buf local_getcjmp
;
2371 volatile int key_already_recorded
= 0;
2372 Lisp_Object tem
, save
;
2373 volatile Lisp_Object previous_echo_area_message
;
2374 volatile Lisp_Object also_record
;
2375 volatile int reread
;
2376 struct gcpro gcpro1
, gcpro2
;
2377 EMACS_TIME last_idle_start
;
2378 int polling_stopped_here
= 0;
2382 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2383 before_command_key_count
= this_command_key_count
;
2384 before_command_echo_length
= echo_length ();
2387 previous_echo_area_message
= Qnil
;
2389 GCPRO2 (c
, previous_echo_area_message
);
2394 if (CONSP (Vunread_post_input_method_events
))
2396 c
= XCAR (Vunread_post_input_method_events
);
2397 Vunread_post_input_method_events
2398 = XCDR (Vunread_post_input_method_events
);
2400 /* Undo what read_char_x_menu_prompt did when it unread
2401 additional keys returned by Fx_popup_menu. */
2403 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2411 if (unread_command_char
!= -1)
2413 XSETINT (c
, unread_command_char
);
2414 unread_command_char
= -1;
2420 if (CONSP (Vunread_command_events
))
2422 c
= XCAR (Vunread_command_events
);
2423 Vunread_command_events
= XCDR (Vunread_command_events
);
2425 /* Undo what read_char_x_menu_prompt did when it unread
2426 additional keys returned by Fx_popup_menu. */
2428 && EQ (XCDR (c
), Qdisabled
)
2429 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2432 /* If the queued event is something that used the mouse,
2433 set used_mouse_menu accordingly. */
2435 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2436 *used_mouse_menu
= 1;
2439 goto reread_for_input_method
;
2442 if (CONSP (Vunread_input_method_events
))
2444 c
= XCAR (Vunread_input_method_events
);
2445 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2447 /* Undo what read_char_x_menu_prompt did when it unread
2448 additional keys returned by Fx_popup_menu. */
2450 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2454 goto reread_for_input_method
;
2457 this_command_key_count_reset
= 0;
2459 if (!NILP (Vexecuting_macro
))
2461 /* We set this to Qmacro; since that's not a frame, nobody will
2462 try to switch frames on us, and the selected window will
2465 Since this event came from a macro, it would be misleading to
2466 leave internal_last_event_frame set to wherever the last
2467 real event came from. Normally, a switch-frame event selects
2468 internal_last_event_frame after each command is read, but
2469 events read from a macro should never cause a new frame to be
2471 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2473 /* Exit the macro if we are at the end.
2474 Also, some things replace the macro with t
2475 to force an early exit. */
2476 if (EQ (Vexecuting_macro
, Qt
)
2477 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
2483 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
2484 if (STRINGP (Vexecuting_macro
)
2485 && (XINT (c
) & 0x80))
2486 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2488 executing_macro_index
++;
2493 if (!NILP (unread_switch_frame
))
2495 c
= unread_switch_frame
;
2496 unread_switch_frame
= Qnil
;
2498 /* This event should make it into this_command_keys, and get echoed
2499 again, so we do not set `reread'. */
2503 /* if redisplay was requested */
2504 if (commandflag
>= 0)
2506 /* If there is pending input, process any events which are not
2507 user-visible, such as X selection_request events. */
2509 || detect_input_pending_run_timers (0))
2510 swallow_events (0); /* may clear input_pending */
2512 /* Redisplay if no pending input. */
2513 while (!input_pending
)
2515 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2516 redisplay_preserve_echo_area (5);
2521 /* Normal case: no input arrived during redisplay. */
2524 /* Input arrived and pre-empted redisplay.
2525 Process any events which are not user-visible. */
2527 /* If that cleared input_pending, try again to redisplay. */
2531 /* Message turns off echoing unless more keystrokes turn it on again.
2533 The code in 20.x for the condition was
2535 1. echo_area_glyphs && *echo_area_glyphs
2536 2. && echo_area_glyphs != current_kboard->echobuf
2537 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2539 (1) means there's a current message displayed
2541 (2) means it's not the message from echoing from the current
2544 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2545 is set to a non-null value. This is done in read_char and it is
2546 set to echo_area_glyphs after a call to echo_char. That means
2547 ok_to_echo_at_next_pause is either null or
2548 current_kboard->echobuf with the appropriate current_kboard at
2551 So, condition (3) means in clear text ok_to_echo_at_next_pause
2552 must be either null, or the current message isn't from echoing at
2553 all, or it's from echoing from a different kboard than the
2556 if (/* There currently is something in the echo area. */
2557 !NILP (echo_area_buffer
[0])
2558 && (/* And it's either not from echoing. */
2559 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2560 /* Or it's an echo from a different kboard. */
2561 || echo_kboard
!= current_kboard
2562 /* Or we explicitly allow overwriting whatever there is. */
2563 || ok_to_echo_at_next_pause
== NULL
))
2568 /* Try reading a character via menu prompting in the minibuf.
2569 Try this before the sit-for, because the sit-for
2570 would do the wrong thing if we are supposed to do
2571 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2572 after a mouse event so don't try a minibuf menu. */
2574 if (nmaps
> 0 && INTERACTIVE
2575 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2576 /* Don't bring up a menu if we already have another event. */
2577 && NILP (Vunread_command_events
)
2578 && unread_command_char
< 0
2579 && !detect_input_pending_run_timers (0))
2581 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2584 key_already_recorded
= 1;
2589 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2590 We will do that below, temporarily for short sections of code,
2591 when appropriate. local_getcjmp must be in effect
2592 around any call to sit_for or kbd_buffer_get_event;
2593 it *must not* be in effect when we call redisplay. */
2595 if (_setjmp (local_getcjmp
))
2597 XSETINT (c
, quit_char
);
2598 internal_last_event_frame
= selected_frame
;
2599 Vlast_event_frame
= internal_last_event_frame
;
2600 /* If we report the quit char as an event,
2601 don't do so more than once. */
2602 if (!NILP (Vinhibit_quit
))
2607 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2608 if (kb
!= current_kboard
)
2610 Lisp_Object link
= kb
->kbd_queue
;
2611 /* We shouldn't get here if we were in single-kboard mode! */
2616 while (CONSP (XCDR (link
)))
2618 if (!NILP (XCDR (link
)))
2622 kb
->kbd_queue
= Fcons (c
, Qnil
);
2624 XSETCDR (link
, Fcons (c
, Qnil
));
2625 kb
->kbd_queue_has_data
= 1;
2626 current_kboard
= kb
;
2627 /* This is going to exit from read_char
2628 so we had better get rid of this frame's stuff. */
2630 longjmp (wrong_kboard_jmpbuf
, 1);
2637 timer_start_idle ();
2639 /* If in middle of key sequence and minibuffer not active,
2640 start echoing if enough time elapses. */
2642 if (minibuf_level
== 0
2643 && !current_kboard
->immediate_echo
2644 && this_command_key_count
> 0
2646 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2647 && NILP (Fzerop (Vecho_keystrokes
))
2648 && (/* No message. */
2649 NILP (echo_area_buffer
[0])
2650 /* Or empty message. */
2651 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2652 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2653 /* Or already echoing from same kboard. */
2654 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2655 /* Or not echoing before and echoing allowed. */
2656 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2660 /* After a mouse event, start echoing right away.
2661 This is because we are probably about to display a menu,
2662 and we don't want to delay before doing so. */
2663 if (EVENT_HAS_PARAMETERS (prev_event
))
2668 double duration
= extract_float (Vecho_keystrokes
);
2669 sec
= (int) duration
;
2670 usec
= (duration
- sec
) * 1000000;
2671 save_getcjmp (save_jump
);
2672 restore_getcjmp (local_getcjmp
);
2673 tem0
= sit_for (sec
, usec
, 1, 1, 0);
2674 restore_getcjmp (save_jump
);
2676 && ! CONSP (Vunread_command_events
))
2681 /* Maybe auto save due to number of keystrokes. */
2683 if (commandflag
!= 0
2684 && auto_save_interval
> 0
2685 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2686 && !detect_input_pending_run_timers (0))
2688 Fdo_auto_save (Qnil
, Qnil
);
2689 /* Hooks can actually change some buffers in auto save. */
2693 /* Try reading using an X menu.
2694 This is never confused with reading using the minibuf
2695 because the recursive call of read_char in read_char_minibuf_menu_prompt
2696 does not pass on any keymaps. */
2698 if (nmaps
> 0 && INTERACTIVE
2699 && !NILP (prev_event
)
2700 && EVENT_HAS_PARAMETERS (prev_event
)
2701 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2702 && !EQ (XCAR (prev_event
), Qtool_bar
)
2703 /* Don't bring up a menu if we already have another event. */
2704 && NILP (Vunread_command_events
)
2705 && unread_command_char
< 0)
2707 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2709 /* Now that we have read an event, Emacs is not idle. */
2715 /* Maybe autosave and/or garbage collect due to idleness. */
2717 if (INTERACTIVE
&& NILP (c
))
2719 int delay_level
, buffer_size
;
2721 /* Slow down auto saves logarithmically in size of current buffer,
2722 and garbage collect while we're at it. */
2723 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2724 last_non_minibuf_size
= Z
- BEG
;
2725 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2727 while (buffer_size
> 64)
2728 delay_level
++, buffer_size
-= buffer_size
>> 2;
2729 if (delay_level
< 4) delay_level
= 4;
2730 /* delay_level is 4 for files under around 50k, 7 at 100k,
2731 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2733 /* Auto save if enough time goes by without input. */
2734 if (commandflag
!= 0
2735 && num_nonmacro_input_events
> last_auto_save
2736 && INTEGERP (Vauto_save_timeout
)
2737 && XINT (Vauto_save_timeout
) > 0)
2741 save_getcjmp (save_jump
);
2742 restore_getcjmp (local_getcjmp
);
2743 tem0
= sit_for (delay_level
* XFASTINT (Vauto_save_timeout
) / 4,
2745 restore_getcjmp (save_jump
);
2748 && ! CONSP (Vunread_command_events
))
2750 Fdo_auto_save (Qnil
, Qnil
);
2752 /* If we have auto-saved and there is still no input
2753 available, garbage collect if there has been enough
2754 consing going on to make it worthwhile. */
2755 if (!detect_input_pending_run_timers (0)
2756 && consing_since_gc
> gc_cons_threshold
/ 2)
2757 Fgarbage_collect ();
2764 /* If this has become non-nil here, it has been set by a timer
2765 or sentinel or filter. */
2766 if (CONSP (Vunread_command_events
))
2768 c
= XCAR (Vunread_command_events
);
2769 Vunread_command_events
= XCDR (Vunread_command_events
);
2772 /* Read something from current KBOARD's side queue, if possible. */
2776 if (current_kboard
->kbd_queue_has_data
)
2778 if (!CONSP (current_kboard
->kbd_queue
))
2780 c
= XCAR (current_kboard
->kbd_queue
);
2781 current_kboard
->kbd_queue
2782 = XCDR (current_kboard
->kbd_queue
);
2783 if (NILP (current_kboard
->kbd_queue
))
2784 current_kboard
->kbd_queue_has_data
= 0;
2785 input_pending
= readable_events (0);
2786 if (EVENT_HAS_PARAMETERS (c
)
2787 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2788 internal_last_event_frame
= XCAR (XCDR (c
));
2789 Vlast_event_frame
= internal_last_event_frame
;
2794 /* If current_kboard's side queue is empty check the other kboards.
2795 If one of them has data that we have not yet seen here,
2796 switch to it and process the data waiting for it.
2798 Note: if the events queued up for another kboard
2799 have already been seen here, and therefore are not a complete command,
2800 the kbd_queue_has_data field is 0, so we skip that kboard here.
2801 That's to avoid an infinite loop switching between kboards here. */
2802 if (NILP (c
) && !single_kboard
)
2805 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2806 if (kb
->kbd_queue_has_data
)
2808 current_kboard
= kb
;
2809 /* This is going to exit from read_char
2810 so we had better get rid of this frame's stuff. */
2812 longjmp (wrong_kboard_jmpbuf
, 1);
2821 /* Finally, we read from the main queue,
2822 and if that gives us something we can't use yet, we put it on the
2823 appropriate side queue and try again. */
2829 /* Actually read a character, waiting if necessary. */
2830 save_getcjmp (save_jump
);
2831 restore_getcjmp (local_getcjmp
);
2832 timer_start_idle ();
2833 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
);
2834 restore_getcjmp (save_jump
);
2837 if (! NILP (c
) && (kb
!= current_kboard
))
2839 Lisp_Object link
= kb
->kbd_queue
;
2842 while (CONSP (XCDR (link
)))
2844 if (!NILP (XCDR (link
)))
2848 kb
->kbd_queue
= Fcons (c
, Qnil
);
2850 XSETCDR (link
, Fcons (c
, Qnil
));
2851 kb
->kbd_queue_has_data
= 1;
2855 current_kboard
= kb
;
2856 /* This is going to exit from read_char
2857 so we had better get rid of this frame's stuff. */
2859 longjmp (wrong_kboard_jmpbuf
, 1);
2864 /* Terminate Emacs in batch mode if at eof. */
2865 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2866 Fkill_emacs (make_number (1));
2870 /* Add in any extra modifiers, where appropriate. */
2871 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2872 || ((extra_keyboard_modifiers
& 0177) < ' '
2873 && (extra_keyboard_modifiers
& 0177) != 0))
2874 XSETINT (c
, make_ctrl_char (XINT (c
)));
2876 /* Transfer any other modifier bits directly from
2877 extra_keyboard_modifiers to c. Ignore the actual character code
2878 in the low 16 bits of extra_keyboard_modifiers. */
2879 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2884 /* Record the last idle start time so that we can reset it
2885 should the next event read be a help-echo. */
2886 last_idle_start
= timer_idleness_start_time
;
2892 if (commandflag
>= 0
2893 && !input_pending
&& !detect_input_pending_run_timers (0))
2901 /* Buffer switch events are only for internal wakeups
2902 so don't show them to the user.
2903 Also, don't record a key if we already did. */
2904 if (BUFFERP (c
) || key_already_recorded
)
2907 /* Process special events within read_char
2908 and loop around to read another event. */
2911 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2916 int was_locked
= single_kboard
;
2918 last_input_char
= c
;
2919 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
2921 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
))
2922 /* We stopped being idle for this event; undo that. This
2923 prevents automatic window selection (under
2924 mouse_autoselect_window from acting as a real input event, for
2925 example banishing the mouse under mouse-avoidance-mode. */
2926 timer_idleness_start_time
= last_idle_start
;
2928 /* Resume allowing input from any kboard, if that was true before. */
2930 any_kboard_state ();
2935 /* Handle things that only apply to characters. */
2938 /* If kbd_buffer_get_event gave us an EOF, return that. */
2942 if ((STRINGP (Vkeyboard_translate_table
)
2943 && SCHARS (Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
2944 || (VECTORP (Vkeyboard_translate_table
)
2945 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2946 || CHAR_TABLE_P (Vkeyboard_translate_table
))
2949 d
= Faref (Vkeyboard_translate_table
, c
);
2950 /* nil in keyboard-translate-table means no translation. */
2956 /* If this event is a mouse click in the menu bar,
2957 return just menu-bar for now. Modify the mouse click event
2958 so we won't do this twice, then queue it up. */
2959 if (EVENT_HAS_PARAMETERS (c
)
2961 && CONSP (EVENT_START (c
))
2962 && CONSP (XCDR (EVENT_START (c
))))
2966 posn
= POSN_POSN (EVENT_START (c
));
2967 /* Handle menu-bar events:
2968 insert the dummy prefix event `menu-bar'. */
2969 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2971 /* Change menu-bar to (menu-bar) as the event "position". */
2972 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2975 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2980 /* Store these characters into recent_keys, the dribble file if any,
2981 and the keyboard macro being defined, if any. */
2983 if (! NILP (also_record
))
2984 record_char (also_record
);
2986 /* Wipe the echo area.
2987 But first, if we are about to use an input method,
2988 save the echo area contents for it to refer to. */
2990 && ! NILP (Vinput_method_function
)
2991 && (unsigned) XINT (c
) >= ' '
2992 && (unsigned) XINT (c
) != 127
2993 && (unsigned) XINT (c
) < 256)
2995 previous_echo_area_message
= Fcurrent_message ();
2996 Vinput_method_previous_message
= previous_echo_area_message
;
2999 /* Now wipe the echo area, except for help events which do their
3000 own stuff with the echo area. */
3002 || (!(EQ (Qhelp_echo
, XCAR (c
)))
3003 && !(EQ (Qswitch_frame
, XCAR (c
)))))
3005 if (!NILP (echo_area_buffer
[0]))
3006 safe_run_hooks (Qecho_area_clear_hook
);
3007 clear_message (1, 0);
3010 reread_for_input_method
:
3012 /* Pass this to the input method, if appropriate. */
3014 && ! NILP (Vinput_method_function
)
3015 /* Don't run the input method within a key sequence,
3016 after the first event of the key sequence. */
3017 && NILP (prev_event
)
3018 && (unsigned) XINT (c
) >= ' '
3019 && (unsigned) XINT (c
) != 127
3020 && (unsigned) XINT (c
) < 256)
3023 int key_count
, key_count_reset
;
3024 struct gcpro gcpro1
;
3025 int count
= SPECPDL_INDEX ();
3027 /* Save the echo status. */
3028 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3029 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3030 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3033 if (before_command_restore_flag
)
3035 this_command_key_count
= before_command_key_count_1
;
3036 if (this_command_key_count
< this_single_command_key_start
)
3037 this_single_command_key_start
= this_command_key_count
;
3038 echo_truncate (before_command_echo_length_1
);
3039 before_command_restore_flag
= 0;
3043 /* Save the this_command_keys status. */
3044 key_count
= this_command_key_count
;
3045 key_count_reset
= this_command_key_count_reset
;
3048 keys
= Fcopy_sequence (this_command_keys
);
3053 /* Clear out this_command_keys. */
3054 this_command_key_count
= 0;
3055 this_command_key_count_reset
= 0;
3057 /* Now wipe the echo area. */
3058 if (!NILP (echo_area_buffer
[0]))
3059 safe_run_hooks (Qecho_area_clear_hook
);
3060 clear_message (1, 0);
3063 /* If we are not reading a key sequence,
3064 never use the echo area. */
3067 specbind (Qinput_method_use_echo_area
, Qt
);
3070 /* Call the input method. */
3071 tem
= call1 (Vinput_method_function
, c
);
3073 tem
= unbind_to (count
, tem
);
3075 /* Restore the saved echoing state
3076 and this_command_keys state. */
3077 this_command_key_count
= key_count
;
3078 this_command_key_count_reset
= key_count_reset
;
3080 this_command_keys
= keys
;
3083 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3084 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3085 if (saved_immediate_echo
)
3090 /* The input method can return no events. */
3093 /* Bring back the previous message, if any. */
3094 if (! NILP (previous_echo_area_message
))
3095 message_with_string ("%s", previous_echo_area_message
, 0);
3098 /* It returned one event or more. */
3100 Vunread_post_input_method_events
3101 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3106 /* Display help if not echoing. */
3107 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3109 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3110 Lisp_Object help
, object
, position
, window
, tem
;
3112 tem
= Fcdr (XCDR (c
));
3115 window
= Fcar (tem
);
3117 object
= Fcar (tem
);
3119 position
= Fcar (tem
);
3121 show_help_echo (help
, window
, object
, position
, 0);
3123 /* We stopped being idle for this event; undo that. */
3124 timer_idleness_start_time
= last_idle_start
;
3128 if (! reread
|| this_command_key_count
== 0
3129 || this_command_key_count_reset
)
3132 /* Don't echo mouse motion events. */
3133 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3134 && NILP (Fzerop (Vecho_keystrokes
))
3135 && ! (EVENT_HAS_PARAMETERS (c
)
3136 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3139 if (! NILP (also_record
))
3140 echo_char (also_record
);
3141 /* Once we reread a character, echoing can happen
3142 the next time we pause to read a new one. */
3143 ok_to_echo_at_next_pause
= current_kboard
;
3146 /* Record this character as part of the current key. */
3147 add_command_key (c
);
3148 if (! NILP (also_record
))
3149 add_command_key (also_record
);
3152 last_input_char
= c
;
3155 /* Process the help character specially if enabled */
3156 if (!NILP (Vhelp_form
) && help_char_p (c
))
3159 count
= SPECPDL_INDEX ();
3161 record_unwind_protect (Fset_window_configuration
,
3162 Fcurrent_window_configuration (Qnil
));
3164 tem0
= Feval (Vhelp_form
);
3166 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3170 c
= read_char (0, 0, 0, Qnil
, 0);
3171 while (BUFFERP (c
));
3172 /* Remove the help from the frame */
3173 unbind_to (count
, Qnil
);
3176 if (EQ (c
, make_number (040)))
3180 c
= read_char (0, 0, 0, Qnil
, 0);
3181 while (BUFFERP (c
));
3190 /* Record a key that came from a mouse menu.
3191 Record it for echoing, for this-command-keys, and so on. */
3197 /* Wipe the echo area. */
3198 clear_message (1, 0);
3203 before_command_key_count
= this_command_key_count
;
3204 before_command_echo_length
= echo_length ();
3207 /* Don't echo mouse motion events. */
3208 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3209 && NILP (Fzerop (Vecho_keystrokes
)))
3213 /* Once we reread a character, echoing can happen
3214 the next time we pause to read a new one. */
3215 ok_to_echo_at_next_pause
= 0;
3218 /* Record this character as part of the current key. */
3219 add_command_key (c
);
3221 /* Re-reading in the middle of a command */
3222 last_input_char
= c
;
3226 /* Return 1 if should recognize C as "the help character". */
3234 if (EQ (c
, Vhelp_char
))
3236 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3237 if (EQ (c
, XCAR (tail
)))
3242 /* Record the input event C in various ways. */
3250 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3252 /* To avoid filling recent_keys with help-echo and mouse-movement
3253 events, we filter out repeated help-echo events, only store the
3254 first and last in a series of mouse-movement events, and don't
3255 store repeated help-echo events which are only separated by
3256 mouse-movement events. */
3258 Lisp_Object ev1
, ev2
, ev3
;
3261 if ((ix1
= recent_keys_index
- 1) < 0)
3262 ix1
= NUM_RECENT_KEYS
- 1;
3263 ev1
= AREF (recent_keys
, ix1
);
3265 if ((ix2
= ix1
- 1) < 0)
3266 ix2
= NUM_RECENT_KEYS
- 1;
3267 ev2
= AREF (recent_keys
, ix2
);
3269 if ((ix3
= ix2
- 1) < 0)
3270 ix3
= NUM_RECENT_KEYS
- 1;
3271 ev3
= AREF (recent_keys
, ix3
);
3273 if (EQ (XCAR (c
), Qhelp_echo
))
3275 /* Don't record `help-echo' in recent_keys unless it shows some help
3276 message, and a different help than the previously recorded
3278 Lisp_Object help
, last_help
;
3280 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3281 if (!STRINGP (help
))
3283 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3284 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3286 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3287 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3288 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3290 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3291 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3292 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3293 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3296 else if (EQ (XCAR (c
), Qmouse_movement
))
3298 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3299 So additional mouse movement events replace the last element. */
3300 Lisp_Object last_window
, window
;
3302 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3303 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3304 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3305 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3306 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3308 ASET (recent_keys
, ix1
, c
);
3314 store_kbd_macro_char (c
);
3319 ASET (recent_keys
, recent_keys_index
, c
);
3320 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3321 recent_keys_index
= 0;
3323 else if (recorded
< 0)
3325 /* We need to remove one or two events from recent_keys.
3326 To do this, we simply put nil at those events and move the
3327 recent_keys_index backwards over those events. Usually,
3328 users will never see those nil events, as they will be
3329 overwritten by the command keys entered to see recent_keys
3332 while (recorded
++ < 0 && total_keys
> 0)
3334 if (total_keys
< NUM_RECENT_KEYS
)
3336 if (--recent_keys_index
< 0)
3337 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3338 ASET (recent_keys
, recent_keys_index
, Qnil
);
3342 num_nonmacro_input_events
++;
3344 /* Write c to the dribble file. If c is a lispy event, write
3345 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3346 If you, dear reader, have a better idea, you've got the source. :-) */
3351 if (XUINT (c
) < 0x100)
3352 putc (XINT (c
), dribble
);
3354 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3358 Lisp_Object dribblee
;
3360 /* If it's a structured event, take the event header. */
3361 dribblee
= EVENT_HEAD (c
);
3363 if (SYMBOLP (dribblee
))
3365 putc ('<', dribble
);
3366 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3367 SBYTES (SYMBOL_NAME (dribblee
)),
3369 putc ('>', dribble
);
3381 struct buffer
*old
= current_buffer
;
3382 Fprinc (object
, Qnil
);
3383 set_buffer_internal (XBUFFER (Vstandard_output
));
3384 call0 (intern ("help-mode"));
3385 set_buffer_internal (old
);
3389 /* Copy out or in the info on where C-g should throw to.
3390 This is used when running Lisp code from within get_char,
3391 in case get_char is called recursively.
3392 See read_process_output. */
3398 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3402 restore_getcjmp (temp
)
3405 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3410 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
3411 of this function. */
3414 tracking_off (old_value
)
3415 Lisp_Object old_value
;
3417 do_mouse_tracking
= old_value
;
3418 if (NILP (old_value
))
3420 /* Redisplay may have been preempted because there was input
3421 available, and it assumes it will be called again after the
3422 input has been processed. If the only input available was
3423 the sort that we have just disabled, then we need to call
3425 if (!readable_events (1))
3427 redisplay_preserve_echo_area (6);
3428 get_input_pending (&input_pending
, 1);
3434 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
3435 doc
: /* Evaluate BODY with mouse movement events enabled.
3436 Within a `track-mouse' form, mouse motion generates input events that
3437 you can read with `read-event'.
3438 Normally, mouse motion is ignored.
3439 usage: (track-mouse BODY ...) */)
3443 int count
= SPECPDL_INDEX ();
3446 record_unwind_protect (tracking_off
, do_mouse_tracking
);
3448 do_mouse_tracking
= Qt
;
3450 val
= Fprogn (args
);
3451 return unbind_to (count
, val
);
3454 /* If mouse has moved on some frame, return one of those frames.
3455 Return 0 otherwise. */
3460 Lisp_Object tail
, frame
;
3462 FOR_EACH_FRAME (tail
, frame
)
3464 if (XFRAME (frame
)->mouse_moved
)
3465 return XFRAME (frame
);
3471 #endif /* HAVE_MOUSE */
3473 /* Low level keyboard/mouse input.
3474 kbd_buffer_store_event places events in kbd_buffer, and
3475 kbd_buffer_get_event retrieves them. */
3477 /* Return true iff there are any events in the queue that read-char
3478 would return. If this returns false, a read-char would block. */
3480 readable_filtered_events (do_timers_now
, filter_events
)
3485 timer_check (do_timers_now
);
3487 /* If the buffer contains only FOCUS_IN_EVENT events,
3488 and FILTER_EVENTS is nonzero, report it as empty. */
3489 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3491 int have_live_event
= 1;
3495 struct input_event
*event
;
3497 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3501 while (have_live_event
&& event
->kind
== FOCUS_IN_EVENT
)
3504 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3506 if (event
== kbd_store_ptr
)
3507 have_live_event
= 0;
3510 if (have_live_event
) return 1;
3514 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3519 if (current_kboard
->kbd_queue_has_data
)
3525 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3526 if (kb
->kbd_queue_has_data
)
3532 /* Return true iff there are any events in the queue that read-char
3533 would return. If this returns false, a read-char would block. */
3535 readable_events (do_timers_now
)
3538 return readable_filtered_events (do_timers_now
, 0);
3541 /* Set this for debugging, to have a way to get out */
3546 event_to_kboard (event
)
3547 struct input_event
*event
;
3550 frame
= event
->frame_or_window
;
3552 frame
= XCAR (frame
);
3553 else if (WINDOWP (frame
))
3554 frame
= WINDOW_FRAME (XWINDOW (frame
));
3556 /* There are still some events that don't set this field.
3557 For now, just ignore the problem.
3558 Also ignore dead frames here. */
3559 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3562 return FRAME_KBOARD (XFRAME (frame
));
3566 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3569 kbd_buffer_store_event (event
)
3570 register struct input_event
*event
;
3572 kbd_buffer_store_event_hold (event
, 0);
3575 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3577 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3578 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3579 Else, if EVENT is a quit event, store the quit event
3580 in HOLD_QUIT, and return (thus ignoring further events).
3582 This is used in read_avail_input to postpone the processing
3583 of the quit event until all subsequent input events have been
3584 parsed (and discarded).
3588 kbd_buffer_store_event_hold (event
, hold_quit
)
3589 register struct input_event
*event
;
3590 struct input_event
*hold_quit
;
3592 if (event
->kind
== NO_EVENT
)
3595 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3598 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3600 register int c
= event
->code
& 0377;
3602 if (event
->modifiers
& ctrl_modifier
)
3603 c
= make_ctrl_char (c
);
3605 c
|= (event
->modifiers
3606 & (meta_modifier
| alt_modifier
3607 | hyper_modifier
| super_modifier
));
3613 struct input_event
*sp
;
3616 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
3617 kb
!= current_kboard
))
3620 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3621 Fcons (make_number (c
), Qnil
));
3622 kb
->kbd_queue_has_data
= 1;
3623 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3625 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3628 if (event_to_kboard (sp
) == kb
)
3630 sp
->kind
= NO_EVENT
;
3631 sp
->frame_or_window
= Qnil
;
3641 bcopy (event
, (char *) hold_quit
, sizeof (*event
));
3645 /* If this results in a quit_char being returned to Emacs as
3646 input, set Vlast_event_frame properly. If this doesn't
3647 get returned to Emacs as an event, the next event read
3648 will set Vlast_event_frame again, so this is safe to do. */
3652 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3654 focus
= event
->frame_or_window
;
3655 internal_last_event_frame
= focus
;
3656 Vlast_event_frame
= focus
;
3659 last_event_timestamp
= event
->timestamp
;
3660 interrupt_signal (0 /* dummy */);
3664 if (c
&& c
== stop_character
)
3670 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3671 Just ignore the second one. */
3672 else if (event
->kind
== BUFFER_SWITCH_EVENT
3673 && kbd_fetch_ptr
!= kbd_store_ptr
3674 && ((kbd_store_ptr
== kbd_buffer
3675 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3676 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3679 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3680 kbd_store_ptr
= kbd_buffer
;
3682 /* Don't let the very last slot in the buffer become full,
3683 since that would make the two pointers equal,
3684 and that is indistinguishable from an empty buffer.
3685 Discard the event if it would fill the last slot. */
3686 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3689 #if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
3690 prone to assign individual members for other events, in case
3691 the input_event structure is changed. --2000-07-13, gerd. */
3692 struct input_event
*sp
= kbd_store_ptr
;
3693 sp
->kind
= event
->kind
;
3694 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3696 /* We must not use the ordinary copying code for this case,
3697 since `part' is an enum and copying it might not copy enough
3699 bcopy (event
, (char *) sp
, sizeof (*event
));
3704 sp
->code
= event
->code
;
3705 sp
->part
= event
->part
;
3706 sp
->frame_or_window
= event
->frame_or_window
;
3707 sp
->arg
= event
->arg
;
3708 sp
->modifiers
= event
->modifiers
;
3711 sp
->timestamp
= event
->timestamp
;
3714 *kbd_store_ptr
= *event
;
3722 /* Generate HELP_EVENT input_events in BUFP which has room for
3723 SIZE events. If there's not enough room in BUFP, ignore this
3726 HELP is the help form.
3728 FRAME is the frame on which the help is generated. OBJECT is the
3729 Lisp object where the help was found (a buffer, a string, an
3730 overlay, or nil if neither from a string nor from a buffer. POS is
3731 the position within OBJECT where the help was found.
3733 Value is the number of input_events generated. */
3736 gen_help_event (help
, frame
, window
, object
, pos
)
3737 Lisp_Object help
, frame
, object
, window
;
3740 struct input_event event
;
3744 event
.kind
= HELP_EVENT
;
3745 event
.frame_or_window
= frame
;
3747 event
.x
= WINDOWP (window
) ? window
: frame
;
3750 kbd_buffer_store_event (&event
);
3754 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3757 kbd_buffer_store_help_event (frame
, help
)
3758 Lisp_Object frame
, help
;
3760 struct input_event event
;
3762 event
.kind
= HELP_EVENT
;
3763 event
.frame_or_window
= frame
;
3768 kbd_buffer_store_event (&event
);
3772 /* Discard any mouse events in the event buffer by setting them to
3775 discard_mouse_events ()
3777 struct input_event
*sp
;
3778 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3780 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3783 if (sp
->kind
== MOUSE_CLICK_EVENT
3784 || sp
->kind
== WHEEL_EVENT
3786 || sp
->kind
== W32_SCROLL_BAR_CLICK_EVENT
3788 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3790 sp
->kind
= NO_EVENT
;
3796 /* Return non-zero if there are any real events waiting in the event
3797 buffer, not counting `NO_EVENT's.
3799 If DISCARD is non-zero, discard NO_EVENT events at the front of
3800 the input queue, possibly leaving the input queue empty if there
3801 are no real input events. */
3804 kbd_buffer_events_waiting (discard
)
3807 struct input_event
*sp
;
3809 for (sp
= kbd_fetch_ptr
;
3810 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3813 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3820 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3824 /* Clear input event EVENT. */
3828 struct input_event
*event
;
3830 event
->kind
= NO_EVENT
;
3834 /* Read one event from the event buffer, waiting if necessary.
3835 The value is a Lisp object representing the event.
3836 The value is nil for an event that should be ignored,
3837 or that was handled here.
3838 We always read and discard one event. */
3841 kbd_buffer_get_event (kbp
, used_mouse_menu
)
3843 int *used_mouse_menu
;
3852 *kbp
= current_kboard
;
3856 /* Wait until there is input available. */
3859 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3862 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3866 /* If the quit flag is set, then read_char will return
3867 quit_char, so that counts as "available input." */
3868 if (!NILP (Vquit_flag
))
3869 quit_throw_to_read_char ();
3871 /* One way or another, wait until input is available; then, if
3872 interrupt handlers have not read it, read it now. */
3875 wait_for_kbd_input ();
3877 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3881 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3884 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3888 Lisp_Object minus_one
;
3890 XSETINT (minus_one
, -1);
3891 wait_reading_process_input (0, 0, minus_one
, 1);
3893 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3894 /* Pass 1 for EXPECT since we just waited to have input. */
3895 read_avail_input (1);
3897 #endif /* not VMS */
3900 if (CONSP (Vunread_command_events
))
3903 first
= XCAR (Vunread_command_events
);
3904 Vunread_command_events
= XCDR (Vunread_command_events
);
3905 *kbp
= current_kboard
;
3909 /* At this point, we know that there is a readable event available
3910 somewhere. If the event queue is empty, then there must be a
3911 mouse movement enabled and available. */
3912 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3914 struct input_event
*event
;
3916 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3920 last_event_timestamp
= event
->timestamp
;
3923 *kbp
= event_to_kboard (event
);
3925 *kbp
= current_kboard
; /* Better than returning null ptr? */
3927 *kbp
= &the_only_kboard
;
3932 /* These two kinds of events get special handling
3933 and don't actually appear to the command loop.
3934 We return nil for them. */
3935 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3938 struct input_event copy
;
3940 /* Remove it from the buffer before processing it,
3941 since otherwise swallow_events will see it
3942 and process it again. */
3944 kbd_fetch_ptr
= event
+ 1;
3945 input_pending
= readable_events (0);
3946 x_handle_selection_request (©
);
3948 /* We're getting selection request events, but we don't have
3954 else if (event
->kind
== SELECTION_CLEAR_EVENT
)
3957 struct input_event copy
;
3959 /* Remove it from the buffer before processing it. */
3961 kbd_fetch_ptr
= event
+ 1;
3962 input_pending
= readable_events (0);
3963 x_handle_selection_clear (©
);
3965 /* We're getting selection request events, but we don't have
3970 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
3971 else if (event
->kind
== DELETE_WINDOW_EVENT
)
3973 /* Make an event (delete-frame (FRAME)). */
3974 obj
= Fcons (event
->frame_or_window
, Qnil
);
3975 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3976 kbd_fetch_ptr
= event
+ 1;
3979 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3980 else if (event
->kind
== ICONIFY_EVENT
)
3982 /* Make an event (iconify-frame (FRAME)). */
3983 obj
= Fcons (event
->frame_or_window
, Qnil
);
3984 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3985 kbd_fetch_ptr
= event
+ 1;
3987 else if (event
->kind
== DEICONIFY_EVENT
)
3989 /* Make an event (make-frame-visible (FRAME)). */
3990 obj
= Fcons (event
->frame_or_window
, Qnil
);
3991 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3992 kbd_fetch_ptr
= event
+ 1;
3995 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
3997 /* The value doesn't matter here; only the type is tested. */
3998 XSETBUFFER (obj
, current_buffer
);
3999 kbd_fetch_ptr
= event
+ 1;
4001 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
4002 || defined (USE_GTK)
4003 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
4005 kbd_fetch_ptr
= event
+ 1;
4006 input_pending
= readable_events (0);
4007 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
4008 x_activate_menubar (XFRAME (event
->frame_or_window
));
4012 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
4014 /* Make an event (language-change (FRAME CHARSET LCID)). */
4015 obj
= Fcons (event
->frame_or_window
, Qnil
);
4016 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
4017 kbd_fetch_ptr
= event
+ 1;
4020 else if (event
->kind
== SAVE_SESSION_EVENT
)
4022 obj
= Fcons (Qsave_session
, Qnil
);
4023 kbd_fetch_ptr
= event
+ 1;
4025 /* Just discard these, by returning nil.
4026 With MULTI_KBOARD, these events are used as placeholders
4027 when we need to randomly delete events from the queue.
4028 (They shouldn't otherwise be found in the buffer,
4029 but on some machines it appears they do show up
4030 even without MULTI_KBOARD.) */
4031 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
4032 mouse events during a popup-menu call. */
4033 else if (event
->kind
== NO_EVENT
)
4034 kbd_fetch_ptr
= event
+ 1;
4035 else if (event
->kind
== HELP_EVENT
)
4037 Lisp_Object object
, position
, help
, frame
, window
;
4039 frame
= event
->frame_or_window
;
4040 object
= event
->arg
;
4041 position
= make_number (event
->code
);
4044 clear_event (event
);
4046 kbd_fetch_ptr
= event
+ 1;
4047 if (!WINDOWP (window
))
4049 obj
= Fcons (Qhelp_echo
,
4050 list5 (frame
, help
, window
, object
, position
));
4052 else if (event
->kind
== FOCUS_IN_EVENT
)
4054 /* Notification of a FocusIn event. The frame receiving the
4055 focus is in event->frame_or_window. Generate a
4056 switch-frame event if necessary. */
4057 Lisp_Object frame
, focus
;
4059 frame
= event
->frame_or_window
;
4060 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4064 if (!EQ (frame
, internal_last_event_frame
)
4065 && !EQ (frame
, selected_frame
))
4066 obj
= make_lispy_switch_frame (frame
);
4067 internal_last_event_frame
= frame
;
4068 kbd_fetch_ptr
= event
+ 1;
4072 /* If this event is on a different frame, return a switch-frame this
4073 time, and leave the event in the queue for next time. */
4077 frame
= event
->frame_or_window
;
4079 frame
= XCAR (frame
);
4080 else if (WINDOWP (frame
))
4081 frame
= WINDOW_FRAME (XWINDOW (frame
));
4083 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4087 if (! EQ (frame
, internal_last_event_frame
)
4088 && !EQ (frame
, selected_frame
))
4089 obj
= make_lispy_switch_frame (frame
);
4090 internal_last_event_frame
= frame
;
4092 /* If we didn't decide to make a switch-frame event, go ahead
4093 and build a real event from the queue entry. */
4097 obj
= make_lispy_event (event
);
4099 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4100 || defined (USE_GTK)
4101 /* If this was a menu selection, then set the flag to inhibit
4102 writing to last_nonmenu_event. Don't do this if the event
4103 we're returning is (menu-bar), though; that indicates the
4104 beginning of the menu sequence, and we might as well leave
4105 that as the `event with parameters' for this selection. */
4107 && !EQ (event
->frame_or_window
, event
->arg
)
4108 && (event
->kind
== MENU_BAR_EVENT
4109 || event
->kind
== TOOL_BAR_EVENT
))
4110 *used_mouse_menu
= 1;
4113 /* Wipe out this event, to catch bugs. */
4114 clear_event (event
);
4115 kbd_fetch_ptr
= event
+ 1;
4120 /* Try generating a mouse motion event. */
4121 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4123 FRAME_PTR f
= some_mouse_moved ();
4124 Lisp_Object bar_window
;
4125 enum scroll_bar_part part
;
4129 *kbp
= current_kboard
;
4130 /* Note that this uses F to determine which display to look at.
4131 If there is no valid info, it does not store anything
4132 so x remains nil. */
4134 (*mouse_position_hook
) (&f
, 0, &bar_window
, &part
, &x
, &y
, &time
);
4138 /* Decide if we should generate a switch-frame event. Don't
4139 generate switch-frame events for motion outside of all Emacs
4145 frame
= FRAME_FOCUS_FRAME (f
);
4147 XSETFRAME (frame
, f
);
4149 if (! EQ (frame
, internal_last_event_frame
)
4150 && !EQ (frame
, selected_frame
))
4151 obj
= make_lispy_switch_frame (frame
);
4152 internal_last_event_frame
= frame
;
4155 /* If we didn't decide to make a switch-frame event, go ahead and
4156 return a mouse-motion event. */
4157 if (!NILP (x
) && NILP (obj
))
4158 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4160 #endif /* HAVE_MOUSE */
4162 /* We were promised by the above while loop that there was
4163 something for us to read! */
4166 input_pending
= readable_events (0);
4168 Vlast_event_frame
= internal_last_event_frame
;
4173 /* Process any events that are not user-visible,
4174 then return, without reading any user-visible events. */
4177 swallow_events (do_display
)
4182 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4184 struct input_event
*event
;
4186 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4190 last_event_timestamp
= event
->timestamp
;
4192 /* These two kinds of events get special handling
4193 and don't actually appear to the command loop. */
4194 if (event
->kind
== SELECTION_REQUEST_EVENT
)
4197 struct input_event copy
;
4199 /* Remove it from the buffer before processing it,
4200 since otherwise swallow_events called recursively could see it
4201 and process it again. */
4203 kbd_fetch_ptr
= event
+ 1;
4204 input_pending
= readable_events (0);
4205 x_handle_selection_request (©
);
4207 /* We're getting selection request events, but we don't have
4213 else if (event
->kind
== SELECTION_CLEAR_EVENT
)
4216 struct input_event copy
;
4218 /* Remove it from the buffer before processing it, */
4221 kbd_fetch_ptr
= event
+ 1;
4222 input_pending
= readable_events (0);
4223 x_handle_selection_clear (©
);
4225 /* We're getting selection request events, but we don't have
4234 old_timers_run
= timers_run
;
4235 get_input_pending (&input_pending
, 1);
4237 if (timers_run
!= old_timers_run
&& do_display
)
4238 redisplay_preserve_echo_area (7);
4241 /* Record the start of when Emacs is idle,
4242 for the sake of running idle-time timers. */
4249 /* If we are already in the idle state, do nothing. */
4250 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4253 EMACS_GET_TIME (timer_idleness_start_time
);
4255 timer_last_idleness_start_time
= timer_idleness_start_time
;
4257 /* Mark all idle-time timers as once again candidates for running. */
4258 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4262 timer
= XCAR (timers
);
4264 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4266 XVECTOR (timer
)->contents
[0] = Qnil
;
4270 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4275 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4278 /* This is only for debugging. */
4279 struct input_event last_timer_event
;
4281 /* Check whether a timer has fired. To prevent larger problems we simply
4282 disregard elements that are not proper timers. Do not make a circular
4283 timer list for the time being.
4285 Returns the number of seconds to wait until the next timer fires. If a
4286 timer is triggering now, return zero seconds.
4287 If no timer is active, return -1 seconds.
4289 If a timer is ripe, we run it, with quitting turned off.
4291 DO_IT_NOW is now ignored. It used to mean that we should
4292 run the timer directly instead of queueing a timer-event.
4293 Now we always run timers directly. */
4296 timer_check (do_it_now
)
4299 EMACS_TIME nexttime
;
4300 EMACS_TIME now
, idleness_now
;
4301 Lisp_Object timers
, idle_timers
, chosen_timer
;
4302 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4304 EMACS_SET_SECS (nexttime
, -1);
4305 EMACS_SET_USECS (nexttime
, -1);
4307 /* Always consider the ordinary timers. */
4308 timers
= Vtimer_list
;
4309 /* Consider the idle timers only if Emacs is idle. */
4310 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4311 idle_timers
= Vtimer_idle_list
;
4314 chosen_timer
= Qnil
;
4315 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4317 if (CONSP (timers
) || CONSP (idle_timers
))
4319 EMACS_GET_TIME (now
);
4320 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4321 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4324 while (CONSP (timers
) || CONSP (idle_timers
))
4326 Lisp_Object
*vector
;
4327 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4328 EMACS_TIME timer_time
, idle_timer_time
;
4329 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4331 /* Skip past invalid timers and timers already handled. */
4334 timer
= XCAR (timers
);
4335 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4337 timers
= XCDR (timers
);
4340 vector
= XVECTOR (timer
)->contents
;
4342 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4343 || !INTEGERP (vector
[3])
4344 || ! NILP (vector
[0]))
4346 timers
= XCDR (timers
);
4350 if (!NILP (idle_timers
))
4352 timer
= XCAR (idle_timers
);
4353 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4355 idle_timers
= XCDR (idle_timers
);
4358 vector
= XVECTOR (timer
)->contents
;
4360 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4361 || !INTEGERP (vector
[3])
4362 || ! NILP (vector
[0]))
4364 idle_timers
= XCDR (idle_timers
);
4369 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4370 based on the next ordinary timer.
4371 TIMER_DIFFERENCE is the distance in time from NOW to when
4372 this timer becomes ripe (negative if it's already ripe). */
4375 timer
= XCAR (timers
);
4376 vector
= XVECTOR (timer
)->contents
;
4377 EMACS_SET_SECS (timer_time
,
4378 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4379 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4380 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4383 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4384 based on the next idle timer. */
4385 if (!NILP (idle_timers
))
4387 idle_timer
= XCAR (idle_timers
);
4388 vector
= XVECTOR (idle_timer
)->contents
;
4389 EMACS_SET_SECS (idle_timer_time
,
4390 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4391 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4392 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4395 /* Decide which timer is the next timer,
4396 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4397 Also step down the list where we found that timer. */
4399 if (! NILP (timers
) && ! NILP (idle_timers
))
4402 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4403 if (EMACS_TIME_NEG_P (temp
))
4405 chosen_timer
= timer
;
4406 timers
= XCDR (timers
);
4407 difference
= timer_difference
;
4411 chosen_timer
= idle_timer
;
4412 idle_timers
= XCDR (idle_timers
);
4413 difference
= idle_timer_difference
;
4416 else if (! NILP (timers
))
4418 chosen_timer
= timer
;
4419 timers
= XCDR (timers
);
4420 difference
= timer_difference
;
4424 chosen_timer
= idle_timer
;
4425 idle_timers
= XCDR (idle_timers
);
4426 difference
= idle_timer_difference
;
4428 vector
= XVECTOR (chosen_timer
)->contents
;
4430 /* If timer is ripe, run it if it hasn't been run. */
4431 if (EMACS_TIME_NEG_P (difference
)
4432 || (EMACS_SECS (difference
) == 0
4433 && EMACS_USECS (difference
) == 0))
4435 if (NILP (vector
[0]))
4437 int was_locked
= single_kboard
;
4438 int count
= SPECPDL_INDEX ();
4439 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4441 /* Mark the timer as triggered to prevent problems if the lisp
4442 code fails to reschedule it right. */
4445 specbind (Qinhibit_quit
, Qt
);
4447 call1 (Qtimer_event_handler
, chosen_timer
);
4448 Vdeactivate_mark
= old_deactivate_mark
;
4450 unbind_to (count
, Qnil
);
4452 /* Resume allowing input from any kboard, if that was true before. */
4454 any_kboard_state ();
4456 /* Since we have handled the event,
4457 we don't need to tell the caller to wake up and do it. */
4461 /* When we encounter a timer that is still waiting,
4462 return the amount of time to wait before it is ripe. */
4469 /* No timers are pending in the future. */
4470 /* Return 0 if we generated an event, and -1 if not. */
4475 /* Caches for modify_event_symbol. */
4476 static Lisp_Object accent_key_syms
;
4477 static Lisp_Object func_key_syms
;
4478 static Lisp_Object mouse_syms
;
4479 static Lisp_Object wheel_syms
;
4480 static Lisp_Object drag_n_drop_syms
;
4482 /* This is a list of keysym codes for special "accent" characters.
4483 It parallels lispy_accent_keys. */
4485 static int lispy_accent_codes
[] =
4487 #ifdef XK_dead_circumflex
4492 #ifdef XK_dead_grave
4497 #ifdef XK_dead_tilde
4502 #ifdef XK_dead_diaeresis
4507 #ifdef XK_dead_macron
4512 #ifdef XK_dead_degree
4517 #ifdef XK_dead_acute
4522 #ifdef XK_dead_cedilla
4527 #ifdef XK_dead_breve
4532 #ifdef XK_dead_ogonek
4537 #ifdef XK_dead_caron
4542 #ifdef XK_dead_doubleacute
4543 XK_dead_doubleacute
,
4547 #ifdef XK_dead_abovedot
4552 #ifdef XK_dead_abovering
4562 #ifdef XK_dead_belowdot
4567 #ifdef XK_dead_voiced_sound
4568 XK_dead_voiced_sound
,
4572 #ifdef XK_dead_semivoiced_sound
4573 XK_dead_semivoiced_sound
,
4589 /* This is a list of Lisp names for special "accent" characters.
4590 It parallels lispy_accent_codes. */
4592 static char *lispy_accent_keys
[] =
4610 "dead-voiced-sound",
4611 "dead-semivoiced-sound",
4617 #define FUNCTION_KEY_OFFSET 0x0
4619 char *lispy_function_keys
[] =
4623 0, /* VK_LBUTTON 0x01 */
4624 0, /* VK_RBUTTON 0x02 */
4625 "cancel", /* VK_CANCEL 0x03 */
4626 0, /* VK_MBUTTON 0x04 */
4628 0, 0, 0, /* 0x05 .. 0x07 */
4630 "backspace", /* VK_BACK 0x08 */
4631 "tab", /* VK_TAB 0x09 */
4633 0, 0, /* 0x0A .. 0x0B */
4635 "clear", /* VK_CLEAR 0x0C */
4636 "return", /* VK_RETURN 0x0D */
4638 0, 0, /* 0x0E .. 0x0F */
4640 0, /* VK_SHIFT 0x10 */
4641 0, /* VK_CONTROL 0x11 */
4642 0, /* VK_MENU 0x12 */
4643 "pause", /* VK_PAUSE 0x13 */
4644 "capslock", /* VK_CAPITAL 0x14 */
4646 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4648 "escape", /* VK_ESCAPE 0x1B */
4650 0, 0, 0, 0, /* 0x1C .. 0x1F */
4652 0, /* VK_SPACE 0x20 */
4653 "prior", /* VK_PRIOR 0x21 */
4654 "next", /* VK_NEXT 0x22 */
4655 "end", /* VK_END 0x23 */
4656 "home", /* VK_HOME 0x24 */
4657 "left", /* VK_LEFT 0x25 */
4658 "up", /* VK_UP 0x26 */
4659 "right", /* VK_RIGHT 0x27 */
4660 "down", /* VK_DOWN 0x28 */
4661 "select", /* VK_SELECT 0x29 */
4662 "print", /* VK_PRINT 0x2A */
4663 "execute", /* VK_EXECUTE 0x2B */
4664 "snapshot", /* VK_SNAPSHOT 0x2C */
4665 "insert", /* VK_INSERT 0x2D */
4666 "delete", /* VK_DELETE 0x2E */
4667 "help", /* VK_HELP 0x2F */
4669 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4673 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4675 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4677 0, 0, 0, 0, 0, 0, 0, 0, 0,
4678 0, 0, 0, 0, 0, 0, 0, 0, 0,
4679 0, 0, 0, 0, 0, 0, 0, 0,
4681 "lwindow", /* VK_LWIN 0x5B */
4682 "rwindow", /* VK_RWIN 0x5C */
4683 "apps", /* VK_APPS 0x5D */
4685 0, 0, /* 0x5E .. 0x5F */
4687 "kp-0", /* VK_NUMPAD0 0x60 */
4688 "kp-1", /* VK_NUMPAD1 0x61 */
4689 "kp-2", /* VK_NUMPAD2 0x62 */
4690 "kp-3", /* VK_NUMPAD3 0x63 */
4691 "kp-4", /* VK_NUMPAD4 0x64 */
4692 "kp-5", /* VK_NUMPAD5 0x65 */
4693 "kp-6", /* VK_NUMPAD6 0x66 */
4694 "kp-7", /* VK_NUMPAD7 0x67 */
4695 "kp-8", /* VK_NUMPAD8 0x68 */
4696 "kp-9", /* VK_NUMPAD9 0x69 */
4697 "kp-multiply", /* VK_MULTIPLY 0x6A */
4698 "kp-add", /* VK_ADD 0x6B */
4699 "kp-separator", /* VK_SEPARATOR 0x6C */
4700 "kp-subtract", /* VK_SUBTRACT 0x6D */
4701 "kp-decimal", /* VK_DECIMAL 0x6E */
4702 "kp-divide", /* VK_DIVIDE 0x6F */
4703 "f1", /* VK_F1 0x70 */
4704 "f2", /* VK_F2 0x71 */
4705 "f3", /* VK_F3 0x72 */
4706 "f4", /* VK_F4 0x73 */
4707 "f5", /* VK_F5 0x74 */
4708 "f6", /* VK_F6 0x75 */
4709 "f7", /* VK_F7 0x76 */
4710 "f8", /* VK_F8 0x77 */
4711 "f9", /* VK_F9 0x78 */
4712 "f10", /* VK_F10 0x79 */
4713 "f11", /* VK_F11 0x7A */
4714 "f12", /* VK_F12 0x7B */
4715 "f13", /* VK_F13 0x7C */
4716 "f14", /* VK_F14 0x7D */
4717 "f15", /* VK_F15 0x7E */
4718 "f16", /* VK_F16 0x7F */
4719 "f17", /* VK_F17 0x80 */
4720 "f18", /* VK_F18 0x81 */
4721 "f19", /* VK_F19 0x82 */
4722 "f20", /* VK_F20 0x83 */
4723 "f21", /* VK_F21 0x84 */
4724 "f22", /* VK_F22 0x85 */
4725 "f23", /* VK_F23 0x86 */
4726 "f24", /* VK_F24 0x87 */
4728 0, 0, 0, 0, /* 0x88 .. 0x8B */
4729 0, 0, 0, 0, /* 0x8C .. 0x8F */
4731 "kp-numlock", /* VK_NUMLOCK 0x90 */
4732 "scroll", /* VK_SCROLL 0x91 */
4734 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4735 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4736 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4737 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4738 "kp-end", /* VK_NUMPAD_END 0x96 */
4739 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4740 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4741 "kp-up", /* VK_NUMPAD_UP 0x99 */
4742 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4743 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4744 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4745 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4747 0, 0, /* 0x9E .. 0x9F */
4750 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4751 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4752 * No other API or message will distinguish left and right keys this way.
4756 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4757 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4758 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4759 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4760 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4766 "attn", /* VK_ATTN 0xF6 */
4767 "crsel", /* VK_CRSEL 0xF7 */
4768 "exsel", /* VK_EXSEL 0xF8 */
4769 "ereof", /* VK_EREOF 0xF9 */
4770 "play", /* VK_PLAY 0xFA */
4771 "zoom", /* VK_ZOOM 0xFB */
4772 "noname", /* VK_NONAME 0xFC */
4773 "pa1", /* VK_PA1 0xFD */
4774 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4778 #else /* not HAVE_NTGUI */
4780 /* This should be dealt with in XTread_socket now, and that doesn't
4781 depend on the client system having the Kana syms defined. See also
4782 the XK_kana_A case below. */
4785 static char *lispy_kana_keys
[] =
4787 /* X Keysym value */
4788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4789 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4790 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4791 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4792 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4793 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4795 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4796 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4797 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4798 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4799 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4800 "kana-i", "kana-u", "kana-e", "kana-o",
4801 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4802 "prolongedsound", "kana-A", "kana-I", "kana-U",
4803 "kana-E", "kana-O", "kana-KA", "kana-KI",
4804 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4805 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4806 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4807 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4808 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4809 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4810 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4811 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4812 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4813 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4814 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4815 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4817 #endif /* XK_kana_A */
4820 #define FUNCTION_KEY_OFFSET 0xff00
4822 /* You'll notice that this table is arranged to be conveniently
4823 indexed by X Windows keysym values. */
4824 static char *lispy_function_keys
[] =
4826 /* X Keysym value */
4828 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4829 "backspace", "tab", "linefeed", "clear",
4831 0, 0, 0, "pause", /* 0xff10...1f */
4832 0, 0, 0, 0, 0, 0, 0, "escape",
4834 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4835 "romaji", "hiragana", "katakana", "hiragana-katakana",
4836 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4837 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4838 "eisu-toggle", /* 0xff30...3f */
4839 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4840 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4842 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4843 "down", "prior", "next", "end",
4844 "begin", 0, 0, 0, 0, 0, 0, 0,
4845 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4856 "break", /* 0xff6b */
4859 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4860 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4861 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4862 0, 0, 0, 0, 0, 0, 0, 0,
4863 "kp-tab", /* 0xff89 */
4865 "kp-enter", /* 0xff8d */
4867 "kp-f1", /* 0xff91 */
4871 "kp-home", /* 0xff95 */
4876 "kp-prior", /* kp-page-up */
4877 "kp-next", /* kp-page-down */
4883 0, 0, 0, 0, 0, 0, 0, 0, 0,
4884 "kp-multiply", /* 0xffaa */
4889 "kp-divide", /* 0xffaf */
4890 "kp-0", /* 0xffb0 */
4891 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4894 "kp-equal", /* 0xffbd */
4895 "f1", /* 0xffbe */ /* IsFunctionKey */
4897 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4898 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4899 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4900 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4901 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4902 0, 0, 0, 0, 0, 0, 0, 0,
4903 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4904 0, 0, 0, 0, 0, 0, 0, "delete"
4907 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4908 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4910 static char *iso_lispy_function_keys
[] =
4912 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4913 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4914 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4915 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4916 "iso-lefttab", /* 0xfe20 */
4917 "iso-move-line-up", "iso-move-line-down",
4918 "iso-partial-line-up", "iso-partial-line-down",
4919 "iso-partial-space-left", "iso-partial-space-right",
4920 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4921 "iso-release-margin-left", "iso-release-margin-right",
4922 "iso-release-both-margins",
4923 "iso-fast-cursor-left", "iso-fast-cursor-right",
4924 "iso-fast-cursor-up", "iso-fast-cursor-down",
4925 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4926 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4929 #endif /* not HAVE_NTGUI */
4931 Lisp_Object Vlispy_mouse_stem
;
4933 static char *lispy_wheel_names
[] =
4935 "wheel-up", "wheel-down"
4938 /* drag-n-drop events are generated when a set of selected files are
4939 dragged from another application and dropped onto an Emacs window. */
4940 static char *lispy_drag_n_drop_names
[] =
4945 /* Scroll bar parts. */
4946 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
4947 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
4948 Lisp_Object Qtop
, Qratio
;
4950 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
4951 Lisp_Object
*scroll_bar_parts
[] = {
4952 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
4953 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
4956 /* User signal events. */
4957 Lisp_Object Qusr1_signal
, Qusr2_signal
;
4959 Lisp_Object
*lispy_user_signals
[] =
4961 &Qusr1_signal
, &Qusr2_signal
4965 /* A vector, indexed by button number, giving the down-going location
4966 of currently depressed buttons, both scroll bar and non-scroll bar.
4968 The elements have the form
4969 (BUTTON-NUMBER MODIFIER-MASK . REST)
4970 where REST is the cdr of a position as it would be reported in the event.
4972 The make_lispy_event function stores positions here to tell the
4973 difference between click and drag events, and to store the starting
4974 location to be included in drag events. */
4976 static Lisp_Object button_down_location
;
4978 /* Information about the most recent up-going button event: Which
4979 button, what location, and what time. */
4981 static int last_mouse_button
;
4982 static int last_mouse_x
;
4983 static int last_mouse_y
;
4984 static unsigned long button_down_time
;
4986 /* The maximum time between clicks to make a double-click, or Qnil to
4987 disable double-click detection, or Qt for no time limit. */
4989 Lisp_Object Vdouble_click_time
;
4991 /* Maximum number of pixels the mouse may be moved between clicks
4992 to make a double-click. */
4994 EMACS_INT double_click_fuzz
;
4996 /* The number of clicks in this multiple-click. */
4998 int double_click_count
;
5000 /* Return position of a mouse click or wheel event */
5003 make_lispy_position (f
, x
, y
, time
)
5009 enum window_part part
;
5010 Lisp_Object posn
= Qnil
;
5011 Lisp_Object extra_info
= Qnil
;
5014 /* Set `window' to the window under frame pixel coordinates (x,y) */
5016 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
5017 &part
, &wx
, &wy
, 0);
5021 if (WINDOWP (window
))
5023 /* It's a click in window window at frame coordinates (x,y) */
5024 struct window
*w
= XWINDOW (window
);
5025 Lisp_Object string_info
= Qnil
;
5026 int textpos
= -1, rx
= -1, ry
= -1;
5027 int dx
= -1, dy
= -1;
5028 int width
= -1, height
= -1;
5029 Lisp_Object object
= Qnil
;
5031 /* Set event coordinates to window-relative coordinates
5032 for constructing the Lisp event below. */
5036 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5038 /* Mode line or header line. Look for a string under
5039 the mouse that may have a `local-map' property. */
5043 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5045 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5046 &object
, &dx
, &dy
, &width
, &height
);
5047 if (STRINGP (string
))
5048 string_info
= Fcons (string
, make_number (charpos
));
5049 if (w
== XWINDOW (selected_window
))
5052 textpos
= XMARKER (w
->pointm
)->charpos
;
5054 else if (part
== ON_VERTICAL_BORDER
)
5056 posn
= Qvertical_line
;
5061 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5066 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5068 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5069 &object
, &dx
, &dy
, &width
, &height
);
5070 if (STRINGP (string
))
5071 string_info
= Fcons (string
, make_number (charpos
));
5073 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
)
5075 posn
= (part
== ON_LEFT_FRINGE
) ? Qleft_fringe
: Qright_fringe
;
5078 if (part
== ON_RIGHT_FRINGE
)
5079 dx
-= (window_box_width (w
, LEFT_MARGIN_AREA
)
5080 + window_box_width (w
, TEXT_AREA
)
5081 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5082 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5084 else if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
5085 dx
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5090 Lisp_Object string2
, object2
= Qnil
;
5091 struct display_pos p
;
5093 int width2
, height2
;
5094 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5095 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5096 &object2
, &dx2
, &dy2
,
5098 textpos
= CHARPOS (p
.pos
);
5099 if (rx
< 0) rx
= wx
;
5100 if (ry
< 0) ry
= wy
;
5101 if (dx
< 0) dx
= dx2
;
5102 if (dy
< 0) dy
= dy2
;
5103 if (width
< 0) width
= width2
;
5104 if (height
< 0) height
= height2
;
5108 posn
= make_number (textpos
);
5109 if (STRINGP (string2
))
5110 string_info
= Fcons (string2
,
5111 make_number (CHARPOS (p
.string_pos
)));
5117 #ifdef HAVE_WINDOW_SYSTEM
5118 if (IMAGEP (object
))
5120 Lisp_Object image_map
, hotspot
;
5121 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5123 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5125 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5126 posn
= XCAR (hotspot
);
5131 extra_info
= Fcons (object
,
5132 Fcons (Fcons (make_number (dx
),
5134 Fcons (Fcons (make_number (width
),
5135 make_number (height
)),
5139 extra_info
= Fcons (string_info
,
5140 Fcons (make_number (textpos
),
5141 Fcons (Fcons (make_number (rx
),
5147 XSETFRAME (window
, f
);
5152 XSETFASTINT (*x
, 0);
5153 XSETFASTINT (*y
, 0);
5156 return Fcons (window
,
5158 Fcons (Fcons (*x
, *y
),
5159 Fcons (make_number (time
),
5163 /* Given a struct input_event, build the lisp event which represents
5164 it. If EVENT is 0, build a mouse movement event from the mouse
5165 movement buffer, which should have a movement event in it.
5167 Note that events must be passed to this function in the order they
5168 are received; this function stores the location of button presses
5169 in order to build drag events when the button is released. */
5172 make_lispy_event (event
)
5173 struct input_event
*event
;
5177 switch (SWITCH_ENUM_CAST (event
->kind
))
5179 /* A simple keystroke. */
5180 case ASCII_KEYSTROKE_EVENT
:
5182 Lisp_Object lispy_c
;
5183 int c
= event
->code
& 0377;
5184 /* Turn ASCII characters into control characters
5186 if (event
->modifiers
& ctrl_modifier
)
5187 c
= make_ctrl_char (c
);
5189 /* Add in the other modifier bits. We took care of ctrl_modifier
5190 just above, and the shift key was taken care of by the X code,
5191 and applied to control characters by make_ctrl_char. */
5192 c
|= (event
->modifiers
5193 & (meta_modifier
| alt_modifier
5194 | hyper_modifier
| super_modifier
));
5195 /* Distinguish Shift-SPC from SPC. */
5196 if ((event
->code
& 0377) == 040
5197 && event
->modifiers
& shift_modifier
)
5198 c
|= shift_modifier
;
5199 button_down_time
= 0;
5200 XSETFASTINT (lispy_c
, c
);
5204 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5206 Lisp_Object lispy_c
;
5207 int c
= event
->code
;
5209 /* Add in the other modifier bits. We took care of ctrl_modifier
5210 just above, and the shift key was taken care of by the X code,
5211 and applied to control characters by make_ctrl_char. */
5212 c
|= (event
->modifiers
5213 & (meta_modifier
| alt_modifier
5214 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5215 /* What about the `shift' modifier ? */
5216 button_down_time
= 0;
5217 XSETFASTINT (lispy_c
, c
);
5221 /* A function key. The symbol may need to have modifier prefixes
5223 case NON_ASCII_KEYSTROKE_EVENT
:
5224 button_down_time
= 0;
5226 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5227 if (event
->code
== lispy_accent_codes
[i
])
5228 return modify_event_symbol (i
,
5230 Qfunction_key
, Qnil
,
5231 lispy_accent_keys
, &accent_key_syms
,
5232 (sizeof (lispy_accent_keys
)
5233 / sizeof (lispy_accent_keys
[0])));
5237 if (event
->code
>= 0x400 && event
->code
< 0x500)
5238 return modify_event_symbol (event
->code
- 0x400,
5239 event
->modifiers
& ~shift_modifier
,
5240 Qfunction_key
, Qnil
,
5241 lispy_kana_keys
, &func_key_syms
,
5242 (sizeof (lispy_kana_keys
)
5243 / sizeof (lispy_kana_keys
[0])));
5244 #endif /* XK_kana_A */
5247 #ifdef ISO_FUNCTION_KEY_OFFSET
5248 if (event
->code
< FUNCTION_KEY_OFFSET
5249 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5250 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5252 Qfunction_key
, Qnil
,
5253 iso_lispy_function_keys
, &func_key_syms
,
5254 (sizeof (iso_lispy_function_keys
)
5255 / sizeof (iso_lispy_function_keys
[0])));
5258 /* Handle system-specific or unknown keysyms. */
5259 if (event
->code
& (1 << 28)
5260 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5261 || (event
->code
- FUNCTION_KEY_OFFSET
5262 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5263 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5265 /* We need to use an alist rather than a vector as the cache
5266 since we can't make a vector long enuf. */
5267 if (NILP (current_kboard
->system_key_syms
))
5268 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5269 return modify_event_symbol (event
->code
,
5272 current_kboard
->Vsystem_key_alist
,
5273 0, ¤t_kboard
->system_key_syms
,
5277 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5279 Qfunction_key
, Qnil
,
5280 lispy_function_keys
, &func_key_syms
,
5281 (sizeof (lispy_function_keys
)
5282 / sizeof (lispy_function_keys
[0])));
5285 /* A mouse click. Figure out where it is, decide whether it's
5286 a press, click or drag, and build the appropriate structure. */
5287 case MOUSE_CLICK_EVENT
:
5288 #ifndef USE_TOOLKIT_SCROLL_BARS
5289 case SCROLL_BAR_CLICK_EVENT
:
5292 int button
= event
->code
;
5294 Lisp_Object position
;
5295 Lisp_Object
*start_pos_ptr
;
5296 Lisp_Object start_pos
;
5300 /* Build the position as appropriate for this mouse click. */
5301 if (event
->kind
== MOUSE_CLICK_EVENT
)
5303 struct frame
*f
= XFRAME (event
->frame_or_window
);
5304 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5308 /* Ignore mouse events that were made on frame that
5309 have been deleted. */
5310 if (! FRAME_LIVE_P (f
))
5313 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5314 /* EVENT->x and EVENT->y are frame-relative pixel
5315 coordinates at this place. Under old redisplay, COLUMN
5316 and ROW are set to frame relative glyph coordinates
5317 which are then used to determine whether this click is
5318 in a menu (non-toolkit version). */
5319 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5320 &column
, &row
, NULL
, 1);
5322 /* In the non-toolkit version, clicks on the menu bar
5323 are ordinary button events in the event buffer.
5324 Distinguish them, and invoke the menu.
5326 (In the toolkit version, the toolkit handles the menu bar
5327 and Emacs doesn't know about it until after the user
5328 makes a selection.) */
5329 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5330 && (event
->modifiers
& down_modifier
))
5332 Lisp_Object items
, item
;
5337 /* Activate the menu bar on the down event. If the
5338 up event comes in before the menu code can deal with it,
5340 if (! (event
->modifiers
& down_modifier
))
5344 /* Find the menu bar item under `column'. */
5346 items
= FRAME_MENU_BAR_ITEMS (f
);
5347 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5349 Lisp_Object pos
, string
;
5350 string
= AREF (items
, i
+ 1);
5351 pos
= AREF (items
, i
+ 3);
5354 if (column
>= XINT (pos
)
5355 && column
< XINT (pos
) + SCHARS (string
))
5357 item
= AREF (items
, i
);
5362 /* ELisp manual 2.4b says (x y) are window relative but
5363 code says they are frame-relative. */
5365 = Fcons (event
->frame_or_window
,
5367 Fcons (Fcons (event
->x
, event
->y
),
5368 Fcons (make_number (event
->timestamp
),
5371 return Fcons (item
, Fcons (position
, Qnil
));
5373 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5375 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5378 #ifndef USE_TOOLKIT_SCROLL_BARS
5381 /* It's a scrollbar click. */
5383 Lisp_Object portion_whole
;
5386 window
= event
->frame_or_window
;
5387 portion_whole
= Fcons (event
->x
, event
->y
);
5388 part
= *scroll_bar_parts
[(int) event
->part
];
5392 Fcons (Qvertical_scroll_bar
,
5393 Fcons (portion_whole
,
5394 Fcons (make_number (event
->timestamp
),
5395 Fcons (part
, Qnil
)))));
5397 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5399 if (button
>= ASIZE (button_down_location
))
5401 button_down_location
= larger_vector (button_down_location
,
5403 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5406 start_pos_ptr
= &AREF (button_down_location
, button
);
5407 start_pos
= *start_pos_ptr
;
5408 *start_pos_ptr
= Qnil
;
5411 /* On window-system frames, use the value of
5412 double-click-fuzz as is. On other frames, interpret it
5413 as a multiple of 1/8 characters. */
5417 if (WINDOWP (event
->frame_or_window
))
5418 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5419 else if (FRAMEP (event
->frame_or_window
))
5420 f
= XFRAME (event
->frame_or_window
);
5424 if (FRAME_WINDOW_P (f
))
5425 fuzz
= double_click_fuzz
;
5427 fuzz
= double_click_fuzz
/ 8;
5429 is_double
= (button
== last_mouse_button
5430 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5431 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5432 && button_down_time
!= 0
5433 && (EQ (Vdouble_click_time
, Qt
)
5434 || (INTEGERP (Vdouble_click_time
)
5435 && ((int)(event
->timestamp
- button_down_time
)
5436 < XINT (Vdouble_click_time
)))));
5439 last_mouse_button
= button
;
5440 last_mouse_x
= XINT (event
->x
);
5441 last_mouse_y
= XINT (event
->y
);
5443 /* If this is a button press, squirrel away the location, so
5444 we can decide later whether it was a click or a drag. */
5445 if (event
->modifiers
& down_modifier
)
5449 double_click_count
++;
5450 event
->modifiers
|= ((double_click_count
> 2)
5455 double_click_count
= 1;
5456 button_down_time
= event
->timestamp
;
5457 *start_pos_ptr
= Fcopy_alist (position
);
5460 /* Now we're releasing a button - check the co-ordinates to
5461 see if this was a click or a drag. */
5462 else if (event
->modifiers
& up_modifier
)
5464 /* If we did not see a down before this up, ignore the up.
5465 Probably this happened because the down event chose a
5466 menu item. It would be an annoyance to treat the
5467 release of the button that chose the menu item as a
5470 if (!CONSP (start_pos
))
5473 event
->modifiers
&= ~up_modifier
;
5474 #if 0 /* Formerly we treated an up with no down as a click event. */
5475 if (!CONSP (start_pos
))
5476 event
->modifiers
|= click_modifier
;
5481 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5483 /* The third element of every position
5484 should be the (x,y) pair. */
5485 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5487 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5489 xdiff
= XFASTINT (event
->x
) - XFASTINT (XCAR (down
));
5490 ydiff
= XFASTINT (event
->y
) - XFASTINT (XCDR (down
));
5493 if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5494 && ydiff
< double_click_fuzz
5495 && ydiff
> - double_click_fuzz
)
5496 /* Mouse hasn't moved (much). */
5497 event
->modifiers
|= click_modifier
;
5500 button_down_time
= 0;
5501 event
->modifiers
|= drag_modifier
;
5504 /* Don't check is_double; treat this as multiple
5505 if the down-event was multiple. */
5506 if (double_click_count
> 1)
5507 event
->modifiers
|= ((double_click_count
> 2)
5513 /* Every mouse event should either have the down_modifier or
5514 the up_modifier set. */
5518 /* Get the symbol we should use for the mouse click. */
5521 head
= modify_event_symbol (button
,
5523 Qmouse_click
, Vlispy_mouse_stem
,
5526 XVECTOR (mouse_syms
)->size
);
5527 if (event
->modifiers
& drag_modifier
)
5532 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5535 Fcons (make_number (double_click_count
),
5546 Lisp_Object position
;
5549 /* Build the position as appropriate for this mouse click. */
5550 struct frame
*f
= XFRAME (event
->frame_or_window
);
5552 /* Ignore wheel events that were made on frame that have been
5554 if (! FRAME_LIVE_P (f
))
5557 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5560 /* Set double or triple modifiers to indicate the wheel speed. */
5562 /* On window-system frames, use the value of
5563 double-click-fuzz as is. On other frames, interpret it
5564 as a multiple of 1/8 characters. */
5569 if (WINDOWP (event
->frame_or_window
))
5570 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5571 else if (FRAMEP (event
->frame_or_window
))
5572 f
= XFRAME (event
->frame_or_window
);
5576 if (FRAME_WINDOW_P (f
))
5577 fuzz
= double_click_fuzz
;
5579 fuzz
= double_click_fuzz
/ 8;
5581 is_double
= (last_mouse_button
< 0
5582 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5583 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5584 && button_down_time
!= 0
5585 && (EQ (Vdouble_click_time
, Qt
)
5586 || (INTEGERP (Vdouble_click_time
)
5587 && ((int)(event
->timestamp
- button_down_time
)
5588 < XINT (Vdouble_click_time
)))));
5591 double_click_count
++;
5592 event
->modifiers
|= ((double_click_count
> 2)
5598 double_click_count
= 1;
5599 event
->modifiers
|= click_modifier
;
5602 button_down_time
= event
->timestamp
;
5603 /* Use a negative value to distinguish wheel from mouse button. */
5604 last_mouse_button
= -1;
5605 last_mouse_x
= XINT (event
->x
);
5606 last_mouse_y
= XINT (event
->y
);
5612 if (event
->modifiers
& up_modifier
)
5614 /* Emit a wheel-up event. */
5615 event
->modifiers
&= ~up_modifier
;
5618 else if (event
->modifiers
& down_modifier
)
5620 /* Emit a wheel-down event. */
5621 event
->modifiers
&= ~down_modifier
;
5625 /* Every wheel event should either have the down_modifier or
5626 the up_modifier set. */
5629 /* Get the symbol we should use for the wheel event. */
5630 head
= modify_event_symbol (symbol_num
,
5636 ASIZE (wheel_syms
));
5639 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5642 Fcons (make_number (double_click_count
),
5651 #ifdef USE_TOOLKIT_SCROLL_BARS
5653 /* We don't have down and up events if using toolkit scroll bars,
5654 so make this always a click event. Store in the `part' of
5655 the Lisp event a symbol which maps to the following actions:
5657 `above_handle' page up
5658 `below_handle' page down
5662 `bottom' bottom of buffer
5663 `handle' thumb has been dragged.
5664 `end-scroll' end of interaction with scroll bar
5666 The incoming input_event contains in its `part' member an
5667 index of type `enum scroll_bar_part' which we can use as an
5668 index in scroll_bar_parts to get the appropriate symbol. */
5670 case SCROLL_BAR_CLICK_EVENT
:
5672 Lisp_Object position
, head
, window
, portion_whole
, part
;
5674 window
= event
->frame_or_window
;
5675 portion_whole
= Fcons (event
->x
, event
->y
);
5676 part
= *scroll_bar_parts
[(int) event
->part
];
5680 Fcons (Qvertical_scroll_bar
,
5681 Fcons (portion_whole
,
5682 Fcons (make_number (event
->timestamp
),
5683 Fcons (part
, Qnil
)))));
5685 /* Always treat scroll bar events as clicks. */
5686 event
->modifiers
|= click_modifier
;
5687 event
->modifiers
&= ~up_modifier
;
5689 if (event
->code
>= ASIZE (mouse_syms
))
5690 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5692 /* Get the symbol we should use for the mouse click. */
5693 head
= modify_event_symbol (event
->code
,
5698 XVECTOR (mouse_syms
)->size
);
5699 return Fcons (head
, Fcons (position
, Qnil
));
5702 #endif /* USE_TOOLKIT_SCROLL_BARS */
5705 case W32_SCROLL_BAR_CLICK_EVENT
:
5707 int button
= event
->code
;
5709 Lisp_Object position
;
5710 Lisp_Object
*start_pos_ptr
;
5711 Lisp_Object start_pos
;
5715 Lisp_Object portion_whole
;
5718 window
= event
->frame_or_window
;
5719 portion_whole
= Fcons (event
->x
, event
->y
);
5720 part
= *scroll_bar_parts
[(int) event
->part
];
5724 Fcons (Qvertical_scroll_bar
,
5725 Fcons (portion_whole
,
5726 Fcons (make_number (event
->timestamp
),
5727 Fcons (part
, Qnil
)))));
5730 /* Always treat W32 scroll bar events as clicks. */
5731 event
->modifiers
|= click_modifier
;
5734 /* Get the symbol we should use for the mouse click. */
5737 head
= modify_event_symbol (button
,
5742 XVECTOR (mouse_syms
)->size
);
5748 #endif /* WINDOWSNT */
5750 case DRAG_N_DROP_EVENT
:
5753 Lisp_Object head
, position
;
5756 /* The frame_or_window field should be a cons of the frame in
5757 which the event occurred and a list of the filenames
5759 if (! CONSP (event
->frame_or_window
))
5762 f
= XFRAME (XCAR (event
->frame_or_window
));
5763 files
= XCDR (event
->frame_or_window
);
5765 /* Ignore mouse events that were made on frames that
5766 have been deleted. */
5767 if (! FRAME_LIVE_P (f
))
5770 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5773 head
= modify_event_symbol (0, event
->modifiers
,
5775 lispy_drag_n_drop_names
,
5776 &drag_n_drop_syms
, 1);
5782 #endif /* HAVE_MOUSE */
5784 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
5785 || defined (USE_GTK)
5786 case MENU_BAR_EVENT
:
5787 if (EQ (event
->arg
, event
->frame_or_window
))
5788 /* This is the prefix key. We translate this to
5789 `(menu_bar)' because the code in keyboard.c for menu
5790 events, which we use, relies on this. */
5791 return Fcons (Qmenu_bar
, Qnil
);
5795 case SELECT_WINDOW_EVENT
:
5796 /* Make an event (select-window (WINDOW)). */
5797 return Fcons (Qselect_window
,
5798 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5801 case TOOL_BAR_EVENT
:
5802 if (EQ (event
->arg
, event
->frame_or_window
))
5803 /* This is the prefix key. We translate this to
5804 `(tool_bar)' because the code in keyboard.c for tool bar
5805 events, which we use, relies on this. */
5806 return Fcons (Qtool_bar
, Qnil
);
5807 else if (SYMBOLP (event
->arg
))
5808 return apply_modifiers (event
->modifiers
, event
->arg
);
5811 case USER_SIGNAL_EVENT
:
5812 /* A user signal. */
5813 return *lispy_user_signals
[event
->code
];
5815 case SAVE_SESSION_EVENT
:
5816 return Qsave_session
;
5818 /* The 'kind' field of the event is something we don't recognize. */
5827 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
5829 Lisp_Object bar_window
;
5830 enum scroll_bar_part part
;
5834 /* Is it a scroll bar movement? */
5835 if (frame
&& ! NILP (bar_window
))
5837 Lisp_Object part_sym
;
5839 part_sym
= *scroll_bar_parts
[(int) part
];
5840 return Fcons (Qscroll_bar_movement
,
5841 (Fcons (Fcons (bar_window
,
5842 Fcons (Qvertical_scroll_bar
,
5843 Fcons (Fcons (x
, y
),
5844 Fcons (make_number (time
),
5850 /* Or is it an ordinary mouse movement? */
5853 Lisp_Object position
;
5855 position
= make_lispy_position (frame
, &x
, &y
, time
);
5857 return Fcons (Qmouse_movement
,
5863 #endif /* HAVE_MOUSE */
5865 /* Construct a switch frame event. */
5867 make_lispy_switch_frame (frame
)
5870 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
5873 /* Manipulating modifiers. */
5875 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5877 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5878 SYMBOL's name of the end of the modifiers; the string from this
5879 position is the unmodified symbol name.
5881 This doesn't use any caches. */
5884 parse_modifiers_uncached (symbol
, modifier_end
)
5892 CHECK_SYMBOL (symbol
);
5895 name
= SYMBOL_NAME (symbol
);
5897 for (i
= 0; i
+2 <= SBYTES (name
); )
5899 int this_mod_end
= 0;
5902 /* See if the name continues with a modifier word.
5903 Check that the word appears, but don't check what follows it.
5904 Set this_mod and this_mod_end to record what we find. */
5906 switch (SREF (name
, i
))
5908 #define SINGLE_LETTER_MOD(BIT) \
5909 (this_mod_end = i + 1, this_mod = BIT)
5912 SINGLE_LETTER_MOD (alt_modifier
);
5916 SINGLE_LETTER_MOD (ctrl_modifier
);
5920 SINGLE_LETTER_MOD (hyper_modifier
);
5924 SINGLE_LETTER_MOD (meta_modifier
);
5928 SINGLE_LETTER_MOD (shift_modifier
);
5932 SINGLE_LETTER_MOD (super_modifier
);
5935 #undef SINGLE_LETTER_MOD
5937 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
5938 if (i + LEN + 1 <= SBYTES (name) \
5939 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
5941 this_mod_end = i + LEN; \
5946 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
5947 MULTI_LETTER_MOD (down_modifier
, "down", 4);
5948 MULTI_LETTER_MOD (double_modifier
, "double", 6);
5952 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
5954 #undef MULTI_LETTER_MOD
5958 /* If we found no modifier, stop looking for them. */
5959 if (this_mod_end
== 0)
5962 /* Check there is a dash after the modifier, so that it
5963 really is a modifier. */
5964 if (this_mod_end
>= SBYTES (name
)
5965 || SREF (name
, this_mod_end
) != '-')
5968 /* This modifier is real; look for another. */
5969 modifiers
|= this_mod
;
5970 i
= this_mod_end
+ 1;
5973 /* Should we include the `click' modifier? */
5974 if (! (modifiers
& (down_modifier
| drag_modifier
5975 | double_modifier
| triple_modifier
))
5976 && i
+ 7 == SBYTES (name
)
5977 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
5978 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
5979 modifiers
|= click_modifier
;
5987 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5988 prepended to the string BASE[0..BASE_LEN-1].
5989 This doesn't use any caches. */
5991 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
5994 int base_len
, base_len_byte
;
5996 /* Since BASE could contain nulls, we can't use intern here; we have
5997 to use Fintern, which expects a genuine Lisp_String, and keeps a
6000 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6006 /* Only the event queue may use the `up' modifier; it should always
6007 be turned into a click or drag event before presented to lisp code. */
6008 if (modifiers
& up_modifier
)
6011 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6012 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6013 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6014 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6015 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6016 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6017 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6018 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6019 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6020 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6021 /* The click modifier is denoted by the absence of other modifiers. */
6025 mod_len
= p
- new_mods
;
6029 Lisp_Object new_name
;
6031 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6032 mod_len
+ base_len_byte
);
6033 bcopy (new_mods
, SDATA (new_name
), mod_len
);
6034 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
6036 return Fintern (new_name
, Qnil
);
6041 static char *modifier_names
[] =
6043 "up", "down", "drag", "click", "double", "triple", 0, 0,
6044 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6045 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6047 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6049 static Lisp_Object modifier_symbols
;
6051 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6053 lispy_modifier_list (modifiers
)
6056 Lisp_Object modifier_list
;
6059 modifier_list
= Qnil
;
6060 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6061 if (modifiers
& (1<<i
))
6062 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6065 return modifier_list
;
6069 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6070 where UNMODIFIED is the unmodified form of SYMBOL,
6071 MASK is the set of modifiers present in SYMBOL's name.
6072 This is similar to parse_modifiers_uncached, but uses the cache in
6073 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6074 Qevent_symbol_elements property. */
6077 parse_modifiers (symbol
)
6080 Lisp_Object elements
;
6082 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6083 if (CONSP (elements
))
6088 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6089 Lisp_Object unmodified
;
6092 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6093 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6096 if (modifiers
& ~INTMASK
)
6098 XSETFASTINT (mask
, modifiers
);
6099 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6101 /* Cache the parsing results on SYMBOL. */
6102 Fput (symbol
, Qevent_symbol_element_mask
,
6104 Fput (symbol
, Qevent_symbol_elements
,
6105 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6107 /* Since we know that SYMBOL is modifiers applied to unmodified,
6108 it would be nice to put that in unmodified's cache.
6109 But we can't, since we're not sure that parse_modifiers is
6116 /* Apply the modifiers MODIFIERS to the symbol BASE.
6117 BASE must be unmodified.
6119 This is like apply_modifiers_uncached, but uses BASE's
6120 Qmodifier_cache property, if present. It also builds
6121 Qevent_symbol_elements properties, since it has that info anyway.
6123 apply_modifiers copies the value of BASE's Qevent_kind property to
6124 the modified symbol. */
6126 apply_modifiers (modifiers
, base
)
6130 Lisp_Object cache
, index
, entry
, new_symbol
;
6132 /* Mask out upper bits. We don't know where this value's been. */
6133 modifiers
&= INTMASK
;
6135 /* The click modifier never figures into cache indices. */
6136 cache
= Fget (base
, Qmodifier_cache
);
6137 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6138 entry
= assq_no_quit (index
, cache
);
6141 new_symbol
= XCDR (entry
);
6144 /* We have to create the symbol ourselves. */
6145 new_symbol
= apply_modifiers_uncached (modifiers
,
6146 SDATA (SYMBOL_NAME (base
)),
6147 SCHARS (SYMBOL_NAME (base
)),
6148 SBYTES (SYMBOL_NAME (base
)));
6150 /* Add the new symbol to the base's cache. */
6151 entry
= Fcons (index
, new_symbol
);
6152 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6154 /* We have the parsing info now for free, so we could add it to
6156 XSETFASTINT (index, modifiers);
6157 Fput (new_symbol, Qevent_symbol_element_mask,
6158 Fcons (base, Fcons (index, Qnil)));
6159 Fput (new_symbol, Qevent_symbol_elements,
6160 Fcons (base, lispy_modifier_list (modifiers)));
6161 Sadly, this is only correct if `base' is indeed a base event,
6162 which is not necessarily the case. -stef */
6165 /* Make sure this symbol is of the same kind as BASE.
6167 You'd think we could just set this once and for all when we
6168 intern the symbol above, but reorder_modifiers may call us when
6169 BASE's property isn't set right; we can't assume that just
6170 because it has a Qmodifier_cache property it must have its
6171 Qevent_kind set right as well. */
6172 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6176 kind
= Fget (base
, Qevent_kind
);
6178 Fput (new_symbol
, Qevent_kind
, kind
);
6185 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6186 return a symbol with the modifiers placed in the canonical order.
6187 Canonical order is alphabetical, except for down and drag, which
6188 always come last. The 'click' modifier is never written out.
6190 Fdefine_key calls this to make sure that (for example) C-M-foo
6191 and M-C-foo end up being equivalent in the keymap. */
6194 reorder_modifiers (symbol
)
6197 /* It's hopefully okay to write the code this way, since everything
6198 will soon be in caches, and no consing will be done at all. */
6201 parsed
= parse_modifiers (symbol
);
6202 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6207 /* For handling events, we often want to produce a symbol whose name
6208 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6209 to some base, like the name of a function key or mouse button.
6210 modify_event_symbol produces symbols of this sort.
6212 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6213 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6216 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6217 into symbol names, or a string specifying a name stem used to
6218 construct a symbol name or the form `STEM-N', where N is the decimal
6219 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6220 non-nil; otherwise NAME_TABLE is used.
6222 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6223 persist between calls to modify_event_symbol that it can use to
6224 store a cache of the symbols it's generated for this NAME_TABLE
6225 before. The object stored there may be a vector or an alist.
6227 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6229 MODIFIERS is a set of modifier bits (as given in struct input_events)
6230 whose prefixes should be applied to the symbol name.
6232 SYMBOL_KIND is the value to be placed in the event_kind property of
6233 the returned symbol.
6235 The symbols we create are supposed to have an
6236 `event-symbol-elements' property, which lists the modifiers present
6237 in the symbol's name. */
6240 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6241 name_table
, symbol_table
, table_size
)
6244 Lisp_Object symbol_kind
;
6245 Lisp_Object name_alist_or_stem
;
6247 Lisp_Object
*symbol_table
;
6248 unsigned int table_size
;
6251 Lisp_Object symbol_int
;
6253 /* Get rid of the "vendor-specific" bit here. */
6254 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6256 /* Is this a request for a valid symbol? */
6257 if (symbol_num
< 0 || symbol_num
>= table_size
)
6260 if (CONSP (*symbol_table
))
6261 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6263 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6264 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6265 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6266 we've never used that symbol before. */
6269 if (! VECTORP (*symbol_table
)
6270 || XVECTOR (*symbol_table
)->size
!= table_size
)
6274 XSETFASTINT (size
, table_size
);
6275 *symbol_table
= Fmake_vector (size
, Qnil
);
6278 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6281 /* Have we already used this symbol before? */
6284 /* No; let's create it. */
6285 if (CONSP (name_alist_or_stem
))
6286 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6287 else if (STRINGP (name_alist_or_stem
))
6289 int len
= SBYTES (name_alist_or_stem
);
6290 char *buf
= (char *) alloca (len
+ 50);
6291 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6292 (long) XINT (symbol_int
) + 1);
6293 value
= intern (buf
);
6295 else if (name_table
!= 0 && name_table
[symbol_num
])
6296 value
= intern (name_table
[symbol_num
]);
6298 #ifdef HAVE_WINDOW_SYSTEM
6301 char *name
= x_get_keysym_name (symbol_num
);
6303 value
= intern (name
);
6310 sprintf (buf
, "key-%d", symbol_num
);
6311 value
= intern (buf
);
6314 if (CONSP (*symbol_table
))
6315 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6317 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6319 /* Fill in the cache entries for this symbol; this also
6320 builds the Qevent_symbol_elements property, which the user
6322 apply_modifiers (modifiers
& click_modifier
, value
);
6323 Fput (value
, Qevent_kind
, symbol_kind
);
6326 /* Apply modifiers to that symbol. */
6327 return apply_modifiers (modifiers
, value
);
6330 /* Convert a list that represents an event type,
6331 such as (ctrl meta backspace), into the usual representation of that
6332 event type as a number or a symbol. */
6334 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6335 doc
: /* Convert the event description list EVENT-DESC to an event type.
6336 EVENT-DESC should contain one base event type (a character or symbol)
6337 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6338 drag, down, double or triple). The base must be last.
6339 The return value is an event type (a character or symbol) which
6340 has the same base event type and all the specified modifiers. */)
6342 Lisp_Object event_desc
;
6350 while (CONSP (rest
))
6358 /* Given a symbol, see if it is a modifier name. */
6359 if (SYMBOLP (elt
) && CONSP (rest
))
6360 this = parse_solitary_modifier (elt
);
6364 else if (!NILP (base
))
6365 error ("Two bases given in one event");
6371 /* Let the symbol A refer to the character A. */
6372 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6373 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6375 if (INTEGERP (base
))
6377 /* Turn (shift a) into A. */
6378 if ((modifiers
& shift_modifier
) != 0
6379 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6381 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6382 modifiers
&= ~shift_modifier
;
6385 /* Turn (control a) into C-a. */
6386 if (modifiers
& ctrl_modifier
)
6387 return make_number ((modifiers
& ~ctrl_modifier
)
6388 | make_ctrl_char (XINT (base
)));
6390 return make_number (modifiers
| XINT (base
));
6392 else if (SYMBOLP (base
))
6393 return apply_modifiers (modifiers
, base
);
6396 error ("Invalid base event");
6401 /* Try to recognize SYMBOL as a modifier name.
6402 Return the modifier flag bit, or 0 if not recognized. */
6405 parse_solitary_modifier (symbol
)
6408 Lisp_Object name
= SYMBOL_NAME (symbol
);
6410 switch (SREF (name
, 0))
6412 #define SINGLE_LETTER_MOD(BIT) \
6413 if (SBYTES (name) == 1) \
6416 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6417 if (LEN == SBYTES (name) \
6418 && ! strncmp (SDATA (name), NAME, LEN)) \
6422 SINGLE_LETTER_MOD (alt_modifier
);
6426 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6430 SINGLE_LETTER_MOD (ctrl_modifier
);
6434 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6435 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6439 SINGLE_LETTER_MOD (hyper_modifier
);
6443 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6447 SINGLE_LETTER_MOD (meta_modifier
);
6451 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6455 SINGLE_LETTER_MOD (shift_modifier
);
6459 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6460 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6461 SINGLE_LETTER_MOD (super_modifier
);
6465 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6466 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6467 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6471 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6474 #undef SINGLE_LETTER_MOD
6475 #undef MULTI_LETTER_MOD
6481 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6482 Such a list is not valid as an event,
6483 but it can be a Lucid-style event type list. */
6486 lucid_event_type_list_p (object
)
6491 if (! CONSP (object
))
6494 if (EQ (XCAR (object
), Qhelp_echo
)
6495 || EQ (XCAR (object
), Qvertical_line
)
6496 || EQ (XCAR (object
), Qmode_line
)
6497 || EQ (XCAR (object
), Qheader_line
))
6500 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6504 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6511 /* Store into *addr a value nonzero if terminal input chars are available.
6512 Serves the purpose of ioctl (0, FIONREAD, addr)
6513 but works even if FIONREAD does not exist.
6514 (In fact, this may actually read some input.)
6516 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
6517 If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
6520 get_filtered_input_pending (addr
, do_timers_now
, filter_events
)
6525 /* First of all, have we already counted some input? */
6526 *addr
= (!NILP (Vquit_flag
)
6527 || readable_filtered_events (do_timers_now
, filter_events
));
6529 /* If input is being read as it arrives, and we have none, there is none. */
6530 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6533 /* Try to read some input and see how much we get. */
6535 *addr
= (!NILP (Vquit_flag
)
6536 || readable_filtered_events (do_timers_now
, filter_events
));
6539 /* Store into *addr a value nonzero if terminal input chars are available.
6540 Serves the purpose of ioctl (0, FIONREAD, addr)
6541 but works even if FIONREAD does not exist.
6542 (In fact, this may actually read some input.)
6544 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
6547 get_input_pending (addr
, do_timers_now
)
6551 get_filtered_input_pending (addr
, do_timers_now
, 0);
6554 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6557 gobble_input (expected
)
6562 if (interrupt_input
)
6565 mask
= sigblock (sigmask (SIGIO
));
6566 read_avail_input (expected
);
6570 #ifdef POLL_FOR_INPUT
6571 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
6574 mask
= sigblock (sigmask (SIGALRM
));
6575 read_avail_input (expected
);
6581 read_avail_input (expected
);
6585 /* Put a BUFFER_SWITCH_EVENT in the buffer
6586 so that read_key_sequence will notice the new current buffer. */
6589 record_asynch_buffer_change ()
6591 struct input_event event
;
6595 event
.kind
= BUFFER_SWITCH_EVENT
;
6596 event
.frame_or_window
= Qnil
;
6600 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6601 The purpose of the event is to make read_key_sequence look up the
6602 keymaps again. If we aren't in read_key_sequence, we don't need one,
6603 and the event could cause trouble by messing up (input-pending-p). */
6604 tem
= Fwaiting_for_user_input_p ();
6608 /* We never need these events if we have no asynchronous subprocesses. */
6612 /* Make sure no interrupt happens while storing the event. */
6614 if (interrupt_input
)
6617 mask
= sigblock (sigmask (SIGIO
));
6618 kbd_buffer_store_event (&event
);
6625 kbd_buffer_store_event (&event
);
6632 /* Read any terminal input already buffered up by the system
6633 into the kbd_buffer, but do not wait.
6635 EXPECTED should be nonzero if the caller knows there is some input.
6637 Except on VMS, all input is read by this function.
6638 If interrupt_input is nonzero, this function MUST be called
6639 only when SIGIO is blocked.
6641 Returns the number of keyboard chars read, or -1 meaning
6642 this is a bad time to try to read input. */
6645 read_avail_input (expected
)
6651 if (read_socket_hook
)
6655 struct input_event hold_quit
;
6657 EVENT_INIT (hold_quit
);
6658 hold_quit
.kind
= NO_EVENT
;
6660 /* No need for FIONREAD or fcntl; just say don't wait. */
6661 while (nr
= (*read_socket_hook
) (input_fd
, expected
, &hold_quit
), nr
> 0)
6666 if (hold_quit
.kind
!= NO_EVENT
)
6667 kbd_buffer_store_event (&hold_quit
);
6671 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6672 the kbd_buffer can really hold. That may prevent loss
6673 of characters on some systems when input is stuffed at us. */
6674 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6677 /* Determine how many characters we should *try* to read. */
6680 #else /* not WINDOWSNT */
6682 n_to_read
= dos_keysns ();
6685 #else /* not MSDOS */
6687 /* Find out how much input is available. */
6688 if (ioctl (input_fd
, FIONREAD
, &n_to_read
) < 0)
6689 /* Formerly simply reported no input, but that sometimes led to
6690 a failure of Emacs to terminate.
6691 SIGHUP seems appropriate if we can't reach the terminal. */
6692 /* ??? Is it really right to send the signal just to this process
6693 rather than to the whole process group?
6694 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6696 if (! noninteractive
)
6697 kill (getpid (), SIGHUP
);
6703 if (n_to_read
> sizeof cbuf
)
6704 n_to_read
= sizeof cbuf
;
6705 #else /* no FIONREAD */
6706 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
6707 /* Read some input if available, but don't wait. */
6708 n_to_read
= sizeof cbuf
;
6709 fcntl (input_fd
, F_SETFL
, O_NDELAY
);
6714 #endif /* not MSDOS */
6715 #endif /* not WINDOWSNT */
6717 /* Now read; for one reason or another, this will not block.
6718 NREAD is set to the number of chars read. */
6722 cbuf
[0] = dos_keyread ();
6725 nread
= emacs_read (input_fd
, cbuf
, n_to_read
);
6727 /* POSIX infers that processes which are not in the session leader's
6728 process group won't get SIGHUP's at logout time. BSDI adheres to
6729 this part standard and returns -1 from read (0) with errno==EIO
6730 when the control tty is taken away.
6731 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6732 if (nread
== -1 && errno
== EIO
)
6734 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6735 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6736 This looks incorrect, but it isn't, because _BSD causes
6737 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6738 and that causes a value other than 0 when there is no input. */
6744 /* We used to retry the read if it was interrupted.
6745 But this does the wrong thing when O_NDELAY causes
6746 an EAGAIN error. Does anybody know of a situation
6747 where a retry is actually needed? */
6749 nread
< 0 && (errno
== EAGAIN
6763 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
6764 fcntl (input_fd
, F_SETFL
, 0);
6765 #endif /* USG or DGUX or CYGWIN */
6766 #endif /* no FIONREAD */
6767 for (i
= 0; i
< nread
; i
++)
6769 struct input_event buf
;
6771 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
6773 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
6774 buf
.modifiers
= meta_modifier
;
6779 buf
.frame_or_window
= selected_frame
;
6782 kbd_buffer_store_event (&buf
);
6783 /* Don't look at input that follows a C-g too closely.
6784 This reduces lossage due to autorepeat on C-g. */
6785 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
6786 && buf
.code
== quit_char
)
6793 #endif /* not VMS */
6796 handle_async_input ()
6799 extern int select_alarmed
;
6801 interrupt_input_pending
= 0;
6806 nread
= read_avail_input (1);
6807 /* -1 means it's not ok to read the input now.
6808 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6809 0 means there was no keyboard input available. */
6814 select_alarmed
= 1; /* Force the select emulator back to life */
6819 #ifdef SIGIO /* for entire page */
6820 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6823 input_available_signal (signo
)
6826 /* Must preserve main program's value of errno. */
6827 int old_errno
= errno
;
6829 #if defined (USG) && !defined (POSIX_SIGNALS)
6830 /* USG systems forget handlers when they are used;
6831 must reestablish each time */
6832 signal (signo
, input_available_signal
);
6839 if (input_available_clear_time
)
6840 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6843 interrupt_input_pending
= 1;
6845 handle_async_input ();
6855 /* Send ourselves a SIGIO.
6857 This function exists so that the UNBLOCK_INPUT macro in
6858 blockinput.h can have some way to take care of input we put off
6859 dealing with, without assuming that every file which uses
6860 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6862 reinvoke_input_signal ()
6865 handle_async_input ();
6871 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
6872 static Lisp_Object menu_bar_one_keymap_changed_items
;
6874 /* These variables hold the vector under construction within
6875 menu_bar_items and its subroutines, and the current index
6876 for storing into that vector. */
6877 static Lisp_Object menu_bar_items_vector
;
6878 static int menu_bar_items_index
;
6880 /* Return a vector of menu items for a menu bar, appropriate
6881 to the current buffer. Each item has three elements in the vector:
6884 OLD is an old vector we can optionally reuse, or nil. */
6887 menu_bar_items (old
)
6890 /* The number of keymaps we're scanning right now, and the number of
6891 keymaps we have allocated space for. */
6894 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6895 in the current keymaps, or nil where it is not a prefix. */
6898 Lisp_Object def
, tail
;
6907 struct gcpro gcpro1
;
6909 /* In order to build the menus, we need to call the keymap
6910 accessors. They all call QUIT. But this function is called
6911 during redisplay, during which a quit is fatal. So inhibit
6912 quitting while building the menus.
6913 We do this instead of specbind because (1) errors will clear it anyway
6914 and (2) this avoids risk of specpdl overflow. */
6915 oquit
= Vinhibit_quit
;
6919 menu_bar_items_vector
= old
;
6921 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
6922 menu_bar_items_index
= 0;
6924 GCPRO1 (menu_bar_items_vector
);
6926 /* Build our list of keymaps.
6927 If we recognize a function key and replace its escape sequence in
6928 keybuf with its symbol, or if the sequence starts with a mouse
6929 click and we need to switch buffers, we jump back here to rebuild
6930 the initial keymaps from the current buffer. */
6934 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6935 if (!NILP (Voverriding_local_map_menu_flag
))
6937 /* Yes, use them (if non-nil) as well as the global map. */
6938 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
6940 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
6941 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
6942 if (!NILP (Voverriding_local_map
))
6943 maps
[nmaps
++] = Voverriding_local_map
;
6947 /* No, so use major and minor mode keymaps and keymap property.
6948 Note that menu-bar bindings in the local-map and keymap
6949 properties may not work reliable, as they are only
6950 recognized when the menu-bar (or mode-line) is updated,
6951 which does not normally happen after every command. */
6954 nminor
= current_minor_maps (NULL
, &tmaps
);
6955 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
6957 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
6958 maps
[nmaps
++] = tem
;
6959 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
6961 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
6963 maps
[nmaps
++] = current_global_map
;
6966 /* Look up in each map the dummy prefix key `menu-bar'. */
6970 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
6971 if (!NILP (maps
[mapno
]))
6973 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
6977 menu_bar_one_keymap_changed_items
= Qnil
;
6978 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
6982 /* Move to the end those items that should be at the end. */
6984 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
6987 int end
= menu_bar_items_index
;
6989 for (i
= 0; i
< end
; i
+= 4)
6990 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6992 Lisp_Object tem0
, tem1
, tem2
, tem3
;
6993 /* Move the item at index I to the end,
6994 shifting all the others forward. */
6995 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
6996 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
6997 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
6998 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7000 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7001 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7002 (end
- i
- 4) * sizeof (Lisp_Object
));
7003 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7004 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7005 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7006 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7011 /* Add nil, nil, nil, nil at the end. */
7012 i
= menu_bar_items_index
;
7013 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7016 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7017 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7018 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7019 menu_bar_items_vector
= tem
;
7021 /* Add this item. */
7022 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7023 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7024 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7025 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7026 menu_bar_items_index
= i
;
7028 Vinhibit_quit
= oquit
;
7030 return menu_bar_items_vector
;
7033 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7034 If there's already an item for KEY, add this DEF to it. */
7036 Lisp_Object item_properties
;
7039 menu_bar_item (key
, item
, dummy1
, dummy2
)
7040 Lisp_Object key
, item
, dummy1
;
7043 struct gcpro gcpro1
;
7047 if (EQ (item
, Qundefined
))
7049 /* If a map has an explicit `undefined' as definition,
7050 discard any previously made menu bar item. */
7052 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7053 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7055 if (menu_bar_items_index
> i
+ 4)
7056 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7057 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7058 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7059 menu_bar_items_index
-= 4;
7063 /* If this keymap has already contributed to this KEY,
7064 don't contribute to it a second time. */
7065 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7066 if (!NILP (tem
) || NILP (item
))
7069 menu_bar_one_keymap_changed_items
7070 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7072 /* We add to menu_bar_one_keymap_changed_items before doing the
7073 parse_menu_item, so that if it turns out it wasn't a menu item,
7074 it still correctly hides any further menu item. */
7076 i
= parse_menu_item (item
, 0, 1);
7081 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7083 /* Find any existing item for this KEY. */
7084 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7085 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7088 /* If we did not find this KEY, add it at the end. */
7089 if (i
== menu_bar_items_index
)
7091 /* If vector is too small, get a bigger one. */
7092 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7095 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7096 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7097 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7098 menu_bar_items_vector
= tem
;
7101 /* Add this item. */
7102 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7103 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7104 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7105 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7106 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7107 menu_bar_items_index
= i
;
7109 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7113 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7114 /* If the new and the old items are not both keymaps,
7115 the lookup will only find `item'. */
7116 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7117 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7121 /* This is used as the handler when calling menu_item_eval_property. */
7123 menu_item_eval_property_1 (arg
)
7126 /* If we got a quit from within the menu computation,
7127 quit all the way out of it. This takes care of C-] in the debugger. */
7128 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7129 Fsignal (Qquit
, Qnil
);
7134 /* Evaluate an expression and return the result (or nil if something
7135 went wrong). Used to evaluate dynamic parts of menu items. */
7137 menu_item_eval_property (sexpr
)
7140 int count
= SPECPDL_INDEX ();
7142 specbind (Qinhibit_redisplay
, Qt
);
7143 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7144 menu_item_eval_property_1
);
7145 return unbind_to (count
, val
);
7148 /* This function parses a menu item and leaves the result in the
7149 vector item_properties.
7150 ITEM is a key binding, a possible menu item.
7151 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7152 evaluate dynamic expressions in the menu item.
7153 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7155 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7156 parse_menu_item returns true if the item is a menu item and false
7160 parse_menu_item (item
, notreal
, inmenubar
)
7162 int notreal
, inmenubar
;
7164 Lisp_Object def
, tem
, item_string
, start
;
7165 Lisp_Object cachelist
;
7167 Lisp_Object keyhint
;
7178 /* Create item_properties vector if necessary. */
7179 if (NILP (item_properties
))
7181 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7183 /* Initialize optional entries. */
7184 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7185 AREF (item_properties
, i
) = Qnil
;
7186 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7188 /* Save the item here to protect it from GC. */
7189 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7191 item_string
= XCAR (item
);
7195 if (STRINGP (item_string
))
7197 /* Old format menu item. */
7198 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7200 /* Maybe help string. */
7201 if (CONSP (item
) && STRINGP (XCAR (item
)))
7203 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7208 /* Maybe key binding cache. */
7209 if (CONSP (item
) && CONSP (XCAR (item
))
7210 && (NILP (XCAR (XCAR (item
)))
7211 || VECTORP (XCAR (XCAR (item
)))))
7213 cachelist
= XCAR (item
);
7217 /* This is the real definition--the function to run. */
7218 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7220 /* Get enable property, if any. */
7223 tem
= Fget (item
, Qmenu_enable
);
7225 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7228 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7230 /* New format menu item. */
7231 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7232 start
= XCDR (item
);
7235 /* We have a real binding. */
7236 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7238 item
= XCDR (start
);
7239 /* Is there a cache list with key equivalences. */
7240 if (CONSP (item
) && CONSP (XCAR (item
)))
7242 cachelist
= XCAR (item
);
7246 /* Parse properties. */
7247 while (CONSP (item
) && CONSP (XCDR (item
)))
7252 if (EQ (tem
, QCenable
))
7253 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7254 else if (EQ (tem
, QCvisible
) && !notreal
)
7256 /* If got a visible property and that evaluates to nil
7257 then ignore this item. */
7258 tem
= menu_item_eval_property (XCAR (item
));
7262 else if (EQ (tem
, QChelp
))
7263 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7264 else if (EQ (tem
, QCfilter
))
7266 else if (EQ (tem
, QCkey_sequence
))
7269 if (NILP (cachelist
)
7270 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7271 /* Be GC protected. Set keyhint to item instead of tem. */
7274 else if (EQ (tem
, QCkeys
))
7277 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7278 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7280 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7285 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7287 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7289 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7296 else if (inmenubar
|| !NILP (start
))
7300 return 0; /* not a menu item */
7302 /* If item string is not a string, evaluate it to get string.
7303 If we don't get a string, skip this item. */
7304 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7305 if (!(STRINGP (item_string
) || notreal
))
7307 item_string
= menu_item_eval_property (item_string
);
7308 if (!STRINGP (item_string
))
7310 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7313 /* If got a filter apply it on definition. */
7314 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7317 def
= menu_item_eval_property (list2 (XCAR (filter
),
7318 list2 (Qquote
, def
)));
7320 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7323 /* Enable or disable selection of item. */
7324 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7330 tem
= menu_item_eval_property (tem
);
7331 if (inmenubar
&& NILP (tem
))
7332 return 0; /* Ignore disabled items in menu bar. */
7333 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7336 /* If we got no definition, this item is just unselectable text which
7337 is OK in a submenu but not in the menubar. */
7339 return (inmenubar
? 0 : 1);
7341 /* See if this is a separate pane or a submenu. */
7342 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7343 tem
= get_keymap (def
, 0, 1);
7344 /* For a subkeymap, just record its details and exit. */
7347 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7348 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7352 /* At the top level in the menu bar, do likewise for commands also.
7353 The menu bar does not display equivalent key bindings anyway.
7354 ITEM_PROPERTY_DEF is already set up properly. */
7358 /* This is a command. See if there is an equivalent key binding. */
7359 if (NILP (cachelist
))
7361 /* We have to create a cachelist. */
7362 CHECK_IMPURE (start
);
7363 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
7364 cachelist
= XCAR (XCDR (start
));
7366 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7367 if (!NILP (keyhint
))
7369 XSETCAR (cachelist
, XCAR (keyhint
));
7372 else if (STRINGP (tem
))
7374 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
7375 XSETCAR (cachelist
, Qt
);
7379 tem
= XCAR (cachelist
);
7386 tem
= Fkey_binding (tem
, Qnil
, Qnil
);
7388 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7391 def
= XCAR (prefix
);
7392 prefix
= XCDR (prefix
);
7395 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7397 if (!update_menu_bindings
)
7399 else if (NILP (XCAR (cachelist
))) /* Have no saved key. */
7401 if (newcache
/* Always check first time. */
7402 /* Should we check everything when precomputing key
7404 /* If something had no key binding before, don't recheck it
7405 because that is too slow--except if we have a list of
7406 rebound commands in Vdefine_key_rebound_commands, do
7407 recheck any command that appears in that list. */
7408 || (CONSP (Vdefine_key_rebound_commands
)
7409 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
7412 /* We had a saved key. Is it still bound to the command? */
7415 /* If the command is an alias for another
7416 (such as lmenu.el set it up), check if the
7417 original command matches the cached command. */
7418 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7419 chkcache
= 1; /* Need to recompute key binding. */
7423 /* Recompute equivalent key binding. If the command is an alias
7424 for another (such as lmenu.el set it up), see if the original
7425 command name has equivalent keys. Otherwise look up the
7426 specified command itself. We don't try both, because that
7427 makes lmenu menus slow. */
7429 && SYMBOLP (XSYMBOL (def
)->function
)
7430 && ! NILP (Fget (def
, Qmenu_alias
)))
7431 def
= XSYMBOL (def
)->function
;
7432 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
7433 XSETCAR (cachelist
, tem
);
7436 XSETCDR (cachelist
, Qnil
);
7440 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
7442 tem
= XCAR (cachelist
);
7446 newcache
= chkcache
;
7449 tem
= Fkey_description (tem
, Qnil
);
7452 if (STRINGP (XCAR (prefix
)))
7453 tem
= concat2 (XCAR (prefix
), tem
);
7454 if (STRINGP (XCDR (prefix
)))
7455 tem
= concat2 (tem
, XCDR (prefix
));
7457 XSETCDR (cachelist
, tem
);
7461 tem
= XCDR (cachelist
);
7462 if (newcache
&& !NILP (tem
))
7464 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
7465 XSETCDR (cachelist
, tem
);
7468 /* If we only want to precompute equivalent key bindings, stop here. */
7472 /* If we have an equivalent key binding, use that. */
7473 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7475 /* Include this when menu help is implemented.
7476 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7477 if (!(NILP (tem) || STRINGP (tem)))
7479 tem = menu_item_eval_property (tem);
7482 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7486 /* Handle radio buttons or toggle boxes. */
7487 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7489 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7490 = menu_item_eval_property (tem
);
7497 /***********************************************************************
7499 ***********************************************************************/
7501 /* A vector holding tool bar items while they are parsed in function
7502 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7505 static Lisp_Object tool_bar_items_vector
;
7507 /* A vector holding the result of parse_tool_bar_item. Layout is like
7508 the one for a single item in tool_bar_items_vector. */
7510 static Lisp_Object tool_bar_item_properties
;
7512 /* Next free index in tool_bar_items_vector. */
7514 static int ntool_bar_items
;
7516 /* The symbols `tool-bar', and `:image'. */
7518 extern Lisp_Object Qtool_bar
;
7519 Lisp_Object QCimage
;
7521 /* Function prototypes. */
7523 static void init_tool_bar_items
P_ ((Lisp_Object
));
7524 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7525 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7526 static void append_tool_bar_item
P_ ((void));
7529 /* Return a vector of tool bar items for keymaps currently in effect.
7530 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7531 tool bar items found. */
7534 tool_bar_items (reuse
, nitems
)
7545 /* In order to build the menus, we need to call the keymap
7546 accessors. They all call QUIT. But this function is called
7547 during redisplay, during which a quit is fatal. So inhibit
7548 quitting while building the menus. We do this instead of
7549 specbind because (1) errors will clear it anyway and (2) this
7550 avoids risk of specpdl overflow. */
7551 oquit
= Vinhibit_quit
;
7554 /* Initialize tool_bar_items_vector and protect it from GC. */
7555 init_tool_bar_items (reuse
);
7557 /* Build list of keymaps in maps. Set nmaps to the number of maps
7560 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7561 if (!NILP (Voverriding_local_map_menu_flag
))
7563 /* Yes, use them (if non-nil) as well as the global map. */
7564 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7566 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7567 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7568 if (!NILP (Voverriding_local_map
))
7569 maps
[nmaps
++] = Voverriding_local_map
;
7573 /* No, so use major and minor mode keymaps and keymap property.
7574 Note that tool-bar bindings in the local-map and keymap
7575 properties may not work reliable, as they are only
7576 recognized when the tool-bar (or mode-line) is updated,
7577 which does not normally happen after every command. */
7580 nminor
= current_minor_maps (NULL
, &tmaps
);
7581 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7583 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7584 maps
[nmaps
++] = tem
;
7585 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7587 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7590 /* Add global keymap at the end. */
7591 maps
[nmaps
++] = current_global_map
;
7593 /* Process maps in reverse order and look up in each map the prefix
7595 for (i
= nmaps
- 1; i
>= 0; --i
)
7596 if (!NILP (maps
[i
]))
7600 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7605 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
7606 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
7608 Lisp_Object keydef
= XCAR (tail
);
7610 process_tool_bar_item (XCAR (keydef
), XCDR (keydef
));
7615 Vinhibit_quit
= oquit
;
7616 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7617 return tool_bar_items_vector
;
7621 /* Process the definition of KEY which is DEF. */
7624 process_tool_bar_item (key
, def
)
7625 Lisp_Object key
, def
;
7628 extern Lisp_Object Qundefined
;
7629 struct gcpro gcpro1
, gcpro2
;
7631 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7635 if (EQ (def
, Qundefined
))
7637 /* If a map has an explicit `undefined' as definition,
7638 discard any previously made item. */
7639 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
7641 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
7643 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
7645 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
7646 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
7647 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
7648 * sizeof (Lisp_Object
)));
7649 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
7654 else if (parse_tool_bar_item (key
, def
))
7655 /* Append a new tool bar item to tool_bar_items_vector. Accept
7656 more than one definition for the same key. */
7657 append_tool_bar_item ();
7663 /* Parse a tool bar item specification ITEM for key KEY and return the
7664 result in tool_bar_item_properties. Value is zero if ITEM is
7667 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7669 CAPTION is the caption of the item, If it's not a string, it is
7670 evaluated to get a string.
7672 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7673 as binding are currently ignored.
7675 The following properties are recognized:
7679 FORM is evaluated and specifies whether the tool bar item is
7680 enabled or disabled.
7684 FORM is evaluated and specifies whether the tool bar item is visible.
7686 - `:filter FUNCTION'
7688 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
7689 result is stored as the new binding.
7691 - `:button (TYPE SELECTED)'
7693 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
7694 and specifies whether the button is selected (pressed) or not.
7698 IMAGES is either a single image specification or a vector of four
7699 image specifications. See enum tool_bar_item_images.
7701 - `:help HELP-STRING'.
7703 Gives a help string to display for the tool bar item. */
7706 parse_tool_bar_item (key
, item
)
7707 Lisp_Object key
, item
;
7709 /* Access slot with index IDX of vector tool_bar_item_properties. */
7710 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
7712 Lisp_Object filter
= Qnil
;
7713 Lisp_Object caption
;
7716 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
7717 Rule out items that aren't lists, don't start with
7718 `menu-item' or whose rest following `tool-bar-item' is not a
7721 || !EQ (XCAR (item
), Qmenu_item
)
7722 || (item
= XCDR (item
),
7726 /* Create tool_bar_item_properties vector if necessary. Reset it to
7728 if (VECTORP (tool_bar_item_properties
))
7730 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
7734 tool_bar_item_properties
7735 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
7738 PROP (TOOL_BAR_ITEM_KEY
) = key
;
7739 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
7741 /* Get the caption of the item. If the caption is not a string,
7742 evaluate it to get a string. If we don't get a string, skip this
7744 caption
= XCAR (item
);
7745 if (!STRINGP (caption
))
7747 caption
= menu_item_eval_property (caption
);
7748 if (!STRINGP (caption
))
7751 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
7753 /* Give up if rest following the caption is not a list. */
7758 /* Store the binding. */
7759 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
7762 /* Ignore cached key binding, if any. */
7763 if (CONSP (item
) && CONSP (XCAR (item
)))
7766 /* Process the rest of the properties. */
7767 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
7769 Lisp_Object key
, value
;
7772 value
= XCAR (XCDR (item
));
7774 if (EQ (key
, QCenable
))
7775 /* `:enable FORM'. */
7776 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
7777 else if (EQ (key
, QCvisible
))
7779 /* `:visible FORM'. If got a visible property and that
7780 evaluates to nil then ignore this item. */
7781 if (NILP (menu_item_eval_property (value
)))
7784 else if (EQ (key
, QChelp
))
7785 /* `:help HELP-STRING'. */
7786 PROP (TOOL_BAR_ITEM_HELP
) = value
;
7787 else if (EQ (key
, QCfilter
))
7788 /* ':filter FORM'. */
7790 else if (EQ (key
, QCbutton
) && CONSP (value
))
7792 /* `:button (TYPE . SELECTED)'. */
7793 Lisp_Object type
, selected
;
7795 type
= XCAR (value
);
7796 selected
= XCDR (value
);
7797 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7799 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
7800 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
7803 else if (EQ (key
, QCimage
)
7805 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
7806 /* Value is either a single image specification or a vector
7807 of 4 such specifications for the different button states. */
7808 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
7811 /* If got a filter apply it on binding. */
7813 PROP (TOOL_BAR_ITEM_BINDING
)
7814 = menu_item_eval_property (list2 (filter
,
7816 PROP (TOOL_BAR_ITEM_BINDING
))));
7818 /* See if the binding is a keymap. Give up if it is. */
7819 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
7822 /* Enable or disable selection of item. */
7823 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
7824 PROP (TOOL_BAR_ITEM_ENABLED_P
)
7825 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7827 /* Handle radio buttons or toggle boxes. */
7828 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
7829 PROP (TOOL_BAR_ITEM_SELECTED_P
)
7830 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7838 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7839 that can be reused. */
7842 init_tool_bar_items (reuse
)
7845 if (VECTORP (reuse
))
7846 tool_bar_items_vector
= reuse
;
7848 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
7849 ntool_bar_items
= 0;
7853 /* Append parsed tool bar item properties from
7854 tool_bar_item_properties */
7857 append_tool_bar_item ()
7859 Lisp_Object
*to
, *from
;
7861 /* Enlarge tool_bar_items_vector if necessary. */
7862 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
7863 >= XVECTOR (tool_bar_items_vector
)->size
)
7865 Lisp_Object new_vector
;
7866 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
7868 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
7869 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
7870 XVECTOR (new_vector
)->contents
,
7871 old_size
* sizeof (Lisp_Object
));
7872 tool_bar_items_vector
= new_vector
;
7875 /* Append entries from tool_bar_item_properties to the end of
7876 tool_bar_items_vector. */
7877 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
7878 from
= XVECTOR (tool_bar_item_properties
)->contents
;
7879 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
7880 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
7887 /* Read a character using menus based on maps in the array MAPS.
7888 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7889 Return t if we displayed a menu but the user rejected it.
7891 PREV_EVENT is the previous input event, or nil if we are reading
7892 the first event of a key sequence.
7894 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7895 if we used a mouse menu to read the input, or zero otherwise. If
7896 USED_MOUSE_MENU is null, we don't dereference it.
7898 The prompting is done based on the prompt-string of the map
7899 and the strings associated with various map elements.
7901 This can be done with X menus or with menus put in the minibuf.
7902 These are done in different ways, depending on how the input will be read.
7903 Menus using X are done after auto-saving in read-char, getting the input
7904 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7905 and do auto-saving in the inner call of read_char. */
7908 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
7911 Lisp_Object prev_event
;
7912 int *used_mouse_menu
;
7915 register Lisp_Object name
= Qnil
;
7917 if (used_mouse_menu
)
7918 *used_mouse_menu
= 0;
7920 /* Use local over global Menu maps */
7922 if (! menu_prompting
)
7925 /* Optionally disregard all but the global map. */
7926 if (inhibit_local_menu_bar_menus
)
7928 maps
+= (nmaps
- 1);
7932 /* Get the menu name from the first map that has one (a prompt string). */
7933 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7935 name
= Fkeymap_prompt (maps
[mapno
]);
7940 /* If we don't have any menus, just read a character normally. */
7941 if (!STRINGP (name
))
7945 /* If we got to this point via a mouse click,
7946 use a real menu for mouse selection. */
7947 if (EVENT_HAS_PARAMETERS (prev_event
)
7948 && !EQ (XCAR (prev_event
), Qmenu_bar
)
7949 && !EQ (XCAR (prev_event
), Qtool_bar
))
7951 /* Display the menu and get the selection. */
7952 Lisp_Object
*realmaps
7953 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
7957 /* Use the maps that are not nil. */
7958 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7959 if (!NILP (maps
[mapno
]))
7960 realmaps
[nmaps1
++] = maps
[mapno
];
7962 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
7967 record_menu_key (XCAR (value
));
7969 /* If we got multiple events, unread all but
7971 There is no way to prevent those unread events
7972 from showing up later in last_nonmenu_event.
7973 So turn symbol and integer events into lists,
7974 to indicate that they came from a mouse menu,
7975 so that when present in last_nonmenu_event
7976 they won't confuse things. */
7977 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
7979 record_menu_key (XCAR (tem
));
7980 if (SYMBOLP (XCAR (tem
))
7981 || INTEGERP (XCAR (tem
)))
7982 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
7985 /* If we got more than one event, put all but the first
7986 onto this list to be read later.
7987 Return just the first event now. */
7988 Vunread_command_events
7989 = nconc2 (XCDR (value
), Vunread_command_events
);
7990 value
= XCAR (value
);
7992 else if (NILP (value
))
7994 if (used_mouse_menu
)
7995 *used_mouse_menu
= 1;
7998 #endif /* HAVE_MENUS */
8002 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8003 We make this bigger when necessary, and never free it. */
8004 static char *read_char_minibuf_menu_text
;
8005 /* Size of that buffer. */
8006 static int read_char_minibuf_menu_width
;
8009 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8015 register Lisp_Object name
;
8017 /* FIXME: Use the minibuffer's frame width. */
8018 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8021 Lisp_Object rest
, vector
;
8027 if (! menu_prompting
)
8030 /* Make sure we have a big enough buffer for the menu text. */
8031 if (read_char_minibuf_menu_text
== 0)
8033 read_char_minibuf_menu_width
= width
+ 4;
8034 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8036 else if (width
+ 4 > read_char_minibuf_menu_width
)
8038 read_char_minibuf_menu_width
= width
+ 4;
8039 read_char_minibuf_menu_text
8040 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8042 menu
= read_char_minibuf_menu_text
;
8044 /* Get the menu name from the first map that has one (a prompt string). */
8045 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8047 name
= Fkeymap_prompt (maps
[mapno
]);
8052 /* If we don't have any menus, just read a character normally. */
8053 if (!STRINGP (name
))
8056 /* Prompt string always starts with map's prompt, and a space. */
8057 strcpy (menu
, SDATA (name
));
8058 nlength
= SBYTES (name
);
8059 menu
[nlength
++] = ':';
8060 menu
[nlength
++] = ' ';
8063 /* Start prompting at start of first map. */
8067 /* Present the documented bindings, a line at a time. */
8074 Lisp_Object orig_defn_macro
;
8076 /* Loop over elements of map. */
8081 /* If reached end of map, start at beginning of next map. */
8085 /* At end of last map, wrap around to first map if just starting,
8086 or end this line if already have something on it. */
8090 if (notfirst
|| nobindings
) break;
8095 /* Look at the next element of the map. */
8097 elt
= XVECTOR (vector
)->contents
[idx
];
8099 elt
= Fcar_safe (rest
);
8101 if (idx
< 0 && VECTORP (elt
))
8103 /* If we found a dense table in the keymap,
8104 advanced past it, but start scanning its contents. */
8105 rest
= Fcdr_safe (rest
);
8111 /* An ordinary element. */
8112 Lisp_Object event
, tem
;
8116 event
= Fcar_safe (elt
); /* alist */
8117 elt
= Fcdr_safe (elt
);
8121 XSETINT (event
, idx
); /* vector */
8124 /* Ignore the element if it has no prompt string. */
8125 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8127 /* 1 if the char to type matches the string. */
8129 Lisp_Object upcased_event
, downcased_event
;
8130 Lisp_Object desc
= Qnil
;
8132 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8134 upcased_event
= Fupcase (event
);
8135 downcased_event
= Fdowncase (event
);
8136 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8137 || XINT (downcased_event
) == SREF (s
, 0));
8139 desc
= Fsingle_key_description (event
, Qnil
);
8141 #if 0 /* It is redundant to list the equivalent key bindings because
8142 the prefix is what the user has already typed. */
8144 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8146 /* Insert equivalent keybinding. */
8147 s
= concat2 (s
, tem
);
8150 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8151 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8153 /* Insert button prefix. */
8154 Lisp_Object selected
8155 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8156 if (EQ (tem
, QCradio
))
8157 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8159 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8160 s
= concat2 (tem
, s
);
8164 /* If we have room for the prompt string, add it to this line.
8165 If this is the first on the line, always add it. */
8166 if ((SCHARS (s
) + i
+ 2
8167 + (char_matches
? 0 : SCHARS (desc
) + 3))
8173 /* Punctuate between strings. */
8176 strcpy (menu
+ i
, ", ");
8182 /* If the char to type doesn't match the string's
8183 first char, explicitly show what char to type. */
8186 /* Add as much of string as fits. */
8187 thiswidth
= SCHARS (desc
);
8188 if (thiswidth
+ i
> width
)
8189 thiswidth
= width
- i
;
8190 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8192 strcpy (menu
+ i
, " = ");
8196 /* Add as much of string as fits. */
8197 thiswidth
= SCHARS (s
);
8198 if (thiswidth
+ i
> width
)
8199 thiswidth
= width
- i
;
8200 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8206 /* If this element does not fit, end the line now,
8207 and save the element for the next line. */
8208 strcpy (menu
+ i
, "...");
8213 /* Move past this element. */
8214 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8215 /* Handle reaching end of dense table. */
8220 rest
= Fcdr_safe (rest
);
8224 /* Prompt with that and read response. */
8225 message2_nolog (menu
, strlen (menu
),
8226 ! NILP (current_buffer
->enable_multibyte_characters
));
8228 /* Make believe its not a keyboard macro in case the help char
8229 is pressed. Help characters are not recorded because menu prompting
8230 is not used on replay.
8232 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8233 current_kboard
->defining_kbd_macro
= Qnil
;
8235 obj
= read_char (commandflag
, 0, 0, Qt
, 0);
8236 while (BUFFERP (obj
));
8237 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8239 if (!INTEGERP (obj
))
8244 if (! EQ (obj
, menu_prompt_more_char
)
8245 && (!INTEGERP (menu_prompt_more_char
)
8246 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8248 if (!NILP (current_kboard
->defining_kbd_macro
))
8249 store_kbd_macro_char (obj
);
8252 /* Help char - go round again */
8256 /* Reading key sequences. */
8258 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8259 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8260 keymap, or nil otherwise. Return the index of the first keymap in
8261 which KEY has any binding, or NMAPS if no map has a binding.
8263 If KEY is a meta ASCII character, treat it like meta-prefix-char
8264 followed by the corresponding non-meta character. Keymaps in
8265 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8268 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8271 NEXT may be the same array as CURRENT. */
8274 follow_key (key
, nmaps
, current
, defs
, next
)
8276 Lisp_Object
*current
, *defs
, *next
;
8279 int i
, first_binding
;
8281 first_binding
= nmaps
;
8282 for (i
= nmaps
- 1; i
>= 0; i
--)
8284 if (! NILP (current
[i
]))
8286 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8287 if (! NILP (defs
[i
]))
8294 /* Given the set of bindings we've found, produce the next set of maps. */
8295 if (first_binding
< nmaps
)
8296 for (i
= 0; i
< nmaps
; i
++)
8297 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8299 return first_binding
;
8302 /* Structure used to keep track of partial application of key remapping
8303 such as Vfunction_key_map and Vkey_translation_map. */
8304 typedef struct keyremap
8306 Lisp_Object map
, parent
;
8310 /* Lookup KEY in MAP.
8311 MAP is a keymap mapping keys to key vectors or functions.
8312 If the mapping is a function and DO_FUNCTION is non-zero, then
8313 the function is called with PROMPT as parameter and its return
8314 value is used as the return value of this function (after checking
8315 that it is indeed a vector). */
8318 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8319 Lisp_Object map
, key
, prompt
;
8324 next
= access_keymap (map
, key
, 1, 0, 1);
8326 /* Handle symbol with autoload definition. */
8327 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8328 && CONSP (XSYMBOL (next
)->function
)
8329 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8330 do_autoload (XSYMBOL (next
)->function
, next
);
8332 /* Handle a symbol whose function definition is a keymap
8334 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8335 && (!NILP (Farrayp (XSYMBOL (next
)->function
))
8336 || KEYMAPP (XSYMBOL (next
)->function
)))
8337 next
= XSYMBOL (next
)->function
;
8339 /* If the keymap gives a function, not an
8340 array, then call the function with one arg and use
8341 its value instead. */
8342 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8347 next
= call1 (next
, prompt
);
8348 /* If the function returned something invalid,
8349 barf--don't ignore it.
8350 (To ignore it safely, we would need to gcpro a bunch of
8351 other variables.) */
8352 if (! (VECTORP (next
) || STRINGP (next
)))
8353 error ("Function %s returns invalid key sequence", tem
);
8358 /* Do one step of the key remapping used for function-key-map and
8359 key-translation-map:
8360 KEYBUF is the buffer holding the input events.
8361 BUFSIZE is its maximum size.
8362 FKEY is a pointer to the keyremap structure to use.
8363 INPUT is the index of the last element in KEYBUF.
8364 DOIT if non-zero says that the remapping can actually take place.
8365 DIFF is used to return the number of keys added/removed by the remapping.
8366 PARENT is the root of the keymap.
8367 PROMPT is the prompt to use if the remapping happens through a function.
8368 The return value is non-zero if the remapping actually took place. */
8371 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
8372 Lisp_Object
*keybuf
, prompt
;
8374 int input
, doit
, *diff
, bufsize
;
8376 Lisp_Object next
, key
;
8378 key
= keybuf
[fkey
->end
++];
8379 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8381 /* If keybuf[fkey->start..fkey->end] is bound in the
8382 map and we're in a position to do the key remapping, replace it with
8383 the binding and restart with fkey->start at the end. */
8384 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8386 int len
= XFASTINT (Flength (next
));
8389 *diff
= len
- (fkey
->end
- fkey
->start
);
8391 if (input
+ *diff
>= bufsize
)
8392 error ("Key sequence too long");
8394 /* Shift the keys that follow fkey->end. */
8396 for (i
= fkey
->end
; i
< input
; i
++)
8397 keybuf
[i
+ *diff
] = keybuf
[i
];
8399 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8400 keybuf
[i
+ *diff
] = keybuf
[i
];
8401 /* Overwrite the old keys with the new ones. */
8402 for (i
= 0; i
< len
; i
++)
8403 keybuf
[fkey
->start
+ i
]
8404 = Faref (next
, make_number (i
));
8406 fkey
->start
= fkey
->end
+= *diff
;
8407 fkey
->map
= fkey
->parent
;
8412 fkey
->map
= get_keymap (next
, 0, 1);
8414 /* If we no longer have a bound suffix, try a new position for
8416 if (!CONSP (fkey
->map
))
8418 fkey
->end
= ++fkey
->start
;
8419 fkey
->map
= fkey
->parent
;
8424 /* Read a sequence of keys that ends with a non prefix character,
8425 storing it in KEYBUF, a buffer of size BUFSIZE.
8427 Return the length of the key sequence stored.
8428 Return -1 if the user rejected a command menu.
8430 Echo starting immediately unless `prompt' is 0.
8432 Where a key sequence ends depends on the currently active keymaps.
8433 These include any minor mode keymaps active in the current buffer,
8434 the current buffer's local map, and the global map.
8436 If a key sequence has no other bindings, we check Vfunction_key_map
8437 to see if some trailing subsequence might be the beginning of a
8438 function key's sequence. If so, we try to read the whole function
8439 key, and substitute its symbolic name into the key sequence.
8441 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8442 `double-' events into similar click events, if that would make them
8443 bound. We try to turn `triple-' events first into `double-' events,
8446 If we get a mouse click in a mode line, vertical divider, or other
8447 non-text area, we treat the click as if it were prefixed by the
8448 symbol denoting that area - `mode-line', `vertical-line', or
8451 If the sequence starts with a mouse click, we read the key sequence
8452 with respect to the buffer clicked on, not the current buffer.
8454 If the user switches frames in the midst of a key sequence, we put
8455 off the switch-frame event until later; the next call to
8456 read_char will return it.
8458 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8459 from the selected window's buffer. */
8462 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
8463 can_return_switch_frame
, fix_current_buffer
)
8464 Lisp_Object
*keybuf
;
8467 int dont_downcase_last
;
8468 int can_return_switch_frame
;
8469 int fix_current_buffer
;
8471 volatile Lisp_Object from_string
;
8472 volatile int count
= SPECPDL_INDEX ();
8474 /* How many keys there are in the current key sequence. */
8477 /* The length of the echo buffer when we started reading, and
8478 the length of this_command_keys when we started reading. */
8479 volatile int echo_start
;
8480 volatile int keys_start
;
8482 /* The number of keymaps we're scanning right now, and the number of
8483 keymaps we have allocated space for. */
8485 volatile int nmaps_allocated
= 0;
8487 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8488 the current keymaps. */
8489 Lisp_Object
*volatile defs
= NULL
;
8491 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8492 in the current keymaps, or nil where it is not a prefix. */
8493 Lisp_Object
*volatile submaps
= NULL
;
8495 /* The local map to start out with at start of key sequence. */
8496 volatile Lisp_Object orig_local_map
;
8498 /* The map from the `keymap' property to start out with at start of
8500 volatile Lisp_Object orig_keymap
;
8502 /* 1 if we have already considered switching to the local-map property
8503 of the place where a mouse click occurred. */
8504 volatile int localized_local_map
= 0;
8506 /* The index in defs[] of the first keymap that has a binding for
8507 this key sequence. In other words, the lowest i such that
8508 defs[i] is non-nil. */
8509 volatile int first_binding
;
8510 /* Index of the first key that has no binding.
8511 It is useless to try fkey.start larger than that. */
8512 volatile int first_unbound
;
8514 /* If t < mock_input, then KEYBUF[t] should be read as the next
8517 We use this to recover after recognizing a function key. Once we
8518 realize that a suffix of the current key sequence is actually a
8519 function key's escape sequence, we replace the suffix with the
8520 function key's binding from Vfunction_key_map. Now keybuf
8521 contains a new and different key sequence, so the echo area,
8522 this_command_keys, and the submaps and defs arrays are wrong. In
8523 this situation, we set mock_input to t, set t to 0, and jump to
8524 restart_sequence; the loop will read keys from keybuf up until
8525 mock_input, thus rebuilding the state; and then it will resume
8526 reading characters from the keyboard. */
8527 volatile int mock_input
= 0;
8529 /* If the sequence is unbound in submaps[], then
8530 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8531 and fkey.map is its binding.
8533 These might be > t, indicating that all function key scanning
8534 should hold off until t reaches them. We do this when we've just
8535 recognized a function key, to avoid searching for the function
8536 key's again in Vfunction_key_map. */
8537 volatile keyremap fkey
;
8539 /* Likewise, for key_translation_map. */
8540 volatile keyremap keytran
;
8542 /* If we receive a `switch-frame' or `select-window' event in the middle of
8543 a key sequence, we put it off for later.
8544 While we're reading, we keep the event here. */
8545 volatile Lisp_Object delayed_switch_frame
;
8547 /* See the comment below... */
8548 #if defined (GOBBLE_FIRST_EVENT)
8549 Lisp_Object first_event
;
8552 volatile Lisp_Object original_uppercase
;
8553 volatile int original_uppercase_position
= -1;
8555 /* Gets around Microsoft compiler limitations. */
8558 struct buffer
*starting_buffer
;
8560 /* List of events for which a fake prefix key has been generated. */
8561 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
8563 #if defined (GOBBLE_FIRST_EVENT)
8567 struct gcpro gcpro1
;
8569 GCPRO1 (fake_prefixed_keys
);
8570 raw_keybuf_count
= 0;
8572 last_nonmenu_event
= Qnil
;
8574 delayed_switch_frame
= Qnil
;
8575 fkey
.map
= fkey
.parent
= Vfunction_key_map
;
8576 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
8577 /* If there is no translation-map, turn off scanning. */
8578 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
8579 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
8584 echo_prompt (prompt
);
8585 else if (cursor_in_echo_area
8586 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8587 && NILP (Fzerop (Vecho_keystrokes
)))
8588 /* This doesn't put in a dash if the echo buffer is empty, so
8589 you don't always see a dash hanging out in the minibuffer. */
8593 /* Record the initial state of the echo area and this_command_keys;
8594 we will need to restore them if we replay a key sequence. */
8596 echo_start
= echo_length ();
8597 keys_start
= this_command_key_count
;
8598 this_single_command_key_start
= keys_start
;
8600 #if defined (GOBBLE_FIRST_EVENT)
8601 /* This doesn't quite work, because some of the things that read_char
8602 does cannot safely be bypassed. It seems too risky to try to make
8605 /* Read the first char of the sequence specially, before setting
8606 up any keymaps, in case a filter runs and switches buffers on us. */
8607 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
8609 #endif /* GOBBLE_FIRST_EVENT */
8611 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8612 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8615 /* We jump here when the key sequence has been thoroughly changed, and
8616 we need to rescan it starting from the beginning. When we jump here,
8617 keybuf[0..mock_input] holds the sequence we should reread. */
8620 starting_buffer
= current_buffer
;
8621 first_unbound
= bufsize
+ 1;
8623 /* Build our list of keymaps.
8624 If we recognize a function key and replace its escape sequence in
8625 keybuf with its symbol, or if the sequence starts with a mouse
8626 click and we need to switch buffers, we jump back here to rebuild
8627 the initial keymaps from the current buffer. */
8630 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
8631 || !NILP (Voverriding_local_map
))
8633 if (3 > nmaps_allocated
)
8635 submaps
= (Lisp_Object
*) alloca (3 * sizeof (submaps
[0]));
8636 defs
= (Lisp_Object
*) alloca (3 * sizeof (defs
[0]));
8637 nmaps_allocated
= 3;
8639 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8640 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8641 if (!NILP (Voverriding_local_map
))
8642 submaps
[nmaps
++] = Voverriding_local_map
;
8650 nminor
= current_minor_maps (0, &maps
);
8651 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
8653 if (total
> nmaps_allocated
)
8655 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
8656 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
8657 nmaps_allocated
= total
;
8660 if (!NILP (orig_keymap
))
8661 submaps
[nmaps
++] = orig_keymap
;
8663 bcopy (maps
, (void *) (submaps
+ nmaps
),
8664 nminor
* sizeof (submaps
[0]));
8668 submaps
[nmaps
++] = orig_local_map
;
8670 submaps
[nmaps
++] = current_global_map
;
8672 /* Find an accurate initial value for first_binding. */
8673 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
8674 if (! NILP (submaps
[first_binding
]))
8677 /* Start from the beginning in keybuf. */
8680 /* These are no-ops the first time through, but if we restart, they
8681 revert the echo area and this_command_keys to their original state. */
8682 this_command_key_count
= keys_start
;
8683 if (INTERACTIVE
&& t
< mock_input
)
8684 echo_truncate (echo_start
);
8686 /* If the best binding for the current key sequence is a keymap, or
8687 we may be looking at a function key's escape sequence, keep on
8689 while (first_binding
< nmaps
8690 /* Keep reading as long as there's a prefix binding. */
8691 ? !NILP (submaps
[first_binding
])
8692 /* Don't return in the middle of a possible function key sequence,
8693 if the only bindings we found were via case conversion.
8694 Thus, if ESC O a has a function-key-map translation
8695 and ESC o has a binding, don't return after ESC O,
8696 so that we can translate ESC O plus the next character. */
8697 : (fkey
.start
< t
|| keytran
.start
< t
))
8700 int used_mouse_menu
= 0;
8702 /* Where the last real key started. If we need to throw away a
8703 key that has expanded into more than one element of keybuf
8704 (say, a mouse click on the mode line which is being treated
8705 as [mode-line (mouse-...)], then we backtrack to this point
8707 volatile int last_real_key_start
;
8709 /* These variables are analogous to echo_start and keys_start;
8710 while those allow us to restart the entire key sequence,
8711 echo_local_start and keys_local_start allow us to throw away
8713 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
8715 eassert (fkey
.end
== t
|| (fkey
.end
> t
&& fkey
.end
<= mock_input
));
8716 eassert (fkey
.start
<= fkey
.end
);
8717 eassert (keytran
.start
<= keytran
.end
);
8718 /* key-translation-map is applied *after* function-key-map. */
8719 eassert (keytran
.end
<= fkey
.start
);
8721 if (first_unbound
< fkey
.start
&& first_unbound
< keytran
.start
)
8722 { /* The prefix upto first_unbound has no binding and has
8723 no translation left to do either, so we know it's unbound.
8724 If we don't stop now, we risk staying here indefinitely
8725 (if the user keeps entering fkey or keytran prefixes
8726 like C-c ESC ESC ESC ESC ...) */
8728 for (i
= first_unbound
+ 1; i
< t
; i
++)
8729 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
8730 mock_input
= t
- first_unbound
- 1;
8731 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
8732 fkey
.map
= fkey
.parent
;
8733 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
8734 keytran
.map
= keytran
.parent
;
8735 goto replay_sequence
;
8739 error ("Key sequence too long");
8742 echo_local_start
= echo_length ();
8743 keys_local_start
= this_command_key_count
;
8744 local_first_binding
= first_binding
;
8747 /* These are no-ops, unless we throw away a keystroke below and
8748 jumped back up to replay_key; in that case, these restore the
8749 variables to their original state, allowing us to replay the
8751 if (INTERACTIVE
&& t
< mock_input
)
8752 echo_truncate (echo_local_start
);
8753 this_command_key_count
= keys_local_start
;
8754 first_binding
= local_first_binding
;
8756 /* By default, assume each event is "real". */
8757 last_real_key_start
= t
;
8759 /* Does mock_input indicate that we are re-reading a key sequence? */
8763 add_command_key (key
);
8764 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8765 && NILP (Fzerop (Vecho_keystrokes
)))
8769 /* If not, we should actually read a character. */
8774 KBOARD
*interrupted_kboard
= current_kboard
;
8775 struct frame
*interrupted_frame
= SELECTED_FRAME ();
8776 if (setjmp (wrong_kboard_jmpbuf
))
8778 if (!NILP (delayed_switch_frame
))
8780 interrupted_kboard
->kbd_queue
8781 = Fcons (delayed_switch_frame
,
8782 interrupted_kboard
->kbd_queue
);
8783 delayed_switch_frame
= Qnil
;
8786 interrupted_kboard
->kbd_queue
8787 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
8789 /* If the side queue is non-empty, ensure it begins with a
8790 switch-frame, so we'll replay it in the right context. */
8791 if (CONSP (interrupted_kboard
->kbd_queue
)
8792 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
8793 !(EVENT_HAS_PARAMETERS (key
)
8794 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
8798 XSETFRAME (frame
, interrupted_frame
);
8799 interrupted_kboard
->kbd_queue
8800 = Fcons (make_lispy_switch_frame (frame
),
8801 interrupted_kboard
->kbd_queue
);
8804 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8805 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8806 goto replay_sequence
;
8809 key
= read_char (NILP (prompt
), nmaps
,
8810 (Lisp_Object
*) submaps
, last_nonmenu_event
,
8814 /* read_char returns t when it shows a menu and the user rejects it.
8818 unbind_to (count
, Qnil
);
8823 /* read_char returns -1 at the end of a macro.
8824 Emacs 18 handles this by returning immediately with a
8825 zero, so that's what we'll do. */
8826 if (INTEGERP (key
) && XINT (key
) == -1)
8829 /* The Microsoft C compiler can't handle the goto that
8835 /* If the current buffer has been changed from under us, the
8836 keymap may have changed, so replay the sequence. */
8839 EMACS_TIME initial_idleness_start_time
;
8840 EMACS_SET_SECS_USECS (initial_idleness_start_time
,
8841 EMACS_SECS (timer_last_idleness_start_time
),
8842 EMACS_USECS (timer_last_idleness_start_time
));
8844 /* Resume idle state, using the same start-time as before. */
8845 timer_start_idle ();
8846 timer_idleness_start_time
= initial_idleness_start_time
;
8849 /* Reset the current buffer from the selected window
8850 in case something changed the former and not the latter.
8851 This is to be more consistent with the behavior
8852 of the command_loop_1. */
8853 if (fix_current_buffer
)
8855 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8857 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
8858 Fset_buffer (XWINDOW (selected_window
)->buffer
);
8861 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8862 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8863 goto replay_sequence
;
8866 /* If we have a quit that was typed in another frame, and
8867 quit_throw_to_read_char switched buffers,
8868 replay to get the right keymap. */
8870 && XINT (key
) == quit_char
8871 && current_buffer
!= starting_buffer
)
8874 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8878 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8879 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8880 goto replay_sequence
;
8885 if (EVENT_HAS_PARAMETERS (key
)
8886 /* Either a `switch-frame' or a `select-window' event. */
8887 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
8889 /* If we're at the beginning of a key sequence, and the caller
8890 says it's okay, go ahead and return this event. If we're
8891 in the midst of a key sequence, delay it until the end. */
8892 if (t
> 0 || !can_return_switch_frame
)
8894 delayed_switch_frame
= key
;
8900 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8903 /* Clicks in non-text areas get prefixed by the symbol
8904 in their CHAR-ADDRESS field. For example, a click on
8905 the mode line is prefixed by the symbol `mode-line'.
8907 Furthermore, key sequences beginning with mouse clicks
8908 are read using the keymaps of the buffer clicked on, not
8909 the current buffer. So we may have to switch the buffer
8912 When we turn one event into two events, we must make sure
8913 that neither of the two looks like the original--so that,
8914 if we replay the events, they won't be expanded again.
8915 If not for this, such reexpansion could happen either here
8916 or when user programs play with this-command-keys. */
8917 if (EVENT_HAS_PARAMETERS (key
))
8922 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
8923 if (EQ (kind
, Qmouse_click
))
8925 Lisp_Object window
, posn
;
8927 window
= POSN_WINDOW (EVENT_START (key
));
8928 posn
= POSN_POSN (EVENT_START (key
));
8931 || (!NILP (fake_prefixed_keys
)
8932 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
8934 /* We're looking a second time at an event for which
8935 we generated a fake prefix key. Set
8936 last_real_key_start appropriately. */
8938 last_real_key_start
= t
- 1;
8941 /* Key sequences beginning with mouse clicks are
8942 read using the keymaps in the buffer clicked on,
8943 not the current buffer. If we're at the
8944 beginning of a key sequence, switch buffers. */
8945 if (last_real_key_start
== 0
8947 && BUFFERP (XWINDOW (window
)->buffer
)
8948 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
8950 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8954 /* Arrange to go back to the original buffer once we're
8955 done reading the key sequence. Note that we can't
8956 use save_excursion_{save,restore} here, because they
8957 save point as well as the current buffer; we don't
8958 want to save point, because redisplay may change it,
8959 to accommodate a Fset_window_start or something. We
8960 don't want to do this at the top of the function,
8961 because we may get input from a subprocess which
8962 wants to change the selected window and stuff (say,
8964 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
8966 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8968 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
8969 orig_local_map
= get_local_map (PT
, current_buffer
,
8971 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8972 goto replay_sequence
;
8975 /* For a mouse click, get the local text-property keymap
8976 of the place clicked on, rather than point. */
8977 if (last_real_key_start
== 0
8978 && CONSP (XCDR (key
))
8979 && ! localized_local_map
)
8981 Lisp_Object map_here
, start
, pos
;
8983 localized_local_map
= 1;
8984 start
= EVENT_START (key
);
8986 if (CONSP (start
) && POSN_INBUFFER_P (start
))
8988 pos
= POSN_BUFFER_POSN (start
);
8990 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
8992 map_here
= get_local_map (XINT (pos
),
8993 current_buffer
, Qlocal_map
);
8994 if (!EQ (map_here
, orig_local_map
))
8996 orig_local_map
= map_here
;
9000 goto replay_sequence
;
9002 map_here
= get_local_map (XINT (pos
),
9003 current_buffer
, Qkeymap
);
9004 if (!EQ (map_here
, orig_keymap
))
9006 orig_keymap
= map_here
;
9010 goto replay_sequence
;
9016 /* Expand mode-line and scroll-bar events into two events:
9017 use posn as a fake prefix key. */
9019 && (NILP (fake_prefixed_keys
)
9020 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9022 if (t
+ 1 >= bufsize
)
9023 error ("Key sequence too long");
9026 keybuf
[t
+ 1] = key
;
9029 /* Record that a fake prefix key has been generated
9030 for KEY. Don't modify the event; this would
9031 prevent proper action when the event is pushed
9032 back into unread-command-events. */
9033 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9035 /* If on a mode line string with a local keymap,
9036 reconsider the key sequence with that keymap. */
9037 if (string
= POSN_STRING (EVENT_START (key
)),
9038 (CONSP (string
) && STRINGP (XCAR (string
))))
9040 Lisp_Object pos
, map
, map2
;
9042 pos
= XCDR (string
);
9043 string
= XCAR (string
);
9045 && XINT (pos
) < SCHARS (string
))
9047 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9049 orig_local_map
= map
;
9050 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9053 if (!NILP (map
) || !NILP (map2
))
9054 goto replay_sequence
;
9060 else if (NILP (from_string
)
9061 && (string
= POSN_STRING (EVENT_START (key
)),
9062 (CONSP (string
) && STRINGP (XCAR (string
)))))
9064 /* For a click on a string, i.e. overlay string or a
9065 string displayed via the `display' property,
9066 consider `local-map' and `keymap' properties of
9068 Lisp_Object pos
, map
, map2
;
9070 pos
= XCDR (string
);
9071 string
= XCAR (string
);
9073 && XINT (pos
) < SCHARS (string
))
9075 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9077 orig_local_map
= map
;
9078 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9082 if (!NILP (map
) || !NILP (map2
))
9084 from_string
= string
;
9085 goto replay_sequence
;
9090 else if (CONSP (XCDR (key
))
9091 && CONSP (EVENT_START (key
))
9092 && CONSP (XCDR (EVENT_START (key
))))
9096 posn
= POSN_POSN (EVENT_START (key
));
9097 /* Handle menu-bar events:
9098 insert the dummy prefix event `menu-bar'. */
9099 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9101 if (t
+ 1 >= bufsize
)
9102 error ("Key sequence too long");
9106 /* Zap the position in key, so we know that we've
9107 expanded it, and don't try to do so again. */
9108 POSN_SET_POSN (EVENT_START (key
),
9109 Fcons (posn
, Qnil
));
9112 goto replay_sequence
;
9114 else if (CONSP (posn
))
9116 /* We're looking at the second event of a
9117 sequence which we expanded before. Set
9118 last_real_key_start appropriately. */
9119 if (last_real_key_start
== t
&& t
> 0)
9120 last_real_key_start
= t
- 1;
9125 /* We have finally decided that KEY is something we might want
9127 first_binding
= (follow_key (key
,
9128 nmaps
- first_binding
,
9129 submaps
+ first_binding
,
9130 defs
+ first_binding
,
9131 submaps
+ first_binding
)
9134 /* If KEY wasn't bound, we'll try some fallbacks. */
9135 if (first_binding
< nmaps
)
9136 /* This is needed for the following scenario:
9137 event 0: a down-event that gets dropped by calling replay_key.
9138 event 1: some normal prefix like C-h.
9139 After event 0, first_unbound is 0, after event 1 fkey.start
9140 and keytran.start are both 1, so when we see that C-h is bound,
9141 we need to update first_unbound. */
9142 first_unbound
= max (t
+ 1, first_unbound
);
9147 /* Remember the position to put an upper bound on fkey.start. */
9148 first_unbound
= min (t
, first_unbound
);
9150 head
= EVENT_HEAD (key
);
9151 if (help_char_p (head
) && t
> 0)
9153 read_key_sequence_cmd
= Vprefix_help_command
;
9155 last_nonmenu_event
= key
;
9156 /* The Microsoft C compiler can't handle the goto that
9164 Lisp_Object breakdown
;
9167 breakdown
= parse_modifiers (head
);
9168 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9169 /* Attempt to reduce an unbound mouse event to a simpler
9170 event that is bound:
9171 Drags reduce to clicks.
9172 Double-clicks reduce to clicks.
9173 Triple-clicks reduce to double-clicks, then to clicks.
9174 Down-clicks are eliminated.
9175 Double-downs reduce to downs, then are eliminated.
9176 Triple-downs reduce to double-downs, then to downs,
9177 then are eliminated. */
9178 if (modifiers
& (down_modifier
| drag_modifier
9179 | double_modifier
| triple_modifier
))
9181 while (modifiers
& (down_modifier
| drag_modifier
9182 | double_modifier
| triple_modifier
))
9184 Lisp_Object new_head
, new_click
;
9185 if (modifiers
& triple_modifier
)
9186 modifiers
^= (double_modifier
| triple_modifier
);
9187 else if (modifiers
& double_modifier
)
9188 modifiers
&= ~double_modifier
;
9189 else if (modifiers
& drag_modifier
)
9190 modifiers
&= ~drag_modifier
;
9193 /* Dispose of this `down' event by simply jumping
9194 back to replay_key, to get another event.
9196 Note that if this event came from mock input,
9197 then just jumping back to replay_key will just
9198 hand it to us again. So we have to wipe out any
9201 We could delete keybuf[t] and shift everything
9202 after that to the left by one spot, but we'd also
9203 have to fix up any variable that points into
9204 keybuf, and shifting isn't really necessary
9207 Adding prefixes for non-textual mouse clicks
9208 creates two characters of mock input, and both
9209 must be thrown away. If we're only looking at
9210 the prefix now, we can just jump back to
9211 replay_key. On the other hand, if we've already
9212 processed the prefix, and now the actual click
9213 itself is giving us trouble, then we've lost the
9214 state of the keymaps we want to backtrack to, and
9215 we need to replay the whole sequence to rebuild
9218 Beyond that, only function key expansion could
9219 create more than two keys, but that should never
9220 generate mouse events, so it's okay to zero
9221 mock_input in that case too.
9223 FIXME: The above paragraph seems just plain
9224 wrong, if you consider things like
9225 xterm-mouse-mode. -stef
9227 Isn't this just the most wonderful code ever? */
9229 /* If mock_input > t + 1, the above simplification
9230 will actually end up dropping keys on the floor.
9231 This is probably OK for now, but even
9232 if mock_input <= t + 1, we need to adjust fkey
9234 Typical case [header-line down-mouse-N]:
9235 mock_input = 2, t = 1, fkey.end = 1,
9236 last_real_key_start = 0. */
9237 if (fkey
.end
> last_real_key_start
)
9239 fkey
.end
= fkey
.start
9240 = min (last_real_key_start
, fkey
.start
);
9241 fkey
.map
= fkey
.parent
;
9242 if (keytran
.end
> last_real_key_start
)
9244 keytran
.end
= keytran
.start
9245 = min (last_real_key_start
, keytran
.start
);
9246 keytran
.map
= keytran
.parent
;
9249 if (t
== last_real_key_start
)
9256 mock_input
= last_real_key_start
;
9257 goto replay_sequence
;
9262 = apply_modifiers (modifiers
, XCAR (breakdown
));
9264 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9266 /* Look for a binding for this new key. follow_key
9267 promises that it didn't munge submaps the
9268 last time we called it, since key was unbound. */
9270 = (follow_key (new_click
,
9271 nmaps
- local_first_binding
,
9272 submaps
+ local_first_binding
,
9273 defs
+ local_first_binding
,
9274 submaps
+ local_first_binding
)
9275 + local_first_binding
);
9277 /* If that click is bound, go for it. */
9278 if (first_binding
< nmaps
)
9283 /* Otherwise, we'll leave key set to the drag event. */
9290 /* Normally, last_nonmenu_event gets the previous key we read.
9291 But when a mouse popup menu is being used,
9292 we don't update last_nonmenu_event; it continues to hold the mouse
9293 event that preceded the first level of menu. */
9294 if (!used_mouse_menu
)
9295 last_nonmenu_event
= key
;
9297 /* Record what part of this_command_keys is the current key sequence. */
9298 this_single_command_key_start
= this_command_key_count
- t
;
9300 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
]))
9301 /* There is a binding and it's not a prefix.
9302 There is thus no function-key in this sequence.
9303 Moving fkey.start is important in this case to allow keytran.start
9304 to go over the sequence before we return (since we keep the
9305 invariant that keytran.end <= fkey.start). */
9308 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9311 /* If the sequence is unbound, see if we can hang a function key
9312 off the end of it. */
9313 /* Continue scan from fkey.end until we find a bound suffix. */
9314 while (fkey
.end
< t
)
9316 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9319 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9320 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9321 max (t
, mock_input
),
9322 /* If there's a binding (i.e.
9323 first_binding >= nmaps) we don't want
9324 to apply this function-key-mapping. */
9325 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9330 mock_input
= diff
+ max (t
, mock_input
);
9331 goto replay_sequence
;
9335 /* Look for this sequence in key-translation-map.
9336 Scan from keytran.end until we find a bound suffix. */
9337 while (keytran
.end
< fkey
.start
)
9339 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9342 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9343 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9348 mock_input
= diff
+ max (t
, mock_input
);
9349 /* Adjust the function-key-map counters. */
9353 goto replay_sequence
;
9357 /* If KEY is not defined in any of the keymaps,
9358 and cannot be part of a function key or translation,
9359 and is an upper case letter
9360 use the corresponding lower-case letter instead. */
9361 if (first_binding
>= nmaps
9362 && fkey
.start
>= t
&& keytran
.start
>= t
9364 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9365 && UPPERCASEP (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9366 || (XINT (key
) & shift_modifier
)))
9368 Lisp_Object new_key
;
9370 original_uppercase
= key
;
9371 original_uppercase_position
= t
- 1;
9373 if (XINT (key
) & shift_modifier
)
9374 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9376 XSETINT (new_key
, (DOWNCASE (XINT (key
) & ~CHAR_MODIFIER_MASK
)
9377 | (XINT (key
) & ~CHAR_MODIFIER_MASK
)));
9379 /* We have to do this unconditionally, regardless of whether
9380 the lower-case char is defined in the keymaps, because they
9381 might get translated through function-key-map. */
9382 keybuf
[t
- 1] = new_key
;
9383 mock_input
= max (t
, mock_input
);
9385 goto replay_sequence
;
9387 /* If KEY is not defined in any of the keymaps,
9388 and cannot be part of a function key or translation,
9389 and is a shifted function key,
9390 use the corresponding unshifted function key instead. */
9391 if (first_binding
>= nmaps
9392 && fkey
.start
>= t
&& keytran
.start
>= t
9395 Lisp_Object breakdown
;
9398 breakdown
= parse_modifiers (key
);
9399 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9400 if (modifiers
& shift_modifier
)
9402 Lisp_Object new_key
;
9404 original_uppercase
= key
;
9405 original_uppercase_position
= t
- 1;
9407 modifiers
&= ~shift_modifier
;
9408 new_key
= apply_modifiers (modifiers
,
9411 keybuf
[t
- 1] = new_key
;
9412 mock_input
= max (t
, mock_input
);
9413 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
9414 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
9416 goto replay_sequence
;
9422 read_key_sequence_cmd
= (first_binding
< nmaps
9423 ? defs
[first_binding
]
9426 unread_switch_frame
= delayed_switch_frame
;
9427 unbind_to (count
, Qnil
);
9429 /* Don't downcase the last character if the caller says don't.
9430 Don't downcase it if the result is undefined, either. */
9431 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9432 && t
- 1 == original_uppercase_position
)
9433 keybuf
[t
- 1] = original_uppercase
;
9435 /* Occasionally we fabricate events, perhaps by expanding something
9436 according to function-key-map, or by adding a prefix symbol to a
9437 mouse click in the scroll bar or modeline. In this cases, return
9438 the entire generated key sequence, even if we hit an unbound
9439 prefix or a definition before the end. This means that you will
9440 be able to push back the event properly, and also means that
9441 read-key-sequence will always return a logical unit.
9444 for (; t
< mock_input
; t
++)
9446 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9447 && NILP (Fzerop (Vecho_keystrokes
)))
9448 echo_char (keybuf
[t
]);
9449 add_command_key (keybuf
[t
]);
9458 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9459 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9460 The sequence is sufficient to specify a non-prefix command in the
9461 current local and global maps.
9463 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9464 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9465 as a continuation of the previous key.
9467 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9468 convert the last event to lower case. (Normally any upper case event
9469 is converted to lower case if the original event is undefined and the lower
9470 case equivalent is defined.) A non-nil value is appropriate for reading
9471 a key sequence to be defined.
9473 A C-g typed while in this function is treated like any other character,
9474 and `quit-flag' is not set.
9476 If the key sequence starts with a mouse click, then the sequence is read
9477 using the keymaps of the buffer of the window clicked in, not the buffer
9478 of the selected window as normal.
9480 `read-key-sequence' drops unbound button-down events, since you normally
9481 only care about the click or drag events which follow them. If a drag
9482 or multi-click event is unbound, but the corresponding click event would
9483 be bound, `read-key-sequence' turns the event into a click event at the
9484 drag's starting position. This means that you don't have to distinguish
9485 between click and drag, double, or triple events unless you want to.
9487 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9488 lines separating windows, and scroll bars with imaginary keys
9489 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9491 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9492 function will process a switch-frame event if the user switches frames
9493 before typing anything. If the user switches frames in the middle of a
9494 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9495 is nil, then the event will be put off until after the current key sequence.
9497 `read-key-sequence' checks `function-key-map' for function key
9498 sequences, where they wouldn't conflict with ordinary bindings. See
9499 `function-key-map' for more details.
9501 The optional fifth argument COMMAND-LOOP, if non-nil, means
9502 that this key sequence is being read by something that will
9503 read commands one after another. It should be nil if the caller
9504 will read just one key sequence. */)
9505 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9507 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9508 Lisp_Object can_return_switch_frame
, command_loop
;
9510 Lisp_Object keybuf
[30];
9512 struct gcpro gcpro1
;
9513 int count
= SPECPDL_INDEX ();
9516 CHECK_STRING (prompt
);
9519 specbind (Qinput_method_exit_on_first_char
,
9520 (NILP (command_loop
) ? Qt
: Qnil
));
9521 specbind (Qinput_method_use_echo_area
,
9522 (NILP (command_loop
) ? Qt
: Qnil
));
9524 bzero (keybuf
, sizeof keybuf
);
9526 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9528 if (NILP (continue_echo
))
9530 this_command_key_count
= 0;
9531 this_command_key_count_reset
= 0;
9532 this_single_command_key_start
= 0;
9535 #ifdef HAVE_X_WINDOWS
9536 if (display_hourglass_p
)
9537 cancel_hourglass ();
9540 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9541 prompt
, ! NILP (dont_downcase_last
),
9542 ! NILP (can_return_switch_frame
), 0);
9544 #if 0 /* The following is fine for code reading a key sequence and
9545 then proceeding with a lenghty computation, but it's not good
9546 for code reading keys in a loop, like an input method. */
9547 #ifdef HAVE_X_WINDOWS
9548 if (display_hourglass_p
)
9559 return unbind_to (count
, make_event_array (i
, keybuf
));
9562 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
9563 Sread_key_sequence_vector
, 1, 5, 0,
9564 doc
: /* Like `read-key-sequence' but always return a vector. */)
9565 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9567 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9568 Lisp_Object can_return_switch_frame
, command_loop
;
9570 Lisp_Object keybuf
[30];
9572 struct gcpro gcpro1
;
9573 int count
= SPECPDL_INDEX ();
9576 CHECK_STRING (prompt
);
9579 specbind (Qinput_method_exit_on_first_char
,
9580 (NILP (command_loop
) ? Qt
: Qnil
));
9581 specbind (Qinput_method_use_echo_area
,
9582 (NILP (command_loop
) ? Qt
: Qnil
));
9584 bzero (keybuf
, sizeof keybuf
);
9586 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9588 if (NILP (continue_echo
))
9590 this_command_key_count
= 0;
9591 this_command_key_count_reset
= 0;
9592 this_single_command_key_start
= 0;
9595 #ifdef HAVE_X_WINDOWS
9596 if (display_hourglass_p
)
9597 cancel_hourglass ();
9600 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9601 prompt
, ! NILP (dont_downcase_last
),
9602 ! NILP (can_return_switch_frame
), 0);
9604 #ifdef HAVE_X_WINDOWS
9605 if (display_hourglass_p
)
9615 return unbind_to (count
, Fvector (i
, keybuf
));
9618 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
9619 doc
: /* Execute CMD as an editor command.
9620 CMD must be a symbol that satisfies the `commandp' predicate.
9621 Optional second arg RECORD-FLAG non-nil
9622 means unconditionally put this command in `command-history'.
9623 Otherwise, that is done only if an arg is read using the minibuffer.
9624 The argument KEYS specifies the value to use instead of (this-command-keys)
9625 when reading the arguments; if it is nil, (this-command-keys) is used.
9626 The argument SPECIAL, if non-nil, means that this command is executing
9627 a special event, so ignore the prefix argument and don't clear it. */)
9628 (cmd
, record_flag
, keys
, special
)
9629 Lisp_Object cmd
, record_flag
, keys
, special
;
9631 register Lisp_Object final
;
9632 register Lisp_Object tem
;
9633 Lisp_Object prefixarg
;
9634 struct backtrace backtrace
;
9635 extern int debug_on_next_call
;
9637 debug_on_next_call
= 0;
9641 prefixarg
= current_kboard
->Vprefix_arg
;
9642 Vcurrent_prefix_arg
= prefixarg
;
9643 current_kboard
->Vprefix_arg
= Qnil
;
9650 tem
= Fget (cmd
, Qdisabled
);
9651 if (!NILP (tem
) && !NILP (Vrun_hooks
))
9653 tem
= Fsymbol_value (Qdisabled_command_hook
);
9655 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
9661 final
= Findirect_function (cmd
);
9663 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
9665 struct gcpro gcpro1
, gcpro2
;
9667 GCPRO2 (cmd
, prefixarg
);
9668 do_autoload (final
, cmd
);
9675 if (STRINGP (final
) || VECTORP (final
))
9677 /* If requested, place the macro in the command history. For
9678 other sorts of commands, call-interactively takes care of
9680 if (!NILP (record_flag
))
9683 = Fcons (Fcons (Qexecute_kbd_macro
,
9684 Fcons (final
, Fcons (prefixarg
, Qnil
))),
9687 /* Don't keep command history around forever. */
9688 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
9690 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
9692 XSETCDR (tem
, Qnil
);
9696 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
9699 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
9701 backtrace
.next
= backtrace_list
;
9702 backtrace_list
= &backtrace
;
9703 backtrace
.function
= &Qcall_interactively
;
9704 backtrace
.args
= &cmd
;
9705 backtrace
.nargs
= 1;
9706 backtrace
.evalargs
= 0;
9707 backtrace
.debug_on_exit
= 0;
9709 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
9711 backtrace_list
= backtrace
.next
;
9719 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
9721 doc
: /* Read function name, then read its arguments and call it. */)
9723 Lisp_Object prefixarg
;
9725 Lisp_Object function
;
9727 int saved_last_point_position
;
9728 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
9729 Lisp_Object bindings
, value
;
9730 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9732 saved_keys
= Fvector (this_command_key_count
,
9733 XVECTOR (this_command_keys
)->contents
);
9734 saved_last_point_position_buffer
= last_point_position_buffer
;
9735 saved_last_point_position
= last_point_position
;
9737 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
9739 if (EQ (prefixarg
, Qminus
))
9741 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
9742 strcpy (buf
, "C-u ");
9743 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
9744 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
9745 else if (INTEGERP (prefixarg
))
9746 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
9748 /* This isn't strictly correct if execute-extended-command
9749 is bound to anything else. Perhaps it should use
9750 this_command_keys? */
9751 strcat (buf
, "M-x ");
9753 /* Prompt with buf, and then read a string, completing from and
9754 restricting to the set of all defined commands. Don't provide
9755 any initial input. Save the command read on the extended-command
9757 function
= Fcompleting_read (build_string (buf
),
9758 Vobarray
, Qcommandp
,
9759 Qt
, Qnil
, Qextended_command_history
, Qnil
,
9762 if (STRINGP (function
) && SCHARS (function
) == 0)
9763 error ("No command name given");
9765 /* Set this_command_keys to the concatenation of saved_keys and
9766 function, followed by a RET. */
9771 this_command_key_count
= 0;
9772 this_command_key_count_reset
= 0;
9773 this_single_command_key_start
= 0;
9775 keys
= XVECTOR (saved_keys
)->contents
;
9776 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
9777 add_command_key (keys
[i
]);
9779 for (i
= 0; i
< SCHARS (function
); i
++)
9780 add_command_key (Faref (function
, make_number (i
)));
9782 add_command_key (make_number ('\015'));
9785 last_point_position
= saved_last_point_position
;
9786 last_point_position_buffer
= saved_last_point_position_buffer
;
9790 function
= Fintern (function
, Qnil
);
9791 current_kboard
->Vprefix_arg
= prefixarg
;
9792 Vthis_command
= function
;
9793 real_this_command
= function
;
9795 /* If enabled, show which key runs this command. */
9796 if (!NILP (Vsuggest_key_bindings
)
9797 && NILP (Vexecuting_macro
)
9798 && SYMBOLP (function
))
9799 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
9805 GCPRO2 (bindings
, value
);
9806 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
9808 /* If the command has a key binding, print it now. */
9809 if (!NILP (bindings
)
9810 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
9813 /* But first wait, and skip the message if there is input. */
9815 if (!NILP (echo_area_buffer
[0]))
9816 /* This command displayed something in the echo area;
9817 so wait a few seconds, then display our suggestion message. */
9818 delay_time
= (NUMBERP (Vsuggest_key_bindings
)
9819 ? XINT (Vsuggest_key_bindings
) : 2);
9821 /* This command left the echo area empty,
9822 so display our message immediately. */
9825 if (!NILP (Fsit_for (make_number (delay_time
), Qnil
, Qnil
))
9826 && ! CONSP (Vunread_command_events
))
9828 Lisp_Object binding
;
9830 int message_p
= push_message ();
9831 int count
= SPECPDL_INDEX ();
9833 record_unwind_protect (pop_message_unwind
, Qnil
);
9834 binding
= Fkey_description (bindings
, Qnil
);
9837 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
9840 sprintf (newmessage
, "You can run the command `%s' with %s",
9841 SDATA (SYMBOL_NAME (function
)),
9843 message2_nolog (newmessage
,
9844 strlen (newmessage
),
9845 STRING_MULTIBYTE (binding
));
9846 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
9847 ? Vsuggest_key_bindings
: make_number (2)),
9852 unbind_to (count
, Qnil
);
9856 RETURN_UNGCPRO (value
);
9860 /* Return nonzero if input events are pending. */
9863 detect_input_pending ()
9866 get_input_pending (&input_pending
, 0);
9868 return input_pending
;
9871 /* Return nonzero if input events are pending, and run any pending timers. */
9874 detect_input_pending_run_timers (do_display
)
9877 int old_timers_run
= timers_run
;
9880 get_input_pending (&input_pending
, 1);
9882 if (old_timers_run
!= timers_run
&& do_display
)
9884 redisplay_preserve_echo_area (8);
9885 /* The following fixes a bug when using lazy-lock with
9886 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9887 from an idle timer function. The symptom of the bug is that
9888 the cursor sometimes doesn't become visible until the next X
9889 event is processed. --gerd. */
9891 rif
->flush_display (NULL
);
9894 return input_pending
;
9897 /* This is called in some cases before a possible quit.
9898 It cases the next call to detect_input_pending to recompute input_pending.
9899 So calling this function unnecessarily can't do any harm. */
9902 clear_input_pending ()
9907 /* Return nonzero if there are pending requeued events.
9908 This isn't used yet. The hope is to make wait_reading_process_input
9909 call it, and return if it runs Lisp code that unreads something.
9910 The problem is, kbd_buffer_get_event needs to be fixed to know what
9911 to do in that case. It isn't trivial. */
9914 requeued_events_pending_p ()
9916 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
9920 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
9921 doc
: /* Return t if command input is currently available with no wait.
9922 Actually, the value is nil only if we can be sure that no input is available;
9923 if there is a doubt, the value is t. */)
9926 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
9929 get_filtered_input_pending (&input_pending
, 1, 1);
9930 return input_pending
> 0 ? Qt
: Qnil
;
9933 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
9934 doc
: /* Return vector of last 100 events, not counting those from keyboard macros. */)
9937 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
9940 if (total_keys
< NUM_RECENT_KEYS
)
9941 return Fvector (total_keys
, keys
);
9944 val
= Fvector (NUM_RECENT_KEYS
, keys
);
9945 bcopy (keys
+ recent_keys_index
,
9946 XVECTOR (val
)->contents
,
9947 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
9949 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
9950 recent_keys_index
* sizeof (Lisp_Object
));
9955 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
9956 doc
: /* Return the key sequence that invoked this command.
9957 However, if the command has called `read-key-sequence', it returns
9958 the last key sequence that has been read.
9959 The value is a string or a vector. */)
9962 return make_event_array (this_command_key_count
,
9963 XVECTOR (this_command_keys
)->contents
);
9966 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
9967 doc
: /* Return the key sequence that invoked this command, as a vector.
9968 However, if the command has called `read-key-sequence', it returns
9969 the last key sequence that has been read. */)
9972 return Fvector (this_command_key_count
,
9973 XVECTOR (this_command_keys
)->contents
);
9976 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
9977 Sthis_single_command_keys
, 0, 0, 0,
9978 doc
: /* Return the key sequence that invoked this command.
9979 More generally, it returns the last key sequence read, either by
9980 the command loop or by `read-key-sequence'.
9981 Unlike `this-command-keys', this function's value
9982 does not include prefix arguments.
9983 The value is always a vector. */)
9986 return Fvector (this_command_key_count
9987 - this_single_command_key_start
,
9988 (XVECTOR (this_command_keys
)->contents
9989 + this_single_command_key_start
));
9992 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
9993 Sthis_single_command_raw_keys
, 0, 0, 0,
9994 doc
: /* Return the raw events that were read for this command.
9995 More generally, it returns the last key sequence read, either by
9996 the command loop or by `read-key-sequence'.
9997 Unlike `this-single-command-keys', this function's value
9998 shows the events before all translations (except for input methods).
9999 The value is always a vector. */)
10002 return Fvector (raw_keybuf_count
,
10003 (XVECTOR (raw_keybuf
)->contents
));
10006 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10007 Sreset_this_command_lengths
, 0, 0, 0,
10008 doc
: /* Make the unread events replace the last command and echo.
10009 Used in `universal-argument-other-key'.
10011 `universal-argument-other-key' rereads the event just typed.
10012 It then gets translated through `function-key-map'.
10013 The translated event has to replace the real events,
10014 both in the value of (this-command-keys) and in echoing.
10015 To achieve this, `universal-argument-other-key' calls
10016 `reset-this-command-lengths', which discards the record of reading
10017 these events the first time. */)
10020 this_command_key_count
= before_command_key_count
;
10021 if (this_command_key_count
< this_single_command_key_start
)
10022 this_single_command_key_start
= this_command_key_count
;
10024 echo_truncate (before_command_echo_length
);
10026 /* Cause whatever we put into unread-command-events
10027 to echo as if it were being freshly read from the keyboard. */
10028 this_command_key_count_reset
= 1;
10033 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10034 Sclear_this_command_keys
, 0, 1, 0,
10035 doc
: /* Clear out the vector that `this-command-keys' returns.
10036 Also clear the record of the last 100 events, unless optional arg
10037 KEEP-RECORD is non-nil. */)
10039 Lisp_Object keep_record
;
10043 this_command_key_count
= 0;
10044 this_command_key_count_reset
= 0;
10046 if (NILP (keep_record
))
10048 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10049 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10051 recent_keys_index
= 0;
10056 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10057 doc
: /* Return the current depth in recursive edits. */)
10061 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10065 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10066 "FOpen dribble file: ",
10067 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10068 If FILE is nil, close any open dribble file. */)
10079 file
= Fexpand_file_name (file
, Qnil
);
10080 dribble
= fopen (SDATA (file
), "w");
10082 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10087 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10088 doc
: /* Discard the contents of the terminal input buffer.
10089 Also end any kbd macro being defined. */)
10092 if (!NILP (current_kboard
->defining_kbd_macro
))
10094 /* Discard the last command from the macro. */
10095 Fcancel_kbd_macro_events ();
10099 update_mode_lines
++;
10101 Vunread_command_events
= Qnil
;
10102 unread_command_char
= -1;
10104 discard_tty_input ();
10106 kbd_fetch_ptr
= kbd_store_ptr
;
10112 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10113 doc
: /* Stop Emacs and return to superior process. You can resume later.
10114 If `cannot-suspend' is non-nil, or if the system doesn't support job
10115 control, run a subshell instead.
10117 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10118 to be read as terminal input by Emacs's parent, after suspension.
10120 Before suspending, run the normal hook `suspend-hook'.
10121 After resumption run the normal hook `suspend-resume-hook'.
10123 Some operating systems cannot stop the Emacs process and resume it later.
10124 On such systems, Emacs starts a subshell instead of suspending. */)
10126 Lisp_Object stuffstring
;
10128 int count
= SPECPDL_INDEX ();
10129 int old_height
, old_width
;
10131 struct gcpro gcpro1
;
10133 if (!NILP (stuffstring
))
10134 CHECK_STRING (stuffstring
);
10136 /* Run the functions in suspend-hook. */
10137 if (!NILP (Vrun_hooks
))
10138 call1 (Vrun_hooks
, intern ("suspend-hook"));
10140 GCPRO1 (stuffstring
);
10141 get_frame_size (&old_width
, &old_height
);
10142 reset_sys_modes ();
10143 /* sys_suspend can get an error if it tries to fork a subshell
10144 and the system resources aren't available for that. */
10145 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_sys_modes
,
10147 stuff_buffered_input (stuffstring
);
10148 if (cannot_suspend
)
10152 unbind_to (count
, Qnil
);
10154 /* Check if terminal/window size has changed.
10155 Note that this is not useful when we are running directly
10156 with a window system; but suspend should be disabled in that case. */
10157 get_frame_size (&width
, &height
);
10158 if (width
!= old_width
|| height
!= old_height
)
10159 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10161 /* Run suspend-resume-hook. */
10162 if (!NILP (Vrun_hooks
))
10163 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10169 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10170 Then in any case stuff anything Emacs has read ahead and not used. */
10173 stuff_buffered_input (stuffstring
)
10174 Lisp_Object stuffstring
;
10176 /* stuff_char works only in BSD, versions 4.2 and up. */
10179 register unsigned char *p
;
10181 if (STRINGP (stuffstring
))
10183 register int count
;
10185 p
= SDATA (stuffstring
);
10186 count
= SBYTES (stuffstring
);
10187 while (count
-- > 0)
10192 /* Anything we have read ahead, put back for the shell to read. */
10193 /* ?? What should this do when we have multiple keyboards??
10194 Should we ignore anything that was typed in at the "wrong" kboard? */
10195 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10198 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10199 kbd_fetch_ptr
= kbd_buffer
;
10200 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10201 stuff_char (kbd_fetch_ptr
->code
);
10203 clear_event (kbd_fetch_ptr
);
10208 #endif /* BSD_SYSTEM and not BSD4_1 */
10212 set_waiting_for_input (time_to_clear
)
10213 EMACS_TIME
*time_to_clear
;
10215 input_available_clear_time
= time_to_clear
;
10217 /* Tell interrupt_signal to throw back to read_char, */
10218 waiting_for_input
= 1;
10220 /* If interrupt_signal was called before and buffered a C-g,
10221 make it run again now, to avoid timing error. */
10222 if (!NILP (Vquit_flag
))
10223 quit_throw_to_read_char ();
10227 clear_waiting_for_input ()
10229 /* Tell interrupt_signal not to throw back to read_char, */
10230 waiting_for_input
= 0;
10231 input_available_clear_time
= 0;
10234 /* This routine is called at interrupt level in response to C-g.
10236 If interrupt_input, this is the handler for SIGINT. Otherwise, it
10237 is called from kbd_buffer_store_event, in handling SIGIO or
10240 If `waiting_for_input' is non zero, then unless `echoing' is
10241 nonzero, immediately throw back to read_char.
10243 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10244 eval to throw, when it gets a chance. If quit-flag is already
10245 non-nil, it stops the job right away. */
10248 interrupt_signal (signalnum
) /* If we don't have an argument, */
10249 int signalnum
; /* some compilers complain in signal calls. */
10252 /* Must preserve main program's value of errno. */
10253 int old_errno
= errno
;
10254 struct frame
*sf
= SELECTED_FRAME ();
10256 #if defined (USG) && !defined (POSIX_SIGNALS)
10257 if (!read_socket_hook
&& NILP (Vwindow_system
))
10259 /* USG systems forget handlers when they are used;
10260 must reestablish each time */
10261 signal (SIGINT
, interrupt_signal
);
10262 signal (SIGQUIT
, interrupt_signal
);
10268 if (!NILP (Vquit_flag
)
10269 && (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
)))
10271 /* If SIGINT isn't blocked, don't let us be interrupted by
10272 another SIGINT, it might be harmful due to non-reentrancy
10273 in I/O functions. */
10274 sigblock (sigmask (SIGINT
));
10277 reset_sys_modes ();
10279 #ifdef SIGTSTP /* Support possible in later USG versions */
10281 * On systems which can suspend the current process and return to the original
10282 * shell, this command causes the user to end up back at the shell.
10283 * The "Auto-save" and "Abort" questions are not asked until
10284 * the user elects to return to emacs, at which point he can save the current
10285 * job and either dump core or continue.
10290 if (sys_suspend () == -1)
10292 printf ("Not running as a subprocess;\n");
10293 printf ("you can continue or abort.\n");
10295 #else /* not VMS */
10296 /* Perhaps should really fork an inferior shell?
10297 But that would not provide any way to get back
10298 to the original shell, ever. */
10299 printf ("No support for stopping a process on this operating system;\n");
10300 printf ("you can continue or abort.\n");
10301 #endif /* not VMS */
10302 #endif /* not SIGTSTP */
10304 /* We must remain inside the screen area when the internal terminal
10305 is used. Note that [Enter] is not echoed by dos. */
10308 /* It doesn't work to autosave while GC is in progress;
10309 the code used for auto-saving doesn't cope with the mark bit. */
10310 if (!gc_in_progress
)
10312 printf ("Auto-save? (y or n) ");
10314 if (((c
= getchar ()) & ~040) == 'Y')
10316 Fdo_auto_save (Qt
, Qnil
);
10318 printf ("\r\nAuto-save done");
10319 #else /* not MSDOS */
10320 printf ("Auto-save done\n");
10321 #endif /* not MSDOS */
10323 while (c
!= '\n') c
= getchar ();
10327 /* During GC, it must be safe to reenable quitting again. */
10328 Vinhibit_quit
= Qnil
;
10331 #endif /* not MSDOS */
10332 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10333 printf ("but will instead do a real quit after garbage collection ends\r\n");
10338 printf ("\r\nAbort? (y or n) ");
10339 #else /* not MSDOS */
10341 printf ("Abort (and enter debugger)? (y or n) ");
10342 #else /* not VMS */
10343 printf ("Abort (and dump core)? (y or n) ");
10344 #endif /* not VMS */
10345 #endif /* not MSDOS */
10347 if (((c
= getchar ()) & ~040) == 'Y')
10349 while (c
!= '\n') c
= getchar ();
10351 printf ("\r\nContinuing...\r\n");
10352 #else /* not MSDOS */
10353 printf ("Continuing...\n");
10354 #endif /* not MSDOS */
10361 /* If executing a function that wants to be interrupted out of
10362 and the user has not deferred quitting by binding `inhibit-quit'
10363 then quit right away. */
10364 if (immediate_quit
&& NILP (Vinhibit_quit
))
10366 struct gl_state_s saved
;
10367 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10369 immediate_quit
= 0;
10372 GCPRO4 (saved
.object
, saved
.global_code
,
10373 saved
.current_syntax_table
, saved
.old_prop
);
10374 Fsignal (Qquit
, Qnil
);
10379 /* Else request quit when it's safe */
10383 if (waiting_for_input
&& !echoing
)
10384 quit_throw_to_read_char ();
10389 /* Handle a C-g by making read_char return C-g. */
10392 quit_throw_to_read_char ()
10395 /* Prevent another signal from doing this before we finish. */
10396 clear_waiting_for_input ();
10399 Vunread_command_events
= Qnil
;
10400 unread_command_char
= -1;
10402 #if 0 /* Currently, sit_for is called from read_char without turning
10403 off polling. And that can call set_waiting_for_input.
10404 It seems to be harmless. */
10405 #ifdef POLL_FOR_INPUT
10406 /* May be > 1 if in recursive minibuffer. */
10407 if (poll_suppress_count
== 0)
10411 if (FRAMEP (internal_last_event_frame
)
10412 && !EQ (internal_last_event_frame
, selected_frame
))
10413 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10416 _longjmp (getcjmp
, 1);
10419 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
10420 doc
: /* Set mode of reading keyboard input.
10421 First arg INTERRUPT non-nil means use input interrupts;
10422 nil means use CBREAK mode.
10423 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10424 (no effect except in CBREAK mode).
10425 Third arg META t means accept 8-bit input (for a Meta key).
10426 META nil means ignore the top bit, on the assumption it is parity.
10427 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10428 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10429 See also `current-input-mode'. */)
10430 (interrupt
, flow
, meta
, quit
)
10431 Lisp_Object interrupt
, flow
, meta
, quit
;
10434 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
10435 error ("set-input-mode: QUIT must be an ASCII character");
10437 #ifdef POLL_FOR_INPUT
10442 /* this causes startup screen to be restored and messes with the mouse */
10443 reset_sys_modes ();
10447 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10448 if (read_socket_hook
)
10450 /* When using X, don't give the user a real choice,
10451 because we haven't implemented the mechanisms to support it. */
10452 #ifdef NO_SOCK_SIGIO
10453 interrupt_input
= 0;
10454 #else /* not NO_SOCK_SIGIO */
10455 interrupt_input
= 1;
10456 #endif /* NO_SOCK_SIGIO */
10459 interrupt_input
= !NILP (interrupt
);
10460 #else /* not SIGIO */
10461 interrupt_input
= 0;
10462 #endif /* not SIGIO */
10464 /* Our VMS input only works by interrupts, as of now. */
10466 interrupt_input
= 1;
10469 flow_control
= !NILP (flow
);
10472 else if (EQ (meta
, Qt
))
10477 /* Don't let this value be out of range. */
10478 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
10484 #ifdef POLL_FOR_INPUT
10485 poll_suppress_count
= 1;
10491 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
10492 doc
: /* Return information about the way Emacs currently reads keyboard input.
10493 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10494 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10495 nil, Emacs is using CBREAK mode.
10496 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10497 terminal; this does not apply if Emacs uses interrupt-driven input.
10498 META is t if accepting 8-bit input with 8th bit as Meta flag.
10499 META nil means ignoring the top bit, on the assumption it is parity.
10500 META is neither t nor nil if accepting 8-bit input and using
10501 all 8 bits as the character code.
10502 QUIT is the character Emacs currently uses to quit.
10503 The elements of this list correspond to the arguments of
10504 `set-input-mode'. */)
10507 Lisp_Object val
[4];
10509 val
[0] = interrupt_input
? Qt
: Qnil
;
10510 val
[1] = flow_control
? Qt
: Qnil
;
10511 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
10512 XSETFASTINT (val
[3], quit_char
);
10514 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
10517 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 3, 0,
10518 doc
: /* Return position information for pixel coordinates X and Y.
10519 By default, X and Y are relative to text area of the selected window.
10520 Optional third arg FRAME_OR_WINDOW non-nil specifies frame or window.
10522 The return value is similar to a mouse click position:
10523 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
10524 IMAGE (DX . DY) (WIDTH . HEIGHT))
10525 The `posn-' functions access elements of such lists. */)
10526 (x
, y
, frame_or_window
)
10527 Lisp_Object x
, y
, frame_or_window
;
10529 if (NILP (frame_or_window
))
10530 frame_or_window
= selected_window
;
10532 if (WINDOWP (frame_or_window
))
10536 CHECK_LIVE_WINDOW (frame_or_window
);
10538 w
= XWINDOW (frame_or_window
);
10539 XSETINT (x
, (WINDOW_TO_FRAME_PIXEL_X (w
, XINT (x
))
10540 + window_box_left_offset (w
, TEXT_AREA
)));
10541 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
10542 frame_or_window
= w
->frame
;
10545 CHECK_LIVE_FRAME (frame_or_window
);
10547 return make_lispy_position (XFRAME (frame_or_window
), &x
, &y
, 0);
10550 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
10551 doc
: /* Return position information for buffer POS in WINDOW.
10552 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
10554 Return nil if position is not visible in window. Otherwise,
10555 the return value is similar to that returned by `event-start' for
10556 a mouse click at the upper left corner of the glyph corresponding
10557 to the given buffer position:
10558 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
10559 IMAGE (DX . DY) (WIDTH . HEIGHT))
10560 The `posn-' functions access elements of such lists. */*/
)
10562 Lisp_Object pos
, window
;
10566 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
10568 tem
= Fposn_at_x_y (XCAR (tem
), XCAR (XCDR (tem
)), window
);
10574 * Set up a new kboard object with reasonable initial values.
10580 kb
->Voverriding_terminal_local_map
= Qnil
;
10581 kb
->Vlast_command
= Qnil
;
10582 kb
->Vreal_last_command
= Qnil
;
10583 kb
->Vprefix_arg
= Qnil
;
10584 kb
->Vlast_prefix_arg
= Qnil
;
10585 kb
->kbd_queue
= Qnil
;
10586 kb
->kbd_queue_has_data
= 0;
10587 kb
->immediate_echo
= 0;
10588 kb
->echo_string
= Qnil
;
10589 kb
->echo_after_prompt
= -1;
10590 kb
->kbd_macro_buffer
= 0;
10591 kb
->kbd_macro_bufsize
= 0;
10592 kb
->defining_kbd_macro
= Qnil
;
10593 kb
->Vlast_kbd_macro
= Qnil
;
10594 kb
->reference_count
= 0;
10595 kb
->Vsystem_key_alist
= Qnil
;
10596 kb
->system_key_syms
= Qnil
;
10597 kb
->Vdefault_minibuffer_frame
= Qnil
;
10601 * Destroy the contents of a kboard object, but not the object itself.
10602 * We use this just before deleting it, or if we're going to initialize
10603 * it a second time.
10609 if (kb
->kbd_macro_buffer
)
10610 xfree (kb
->kbd_macro_buffer
);
10613 #ifdef MULTI_KBOARD
10615 /* Free KB and memory referenced from it. */
10623 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
10626 *kbp
= kb
->next_kboard
;
10628 /* Prevent a dangling reference to KB. */
10629 if (kb
== current_kboard
10630 && FRAMEP (selected_frame
)
10631 && FRAME_LIVE_P (XFRAME (selected_frame
)))
10633 current_kboard
= XFRAME (selected_frame
)->kboard
;
10634 if (current_kboard
== kb
)
10642 #endif /* MULTI_KBOARD */
10647 /* This is correct before outermost invocation of the editor loop */
10648 command_loop_level
= -1;
10649 immediate_quit
= 0;
10650 quit_char
= Ctl ('g');
10651 Vunread_command_events
= Qnil
;
10652 unread_command_char
= -1;
10653 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
10655 recent_keys_index
= 0;
10656 kbd_fetch_ptr
= kbd_buffer
;
10657 kbd_store_ptr
= kbd_buffer
;
10659 do_mouse_tracking
= Qnil
;
10663 /* This means that command_loop_1 won't try to select anything the first
10665 internal_last_event_frame
= Qnil
;
10666 Vlast_event_frame
= internal_last_event_frame
;
10668 #ifdef MULTI_KBOARD
10669 current_kboard
= initial_kboard
;
10671 wipe_kboard (current_kboard
);
10672 init_kboard (current_kboard
);
10674 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
10676 signal (SIGINT
, interrupt_signal
);
10677 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
10678 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10679 SIGQUIT and we can't tell which one it will give us. */
10680 signal (SIGQUIT
, interrupt_signal
);
10681 #endif /* HAVE_TERMIO */
10683 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10685 if (!noninteractive
)
10686 signal (SIGIO
, input_available_signal
);
10689 /* Use interrupt input by default, if it works and noninterrupt input
10690 has deficiencies. */
10692 #ifdef INTERRUPT_INPUT
10693 interrupt_input
= 1;
10695 interrupt_input
= 0;
10698 /* Our VMS input only works by interrupts, as of now. */
10700 interrupt_input
= 1;
10706 if (keyboard_init_hook
)
10707 (*keyboard_init_hook
) ();
10709 #ifdef POLL_FOR_INPUT
10710 poll_suppress_count
= 1;
10715 /* At least provide an escape route since C-g doesn't work. */
10716 signal (SIGINT
, interrupt_signal
);
10720 /* This type's only use is in syms_of_keyboard, to initialize the
10721 event header symbols and put properties on them. */
10722 struct event_head
{
10728 struct event_head head_table
[] = {
10729 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
10730 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
10731 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
10732 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
10733 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
10734 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
10735 /* `select-window' should be handled just like `switch-frame'
10736 in read_key_sequence. */
10737 {&Qselect_window
, "select-window", &Qswitch_frame
}
10741 syms_of_keyboard ()
10743 Vpre_help_message
= Qnil
;
10744 staticpro (&Vpre_help_message
);
10746 Vlispy_mouse_stem
= build_string ("mouse");
10747 staticpro (&Vlispy_mouse_stem
);
10750 QCimage
= intern (":image");
10751 staticpro (&QCimage
);
10753 staticpro (&Qhelp_echo
);
10754 Qhelp_echo
= intern ("help-echo");
10756 staticpro (&item_properties
);
10757 item_properties
= Qnil
;
10759 staticpro (&tool_bar_item_properties
);
10760 tool_bar_item_properties
= Qnil
;
10761 staticpro (&tool_bar_items_vector
);
10762 tool_bar_items_vector
= Qnil
;
10764 staticpro (&real_this_command
);
10765 real_this_command
= Qnil
;
10767 Qtimer_event_handler
= intern ("timer-event-handler");
10768 staticpro (&Qtimer_event_handler
);
10770 Qdisabled_command_hook
= intern ("disabled-command-hook");
10771 staticpro (&Qdisabled_command_hook
);
10773 Qself_insert_command
= intern ("self-insert-command");
10774 staticpro (&Qself_insert_command
);
10776 Qforward_char
= intern ("forward-char");
10777 staticpro (&Qforward_char
);
10779 Qbackward_char
= intern ("backward-char");
10780 staticpro (&Qbackward_char
);
10782 Qdisabled
= intern ("disabled");
10783 staticpro (&Qdisabled
);
10785 Qundefined
= intern ("undefined");
10786 staticpro (&Qundefined
);
10788 Qpre_command_hook
= intern ("pre-command-hook");
10789 staticpro (&Qpre_command_hook
);
10791 Qpost_command_hook
= intern ("post-command-hook");
10792 staticpro (&Qpost_command_hook
);
10794 Qpost_command_idle_hook
= intern ("post-command-idle-hook");
10795 staticpro (&Qpost_command_idle_hook
);
10797 Qdeferred_action_function
= intern ("deferred-action-function");
10798 staticpro (&Qdeferred_action_function
);
10800 Qcommand_hook_internal
= intern ("command-hook-internal");
10801 staticpro (&Qcommand_hook_internal
);
10803 Qfunction_key
= intern ("function-key");
10804 staticpro (&Qfunction_key
);
10805 Qmouse_click
= intern ("mouse-click");
10806 staticpro (&Qmouse_click
);
10808 Qlanguage_change
= intern ("language-change");
10809 staticpro (&Qlanguage_change
);
10811 Qdrag_n_drop
= intern ("drag-n-drop");
10812 staticpro (&Qdrag_n_drop
);
10814 Qsave_session
= intern ("save-session");
10815 staticpro(&Qsave_session
);
10817 Qusr1_signal
= intern ("usr1-signal");
10818 staticpro (&Qusr1_signal
);
10819 Qusr2_signal
= intern ("usr2-signal");
10820 staticpro (&Qusr2_signal
);
10822 Qmenu_enable
= intern ("menu-enable");
10823 staticpro (&Qmenu_enable
);
10824 Qmenu_alias
= intern ("menu-alias");
10825 staticpro (&Qmenu_alias
);
10826 QCenable
= intern (":enable");
10827 staticpro (&QCenable
);
10828 QCvisible
= intern (":visible");
10829 staticpro (&QCvisible
);
10830 QChelp
= intern (":help");
10831 staticpro (&QChelp
);
10832 QCfilter
= intern (":filter");
10833 staticpro (&QCfilter
);
10834 QCbutton
= intern (":button");
10835 staticpro (&QCbutton
);
10836 QCkeys
= intern (":keys");
10837 staticpro (&QCkeys
);
10838 QCkey_sequence
= intern (":key-sequence");
10839 staticpro (&QCkey_sequence
);
10840 QCtoggle
= intern (":toggle");
10841 staticpro (&QCtoggle
);
10842 QCradio
= intern (":radio");
10843 staticpro (&QCradio
);
10845 Qmode_line
= intern ("mode-line");
10846 staticpro (&Qmode_line
);
10847 Qvertical_line
= intern ("vertical-line");
10848 staticpro (&Qvertical_line
);
10849 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
10850 staticpro (&Qvertical_scroll_bar
);
10851 Qmenu_bar
= intern ("menu-bar");
10852 staticpro (&Qmenu_bar
);
10854 Qabove_handle
= intern ("above-handle");
10855 staticpro (&Qabove_handle
);
10856 Qhandle
= intern ("handle");
10857 staticpro (&Qhandle
);
10858 Qbelow_handle
= intern ("below-handle");
10859 staticpro (&Qbelow_handle
);
10860 Qup
= intern ("up");
10862 Qdown
= intern ("down");
10863 staticpro (&Qdown
);
10864 Qtop
= intern ("top");
10866 Qbottom
= intern ("bottom");
10867 staticpro (&Qbottom
);
10868 Qend_scroll
= intern ("end-scroll");
10869 staticpro (&Qend_scroll
);
10870 Qratio
= intern ("ratio");
10871 staticpro (&Qratio
);
10873 Qevent_kind
= intern ("event-kind");
10874 staticpro (&Qevent_kind
);
10875 Qevent_symbol_elements
= intern ("event-symbol-elements");
10876 staticpro (&Qevent_symbol_elements
);
10877 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
10878 staticpro (&Qevent_symbol_element_mask
);
10879 Qmodifier_cache
= intern ("modifier-cache");
10880 staticpro (&Qmodifier_cache
);
10882 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
10883 staticpro (&Qrecompute_lucid_menubar
);
10884 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
10885 staticpro (&Qactivate_menubar_hook
);
10887 Qpolling_period
= intern ("polling-period");
10888 staticpro (&Qpolling_period
);
10890 Qinput_method_function
= intern ("input-method-function");
10891 staticpro (&Qinput_method_function
);
10893 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
10894 staticpro (&Qinput_method_exit_on_first_char
);
10895 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
10896 staticpro (&Qinput_method_use_echo_area
);
10898 Fset (Qinput_method_exit_on_first_char
, Qnil
);
10899 Fset (Qinput_method_use_echo_area
, Qnil
);
10901 last_point_position_buffer
= Qnil
;
10904 struct event_head
*p
;
10906 for (p
= head_table
;
10907 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
10910 *p
->var
= intern (p
->name
);
10911 staticpro (p
->var
);
10912 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
10913 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
10917 button_down_location
= Fmake_vector (make_number (1), Qnil
);
10918 staticpro (&button_down_location
);
10919 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
10920 staticpro (&mouse_syms
);
10921 wheel_syms
= Fmake_vector (make_number (2), Qnil
);
10922 staticpro (&wheel_syms
);
10926 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
10928 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
10929 for (i
= 0; i
< len
; i
++)
10930 if (modifier_names
[i
])
10931 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
10932 staticpro (&modifier_symbols
);
10935 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
10936 staticpro (&recent_keys
);
10938 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
10939 staticpro (&this_command_keys
);
10941 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
10942 staticpro (&raw_keybuf
);
10944 Qextended_command_history
= intern ("extended-command-history");
10945 Fset (Qextended_command_history
, Qnil
);
10946 staticpro (&Qextended_command_history
);
10948 accent_key_syms
= Qnil
;
10949 staticpro (&accent_key_syms
);
10951 func_key_syms
= Qnil
;
10952 staticpro (&func_key_syms
);
10954 drag_n_drop_syms
= Qnil
;
10955 staticpro (&drag_n_drop_syms
);
10957 unread_switch_frame
= Qnil
;
10958 staticpro (&unread_switch_frame
);
10960 internal_last_event_frame
= Qnil
;
10961 staticpro (&internal_last_event_frame
);
10963 read_key_sequence_cmd
= Qnil
;
10964 staticpro (&read_key_sequence_cmd
);
10966 menu_bar_one_keymap_changed_items
= Qnil
;
10967 staticpro (&menu_bar_one_keymap_changed_items
);
10969 defsubr (&Sevent_convert_list
);
10970 defsubr (&Sread_key_sequence
);
10971 defsubr (&Sread_key_sequence_vector
);
10972 defsubr (&Srecursive_edit
);
10974 defsubr (&Strack_mouse
);
10976 defsubr (&Sinput_pending_p
);
10977 defsubr (&Scommand_execute
);
10978 defsubr (&Srecent_keys
);
10979 defsubr (&Sthis_command_keys
);
10980 defsubr (&Sthis_command_keys_vector
);
10981 defsubr (&Sthis_single_command_keys
);
10982 defsubr (&Sthis_single_command_raw_keys
);
10983 defsubr (&Sreset_this_command_lengths
);
10984 defsubr (&Sclear_this_command_keys
);
10985 defsubr (&Ssuspend_emacs
);
10986 defsubr (&Sabort_recursive_edit
);
10987 defsubr (&Sexit_recursive_edit
);
10988 defsubr (&Srecursion_depth
);
10989 defsubr (&Stop_level
);
10990 defsubr (&Sdiscard_input
);
10991 defsubr (&Sopen_dribble_file
);
10992 defsubr (&Sset_input_mode
);
10993 defsubr (&Scurrent_input_mode
);
10994 defsubr (&Sexecute_extended_command
);
10995 defsubr (&Sposn_at_point
);
10996 defsubr (&Sposn_at_x_y
);
10998 DEFVAR_LISP ("last-command-char", &last_command_char
,
10999 doc
: /* Last input event that was part of a command. */);
11001 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
11002 doc
: /* Last input event that was part of a command. */);
11004 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11005 doc
: /* Last input event in a command, except for mouse menu events.
11006 Mouse menus give back keys that don't look like mouse events;
11007 this variable holds the actual mouse event that led to the menu,
11008 so that you can determine whether the command was run by mouse or not. */);
11010 DEFVAR_LISP ("last-input-char", &last_input_char
,
11011 doc
: /* Last input event. */);
11013 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
11014 doc
: /* Last input event. */);
11016 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11017 doc
: /* List of events to be read as the command input.
11018 These events are processed first, before actual keyboard input. */);
11019 Vunread_command_events
= Qnil
;
11021 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11022 doc
: /* If not -1, an object to be read as next command input event. */);
11024 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11025 doc
: /* List of events to be processed as input by input methods.
11026 These events are processed after `unread-command-events', but
11027 before actual keyboard input. */);
11028 Vunread_post_input_method_events
= Qnil
;
11030 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
11031 doc
: /* List of events to be processed as input by input methods.
11032 These events are processed after `unread-command-events', but
11033 before actual keyboard input. */);
11034 Vunread_input_method_events
= Qnil
;
11036 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
11037 doc
: /* Meta-prefix character code.
11038 Meta-foo as command input turns into this character followed by foo. */);
11039 XSETINT (meta_prefix_char
, 033);
11041 DEFVAR_KBOARD ("last-command", Vlast_command
,
11042 doc
: /* The last command executed.
11043 Normally a symbol with a function definition, but can be whatever was found
11044 in the keymap, or whatever the variable `this-command' was set to by that
11047 The value `mode-exit' is special; it means that the previous command
11048 read an event that told it to exit, and it did so and unread that event.
11049 In other words, the present command is the event that made the previous
11052 The value `kill-region' is special; it means that the previous command
11053 was a kill command. */);
11055 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11056 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11058 DEFVAR_LISP ("this-command", &Vthis_command
,
11059 doc
: /* The command now being executed.
11060 The command can set this variable; whatever is put here
11061 will be in `last-command' during the following command. */);
11062 Vthis_command
= Qnil
;
11064 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
11065 doc
: /* The command bound to the current key sequence before remapping.
11066 It equals `this-command' if the original command was not remapped through
11067 any of the active keymaps. Otherwise, the value of `this-command' is the
11068 result of looking up the original command in the active keymaps. */);
11069 Vthis_original_command
= Qnil
;
11071 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
11072 doc
: /* *Number of input events between auto-saves.
11073 Zero means disable autosaving due to number of characters typed. */);
11074 auto_save_interval
= 300;
11076 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
11077 doc
: /* *Number of seconds idle time before auto-save.
11078 Zero or nil means disable auto-saving due to idleness.
11079 After auto-saving due to this many seconds of idle time,
11080 Emacs also does a garbage collection if that seems to be warranted. */);
11081 XSETFASTINT (Vauto_save_timeout
, 30);
11083 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11084 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11085 The value may be integer or floating point. */);
11086 Vecho_keystrokes
= make_number (1);
11088 DEFVAR_INT ("polling-period", &polling_period
,
11089 doc
: /* *Interval between polling for input during Lisp execution.
11090 The reason for polling is to make C-g work to stop a running program.
11091 Polling is needed only when using X windows and SIGIO does not work.
11092 Polling is automatically disabled in all other cases. */);
11093 polling_period
= 2;
11095 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
11096 doc
: /* *Maximum time between mouse clicks to make a double-click.
11097 Measured in milliseconds. nil means disable double-click recognition;
11098 t means double-clicks have no time limit and are detected
11099 by position only. */);
11100 Vdouble_click_time
= make_number (500);
11102 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
11103 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11104 On window-system frames, value is the number of pixels the mouse may have
11105 moved horizontally or vertically between two clicks to make a double-click.
11106 On non window-system frames, value is interpreted in units of 1/8 characters
11109 This variable is also the threshold for motion of the mouse
11110 to count as a drag. */);
11111 double_click_fuzz
= 3;
11113 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
11114 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11115 inhibit_local_menu_bar_menus
= 0;
11117 DEFVAR_INT ("num-input-keys", &num_input_keys
,
11118 doc
: /* Number of complete key sequences read as input so far.
11119 This includes key sequences read from keyboard macros.
11120 The number is effectively the number of interactive command invocations. */);
11121 num_input_keys
= 0;
11123 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
11124 doc
: /* Number of input events read from the keyboard so far.
11125 This does not include events generated by keyboard macros. */);
11126 num_nonmacro_input_events
= 0;
11128 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
11129 doc
: /* The frame in which the most recently read event occurred.
11130 If the last event came from a keyboard macro, this is set to `macro'. */);
11131 Vlast_event_frame
= Qnil
;
11133 /* This variable is set up in sysdep.c. */
11134 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
11135 doc
: /* The ERASE character as set by the user with stty. */);
11137 DEFVAR_LISP ("help-char", &Vhelp_char
,
11138 doc
: /* Character to recognize as meaning Help.
11139 When it is read, do `(eval help-form)', and display result if it's a string.
11140 If the value of `help-form' is nil, this char can be read normally. */);
11141 XSETINT (Vhelp_char
, Ctl ('H'));
11143 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
11144 doc
: /* List of input events to recognize as meaning Help.
11145 These work just like the value of `help-char' (see that). */);
11146 Vhelp_event_list
= Qnil
;
11148 DEFVAR_LISP ("help-form", &Vhelp_form
,
11149 doc
: /* Form to execute when character `help-char' is read.
11150 If the form returns a string, that string is displayed.
11151 If `help-form' is nil, the help char is not recognized. */);
11154 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
11155 doc
: /* Command to run when `help-char' character follows a prefix key.
11156 This command is used only when there is no actual binding
11157 for that character after that prefix key. */);
11158 Vprefix_help_command
= Qnil
;
11160 DEFVAR_LISP ("top-level", &Vtop_level
,
11161 doc
: /* Form to evaluate when Emacs starts up.
11162 Useful to set before you dump a modified Emacs. */);
11165 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
11166 doc
: /* Translate table for keyboard input, or nil.
11167 If non-nil, the value should be a char-table. Each character read
11168 from the keyboard is looked up in this char-table. If the value found
11169 there is non-nil, then it is used instead of the actual input character.
11171 The value can also be a string or vector, but this is considered obsolete.
11172 If it is a string or vector of length N, character codes N and up are left
11173 untranslated. In a vector, an element which is nil means "no translation".
11175 This is applied to the characters supplied to input methods, not their
11176 output. See also `translation-table-for-input'. */);
11177 Vkeyboard_translate_table
= Qnil
;
11179 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
11180 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11181 \(Even if the operating system has support for stopping a process.\) */);
11182 cannot_suspend
= 0;
11184 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
11185 doc
: /* Non-nil means prompt with menus when appropriate.
11186 This is done when reading from a keymap that has a prompt string,
11187 for elements that have prompt strings.
11188 The menu is displayed on the screen
11189 if X menus were enabled at configuration
11190 time and the previous event was a mouse click prefix key.
11191 Otherwise, menu prompting uses the echo area. */);
11192 menu_prompting
= 1;
11194 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
11195 doc
: /* Character to see next line of menu prompt.
11196 Type this character while in a menu prompt to rotate around the lines of it. */);
11197 XSETINT (menu_prompt_more_char
, ' ');
11199 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
11200 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11201 Emacs applies the modifiers of the character stored here to each keyboard
11202 character it reads. For example, after evaluating the expression
11203 (setq extra-keyboard-modifiers ?\\C-x)
11204 all input characters will have the control modifier applied to them.
11206 Note that the character ?\\C-@, equivalent to the integer zero, does
11207 not count as a control character; rather, it counts as a character
11208 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11209 cancels any modification. */);
11210 extra_keyboard_modifiers
= 0;
11212 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
11213 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11214 The command loop sets this to nil before each command,
11215 and tests the value when the command returns.
11216 Buffer modification stores t in this variable. */);
11217 Vdeactivate_mark
= Qnil
;
11219 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
11220 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
11221 Vcommand_hook_internal
= Qnil
;
11223 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
11224 doc
: /* Normal hook run before each command is executed.
11225 If an unhandled error happens in running this hook,
11226 the hook value is set to nil, since otherwise the error
11227 might happen repeatedly and make Emacs nonfunctional. */);
11228 Vpre_command_hook
= Qnil
;
11230 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
11231 doc
: /* Normal hook run after each command is executed.
11232 If an unhandled error happens in running this hook,
11233 the hook value is set to nil, since otherwise the error
11234 might happen repeatedly and make Emacs nonfunctional. */);
11235 Vpost_command_hook
= Qnil
;
11237 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook
,
11238 doc
: /* Normal hook run after each command is executed, if idle.
11239 Errors running the hook are caught and ignored. */);
11240 Vpost_command_idle_hook
= Qnil
;
11242 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay
,
11243 doc
: /* Delay time before running `post-command-idle-hook'.
11244 This is measured in microseconds. */);
11245 post_command_idle_delay
= 100000;
11248 DEFVAR_LISP ("echo-area-clear-hook", ...,
11249 doc
: /* Normal hook run when clearing the echo area. */);
11251 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
11252 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
11254 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
11255 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11256 Vlucid_menu_bar_dirty_flag
= Qnil
;
11258 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
11259 doc
: /* List of menu bar items to move to the end of the menu bar.
11260 The elements of the list are event types that may have menu bar bindings. */);
11261 Vmenu_bar_final_items
= Qnil
;
11263 DEFVAR_KBOARD ("overriding-terminal-local-map",
11264 Voverriding_terminal_local_map
,
11265 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11266 If this variable is non-nil, it is used as a keymap instead of the
11267 buffer's local map, and the minor mode keymaps and text property keymaps.
11268 This variable is intended to let commands such as `universal-argument'
11269 set up a different keymap for reading the next command. */);
11271 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
11272 doc
: /* Keymap that overrides all other local keymaps.
11273 If this variable is non-nil, it is used as a keymap instead of the
11274 buffer's local map, and the minor mode keymaps and text property keymaps. */);
11275 Voverriding_local_map
= Qnil
;
11277 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
11278 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11279 Otherwise, the menu bar continues to reflect the buffer's local map
11280 and the minor mode maps regardless of `overriding-local-map'. */);
11281 Voverriding_local_map_menu_flag
= Qnil
;
11283 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
11284 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11285 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
11287 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
11288 doc
: /* *Non-nil means generate motion events for mouse motion. */);
11290 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11291 doc
: /* Alist of system-specific X windows key symbols.
11292 Each element should have the form (N . SYMBOL) where N is the
11293 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11294 and SYMBOL is its name. */);
11296 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
11297 doc
: /* List of deferred actions to be performed at a later time.
11298 The precise format isn't relevant here; we just check whether it is nil. */);
11299 Vdeferred_action_list
= Qnil
;
11301 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
11302 doc
: /* Function to call to handle deferred actions, after each command.
11303 This function is called with no arguments after each command
11304 whenever `deferred-action-list' is non-nil. */);
11305 Vdeferred_action_function
= Qnil
;
11307 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
11308 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
11309 The value can be a length of time to show the message for.
11310 If the value is non-nil and not a number, we wait 2 seconds. */);
11311 Vsuggest_key_bindings
= Qt
;
11313 DEFVAR_LISP ("timer-list", &Vtimer_list
,
11314 doc
: /* List of active absolute time timers in order of increasing time. */);
11315 Vtimer_list
= Qnil
;
11317 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
11318 doc
: /* List of active idle-time timers in order of increasing time. */);
11319 Vtimer_idle_list
= Qnil
;
11321 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
11322 doc
: /* If non-nil, the function that implements the current input method.
11323 It's called with one argument, a printing character that was just read.
11324 \(That means a character with code 040...0176.)
11325 Typically this function uses `read-event' to read additional events.
11326 When it does so, it should first bind `input-method-function' to nil
11327 so it will not be called recursively.
11329 The function should return a list of zero or more events
11330 to be used as input. If it wants to put back some events
11331 to be reconsidered, separately, by the input method,
11332 it can add them to the beginning of `unread-command-events'.
11334 The input method function can find in `input-method-previous-method'
11335 the previous echo area message.
11337 The input method function should refer to the variables
11338 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11339 for guidance on what to do. */);
11340 Vinput_method_function
= Qnil
;
11342 DEFVAR_LISP ("input-method-previous-message",
11343 &Vinput_method_previous_message
,
11344 doc
: /* When `input-method-function' is called, hold the previous echo area message.
11345 This variable exists because `read-event' clears the echo area
11346 before running the input method. It is nil if there was no message. */);
11347 Vinput_method_previous_message
= Qnil
;
11349 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
11350 doc
: /* If non-nil, the function that implements the display of help.
11351 It's called with one argument, the help string to display. */);
11352 Vshow_help_function
= Qnil
;
11354 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
11355 doc
: /* If non-nil, suppress point adjustment after executing a command.
11357 After a command is executed, if point is moved into a region that has
11358 special properties (e.g. composition, display), we adjust point to
11359 the boundary of the region. But, several special commands sets this
11360 variable to non-nil, then we suppress the point adjustment.
11362 This variable is set to nil before reading a command, and is checked
11363 just after executing the command. */);
11364 Vdisable_point_adjustment
= Qnil
;
11366 DEFVAR_LISP ("global-disable-point-adjustment",
11367 &Vglobal_disable_point_adjustment
,
11368 doc
: /* *If non-nil, always suppress point adjustment.
11370 The default value is nil, in which case, point adjustment are
11371 suppressed only after special commands that set
11372 `disable-point-adjustment' (which see) to non-nil. */);
11373 Vglobal_disable_point_adjustment
= Qnil
;
11375 DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings
,
11376 doc
: /* Non-nil means updating menu bindings is allowed.
11377 A value of nil means menu bindings should not be updated.
11378 Used during Emacs' startup. */);
11379 update_menu_bindings
= 1;
11381 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
11382 doc
: /* *How long to display an echo-area message when the minibuffer is active.
11383 If the value is not a number, such messages don't time out. */);
11384 Vminibuffer_message_timeout
= make_number (2);
11388 keys_of_keyboard ()
11390 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
11391 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
11392 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
11393 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
11394 initial_define_key (meta_map
, 'x', "execute-extended-command");
11396 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
11397 "handle-delete-frame");
11398 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
11400 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
11402 /* Handling it at such a low-level causes read_key_sequence to get
11403 * confused because it doesn't realize that the current_buffer was
11404 * changed by read_char.
11406 * initial_define_lispy_key (Vspecial_event_map, "select-window",
11407 * "handle-select-window"); */
11408 initial_define_lispy_key (Vspecial_event_map
, "save-session",
11409 "handle-save-session");
11412 /* Mark the pointers in the kboard objects.
11413 Called by the Fgarbage_collector. */
11419 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
11421 if (kb
->kbd_macro_buffer
)
11422 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
11424 mark_object (kb
->Voverriding_terminal_local_map
);
11425 mark_object (kb
->Vlast_command
);
11426 mark_object (kb
->Vreal_last_command
);
11427 mark_object (kb
->Vprefix_arg
);
11428 mark_object (kb
->Vlast_prefix_arg
);
11429 mark_object (kb
->kbd_queue
);
11430 mark_object (kb
->defining_kbd_macro
);
11431 mark_object (kb
->Vlast_kbd_macro
);
11432 mark_object (kb
->Vsystem_key_alist
);
11433 mark_object (kb
->system_key_syms
);
11434 mark_object (kb
->Vdefault_minibuffer_frame
);
11435 mark_object (kb
->echo_string
);
11438 struct input_event
*event
;
11439 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
11441 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
11442 event
= kbd_buffer
;
11443 if (event
->kind
!= SELECTION_REQUEST_EVENT
)
11445 mark_object (event
->x
);
11446 mark_object (event
->y
);
11448 mark_object (event
->frame_or_window
);
11449 mark_object (event
->arg
);
11454 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
11455 (do not change this comment) */