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
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. */
29 #include "termhooks.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"
59 #include <sys/types.h>
64 /* This is to get the definitions of the XK_ symbols. */
71 #endif /* HAVE_NTGUI */
81 /* Variables for blockinput.h: */
83 /* Non-zero if interrupt input is blocked right now. */
84 int interrupt_input_blocked
;
86 /* Nonzero means an input interrupt has arrived
87 during the current critical section. */
88 int interrupt_input_pending
;
91 #ifdef HAVE_WINDOW_SYSTEM
92 /* Make all keyboard buffers much bigger when using X windows. */
94 /* But not too big (local data > 32K error) if on Mac OS Classic. */
95 #define KBD_BUFFER_SIZE 512
97 #define KBD_BUFFER_SIZE 4096
99 #else /* No X-windows, character input */
100 #define KBD_BUFFER_SIZE 4096
101 #endif /* No X-windows */
103 #define abs(x) ((x) >= 0 ? (x) : -(x))
105 /* Following definition copied from eval.c */
109 struct backtrace
*next
;
110 Lisp_Object
*function
;
111 Lisp_Object
*args
; /* Points to vector of args. */
112 int nargs
; /* length of vector. If nargs is UNEVALLED,
113 args points to slot holding list of
119 KBOARD
*initial_kboard
;
120 KBOARD
*current_kboard
;
124 KBOARD the_only_kboard
;
127 /* Non-nil disable property on a command means
128 do not execute it; call disabled-command-hook's value instead. */
129 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
131 #define NUM_RECENT_KEYS (100)
132 int recent_keys_index
; /* Index for storing next element into recent_keys */
133 int total_keys
; /* Total number of elements stored into recent_keys */
134 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
136 /* Vector holding the key sequence that invoked the current command.
137 It is reused for each command, and it may be longer than the current
138 sequence; this_command_key_count indicates how many elements
139 actually mean something.
140 It's easier to staticpro a single Lisp_Object than an array. */
141 Lisp_Object this_command_keys
;
142 int this_command_key_count
;
144 /* 1 after calling Freset_this_command_lengths.
146 int this_command_key_count_reset
;
148 /* This vector is used as a buffer to record the events that were actually read
149 by read_key_sequence. */
150 Lisp_Object raw_keybuf
;
151 int raw_keybuf_count
;
153 #define GROW_RAW_KEYBUF \
154 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
156 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
158 new = Fmake_vector (make_number (newsize), Qnil); \
159 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
160 raw_keybuf_count * sizeof (Lisp_Object)); \
164 /* Number of elements of this_command_keys
165 that precede this key sequence. */
166 int this_single_command_key_start
;
168 /* Record values of this_command_key_count and echo_length ()
169 before this command was read. */
170 static int before_command_key_count
;
171 static int before_command_echo_length
;
173 extern int minbuf_level
;
175 extern int message_enable_multibyte
;
177 extern struct backtrace
*backtrace_list
;
179 /* If non-nil, the function that implements the display of help.
180 It's called with one argument, the help string to display. */
182 Lisp_Object Vshow_help_function
;
184 /* If a string, the message displayed before displaying a help-echo
187 Lisp_Object Vpre_help_message
;
189 /* Nonzero means do menu prompting. */
191 static int menu_prompting
;
193 /* Character to see next line of menu prompt. */
195 static Lisp_Object menu_prompt_more_char
;
197 /* For longjmp to where kbd input is being done. */
199 static jmp_buf getcjmp
;
201 /* True while doing kbd input. */
202 int waiting_for_input
;
204 /* True while displaying for echoing. Delays C-g throwing. */
208 /* Non-null means we can start echoing at the next input pause even
209 though there is something in the echo area. */
211 static struct kboard
*ok_to_echo_at_next_pause
;
213 /* The kboard last echoing, or null for none. Reset to 0 in
214 cancel_echoing. If non-null, and a current echo area message
215 exists, and echo_message_buffer is eq to the current message
216 buffer, we know that the message comes from echo_kboard. */
218 struct kboard
*echo_kboard
;
220 /* The buffer used for echoing. Set in echo_now, reset in
223 Lisp_Object echo_message_buffer
;
225 /* Nonzero means disregard local maps for the menu bar. */
226 static int inhibit_local_menu_bar_menus
;
228 /* Nonzero means C-g should cause immediate error-signal. */
231 /* The user's ERASE setting. */
232 Lisp_Object Vtty_erase_char
;
234 /* Character to recognize as the help char. */
235 Lisp_Object Vhelp_char
;
237 /* List of other event types to recognize as meaning "help". */
238 Lisp_Object Vhelp_event_list
;
240 /* Form to execute when help char is typed. */
241 Lisp_Object Vhelp_form
;
243 /* Command to run when the help character follows a prefix key. */
244 Lisp_Object Vprefix_help_command
;
246 /* List of items that should move to the end of the menu bar. */
247 Lisp_Object Vmenu_bar_final_items
;
249 /* Non-nil means show the equivalent key-binding for
250 any M-x command that has one.
251 The value can be a length of time to show the message for.
252 If the value is non-nil and not a number, we wait 2 seconds. */
253 Lisp_Object Vsuggest_key_bindings
;
255 /* How long to display an echo-area message when the minibuffer is active.
256 If the value is not a number, such messages don't time out. */
257 Lisp_Object Vminibuffer_message_timeout
;
259 /* Character that causes a quit. Normally C-g.
261 If we are running on an ordinary terminal, this must be an ordinary
262 ASCII char, since we want to make it our interrupt character.
264 If we are not running on an ordinary terminal, it still needs to be
265 an ordinary ASCII char. This character needs to be recognized in
266 the input interrupt handler. At this point, the keystroke is
267 represented as a struct input_event, while the desired quit
268 character is specified as a lispy event. The mapping from struct
269 input_events to lispy events cannot run in an interrupt handler,
270 and the reverse mapping is difficult for anything but ASCII
273 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
277 extern Lisp_Object current_global_map
;
278 extern int minibuf_level
;
280 /* If non-nil, this is a map that overrides all other local maps. */
281 Lisp_Object Voverriding_local_map
;
283 /* If non-nil, Voverriding_local_map applies to the menu bar. */
284 Lisp_Object Voverriding_local_map_menu_flag
;
286 /* Keymap that defines special misc events that should
287 be processed immediately at a low level. */
288 Lisp_Object Vspecial_event_map
;
290 /* Current depth in recursive edits. */
291 int command_loop_level
;
293 /* Total number of times command_loop has read a key sequence. */
294 EMACS_INT num_input_keys
;
296 /* Last input character read as a command. */
297 Lisp_Object last_command_char
;
299 /* Last input character read as a command, not counting menus
300 reached by the mouse. */
301 Lisp_Object last_nonmenu_event
;
303 /* Last input character read for any purpose. */
304 Lisp_Object last_input_char
;
306 /* If not Qnil, a list of objects to be read as subsequent command input. */
307 Lisp_Object Vunread_command_events
;
309 /* If not Qnil, a list of objects to be read as subsequent command input
310 including input method processing. */
311 Lisp_Object Vunread_input_method_events
;
313 /* If not Qnil, a list of objects to be read as subsequent command input
314 but NOT including input method processing. */
315 Lisp_Object Vunread_post_input_method_events
;
317 /* If not -1, an event to be read as subsequent command input. */
318 EMACS_INT unread_command_char
;
320 /* If not Qnil, this is a switch-frame event which we decided to put
321 off until the end of a key sequence. This should be read as the
322 next command input, after any unread_command_events.
324 read_key_sequence uses this to delay switch-frame events until the
325 end of the key sequence; Fread_char uses it to put off switch-frame
326 events until a non-ASCII event is acceptable as input. */
327 Lisp_Object unread_switch_frame
;
329 /* A mask of extra modifier bits to put into every keyboard char. */
330 EMACS_INT extra_keyboard_modifiers
;
332 /* Char to use as prefix when a meta character is typed in.
333 This is bound on entry to minibuffer in case ESC is changed there. */
335 Lisp_Object meta_prefix_char
;
337 /* Last size recorded for a current buffer which is not a minibuffer. */
338 static int last_non_minibuf_size
;
340 /* Number of idle seconds before an auto-save and garbage collection. */
341 static Lisp_Object Vauto_save_timeout
;
343 /* Total number of times read_char has returned. */
344 int num_input_events
;
346 /* Total number of times read_char has returned, outside of macros. */
347 EMACS_INT num_nonmacro_input_events
;
349 /* Auto-save automatically when this many characters have been typed
350 since the last time. */
352 static EMACS_INT auto_save_interval
;
354 /* Value of num_nonmacro_input_events as of last auto save. */
358 /* The command being executed by the command loop.
359 Commands may set this, and the value set will be copied into
360 current_kboard->Vlast_command instead of the actual command. */
361 Lisp_Object Vthis_command
;
363 /* This is like Vthis_command, except that commands never set it. */
364 Lisp_Object real_this_command
;
366 /* If the lookup of the command returns a binding, the original
367 command is stored in this-original-command. It is nil otherwise. */
368 Lisp_Object Vthis_original_command
;
370 /* The value of point when the last command was executed. */
371 int last_point_position
;
373 /* The buffer that was current when the last command was started. */
374 Lisp_Object last_point_position_buffer
;
376 /* The frame in which the last input event occurred, or Qmacro if the
377 last event came from a macro. We use this to determine when to
378 generate switch-frame events. This may be cleared by functions
379 like Fselect_frame, to make sure that a switch-frame event is
380 generated by the next character. */
381 Lisp_Object internal_last_event_frame
;
383 /* A user-visible version of the above, intended to allow users to
384 figure out where the last event came from, if the event doesn't
385 carry that information itself (i.e. if it was a character). */
386 Lisp_Object Vlast_event_frame
;
388 /* The timestamp of the last input event we received from the X server.
389 X Windows wants this for selection ownership. */
390 unsigned long last_event_timestamp
;
392 Lisp_Object Qself_insert_command
;
393 Lisp_Object Qforward_char
;
394 Lisp_Object Qbackward_char
;
395 Lisp_Object Qundefined
;
396 Lisp_Object Qtimer_event_handler
;
398 /* read_key_sequence stores here the command definition of the
399 key sequence that it reads. */
400 Lisp_Object read_key_sequence_cmd
;
402 /* Echo unfinished commands after this many seconds of pause. */
403 Lisp_Object Vecho_keystrokes
;
405 /* Form to evaluate (if non-nil) when Emacs is started. */
406 Lisp_Object Vtop_level
;
408 /* User-supplied table to translate input characters. */
409 Lisp_Object Vkeyboard_translate_table
;
411 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
412 extern Lisp_Object Vfunction_key_map
;
414 /* Another keymap that maps key sequences into key sequences.
415 This one takes precedence over ordinary definitions. */
416 extern Lisp_Object Vkey_translation_map
;
418 /* If non-nil, this implements the current input method. */
419 Lisp_Object Vinput_method_function
;
420 Lisp_Object Qinput_method_function
;
422 /* When we call Vinput_method_function,
423 this holds the echo area message that was just erased. */
424 Lisp_Object Vinput_method_previous_message
;
426 /* Non-nil means deactivate the mark at end of this command. */
427 Lisp_Object Vdeactivate_mark
;
429 /* Menu bar specified in Lucid Emacs fashion. */
431 Lisp_Object Vlucid_menu_bar_dirty_flag
;
432 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
434 Lisp_Object Qecho_area_clear_hook
;
436 /* Hooks to run before and after each command. */
437 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
438 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
439 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
440 /* Hook run after a command if there's no more input soon. */
441 Lisp_Object Qpost_command_idle_hook
, Vpost_command_idle_hook
;
443 /* Delay time in microseconds before running post-command-idle-hook. */
444 EMACS_INT post_command_idle_delay
;
446 /* List of deferred actions to be performed at a later time.
447 The precise format isn't relevant here; we just check whether it is nil. */
448 Lisp_Object Vdeferred_action_list
;
450 /* Function to call to handle deferred actions, when there are any. */
451 Lisp_Object Vdeferred_action_function
;
452 Lisp_Object Qdeferred_action_function
;
454 Lisp_Object Qinput_method_exit_on_first_char
;
455 Lisp_Object Qinput_method_use_echo_area
;
457 /* File in which we write all commands we read. */
460 /* Nonzero if input is available. */
463 /* Non-zero means force key bindings update in parse_menu_item. */
465 int update_menu_bindings
;
467 extern char *pending_malloc_warning
;
469 /* Circular buffer for pre-read keyboard input. */
471 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
473 /* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
475 The interrupt-level event handlers will never enqueue an event on a
476 frame which is not in Vframe_list, and once an event is dequeued,
477 internal_last_event_frame or the event itself points to the frame.
480 But while the event is sitting in the queue, it's completely
481 unprotected. Suppose the user types one command which will run for
482 a while and then delete a frame, and then types another event at
483 the frame that will be deleted, before the command gets around to
484 it. Suppose there are no references to this frame elsewhere in
485 Emacs, and a GC occurs before the second event is dequeued. Now we
486 have an event referring to a freed frame, which will crash Emacs
489 Similar things happen when an event on a scroll bar is enqueued; the
490 window may be deleted while the event is in the queue.
492 So, we use this vector to protect the Lisp_Objects in the event
493 queue. That way, they'll be dequeued as dead frames or windows,
494 but still valid Lisp objects.
496 If kbd_buffer[i].kind != NO_EVENT, then
498 AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
499 AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
501 static Lisp_Object kbd_buffer_gcpro
;
503 /* Pointer to next available character in kbd_buffer.
504 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
505 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
506 next available char is in kbd_buffer[0]. */
507 static struct input_event
*kbd_fetch_ptr
;
509 /* Pointer to next place to store character in kbd_buffer. This
510 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
511 character should go in kbd_buffer[0]. */
512 static struct input_event
* volatile kbd_store_ptr
;
514 /* The above pair of variables forms a "queue empty" flag. When we
515 enqueue a non-hook event, we increment kbd_store_ptr. When we
516 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
517 there is input available iff the two pointers are not equal.
519 Why not just have a flag set and cleared by the enqueuing and
520 dequeuing functions? Such a flag could be screwed up by interrupts
521 at inopportune times. */
523 /* If this flag is non-nil, we check mouse_moved to see when the
524 mouse moves, and motion events will appear in the input stream.
525 Otherwise, mouse motion is ignored. */
526 Lisp_Object do_mouse_tracking
;
528 /* Symbols to head events. */
529 Lisp_Object Qmouse_movement
;
530 Lisp_Object Qscroll_bar_movement
;
531 Lisp_Object Qswitch_frame
;
532 Lisp_Object Qdelete_frame
;
533 Lisp_Object Qiconify_frame
;
534 Lisp_Object Qmake_frame_visible
;
535 Lisp_Object Qselect_window
;
536 Lisp_Object Qhelp_echo
;
538 /* Symbols to denote kinds of events. */
539 Lisp_Object Qfunction_key
;
540 Lisp_Object Qmouse_click
;
542 Lisp_Object Qlanguage_change
;
544 Lisp_Object Qdrag_n_drop
;
545 Lisp_Object Qsave_session
;
547 /* Lisp_Object Qmouse_movement; - also an event header */
549 /* Properties of event headers. */
550 Lisp_Object Qevent_kind
;
551 Lisp_Object Qevent_symbol_elements
;
553 /* menu item parts */
554 Lisp_Object Qmenu_alias
;
555 Lisp_Object Qmenu_enable
;
556 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
557 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
558 extern Lisp_Object Vdefine_key_rebound_commands
;
559 extern Lisp_Object Qmenu_item
;
561 /* An event header symbol HEAD may have a property named
562 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
563 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
564 mask of modifiers applied to it. If present, this is used to help
565 speed up parse_modifiers. */
566 Lisp_Object Qevent_symbol_element_mask
;
568 /* An unmodified event header BASE may have a property named
569 Qmodifier_cache, which is an alist mapping modifier masks onto
570 modified versions of BASE. If present, this helps speed up
572 Lisp_Object Qmodifier_cache
;
574 /* Symbols to use for parts of windows. */
575 Lisp_Object Qmode_line
;
576 Lisp_Object Qvertical_line
;
577 Lisp_Object Qvertical_scroll_bar
;
578 Lisp_Object Qmenu_bar
;
579 extern Lisp_Object Qleft_margin
, Qright_margin
;
580 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
581 extern Lisp_Object QCmap
;
583 Lisp_Object
recursive_edit_unwind (), command_loop ();
584 Lisp_Object
Fthis_command_keys ();
585 Lisp_Object Qextended_command_history
;
586 EMACS_TIME
timer_check ();
588 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
590 extern char *x_get_keysym_name ();
592 static void record_menu_key ();
593 static int echo_length ();
595 Lisp_Object Qpolling_period
;
597 /* List of absolute timers. Appears in order of next scheduled event. */
598 Lisp_Object Vtimer_list
;
600 /* List of idle time timers. Appears in order of next scheduled event. */
601 Lisp_Object Vtimer_idle_list
;
603 /* Incremented whenever a timer is run. */
606 extern Lisp_Object Vprint_level
, Vprint_length
;
608 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
610 EMACS_TIME
*input_available_clear_time
;
612 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
613 Default is 1 if INTERRUPT_INPUT is defined. */
616 /* Nonzero while interrupts are temporarily deferred during redisplay. */
617 int interrupts_deferred
;
619 /* Allow m- file to inhibit use of FIONREAD. */
620 #ifdef BROKEN_FIONREAD
624 /* We are unable to use interrupts if FIONREAD is not available,
625 so flush SIGIO so we won't try. */
632 /* If we support a window system, turn on the code to poll periodically
633 to detect C-g. It isn't actually used when doing interrupt input. */
634 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
635 #define POLL_FOR_INPUT
638 /* After a command is executed, if point is moved into a region that
639 has specific properties (e.g. composition, display), we adjust
640 point to the boundary of the region. But, if a command sets this
641 variable to non-nil, we suppress this point adjustment. This
642 variable is set to nil before reading a command. */
644 Lisp_Object Vdisable_point_adjustment
;
646 /* If non-nil, always disable point adjustment. */
648 Lisp_Object Vglobal_disable_point_adjustment
;
650 /* The time when Emacs started being idle. */
652 static EMACS_TIME timer_idleness_start_time
;
654 /* After Emacs stops being idle, this saves the last value
655 of timer_idleness_start_time from when it was idle. */
657 static EMACS_TIME timer_last_idleness_start_time
;
660 /* Global variable declarations. */
662 /* Function for init_keyboard to call with no args (if nonzero). */
663 void (*keyboard_init_hook
) ();
665 static int read_avail_input
P_ ((int));
666 static void get_input_pending
P_ ((int *, int));
667 static void get_filtered_input_pending
P_ ((int *, int, int));
668 static int readable_events
P_ ((int));
669 static int readable_filtered_events
P_ ((int, int));
670 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
671 Lisp_Object
, int *));
672 static Lisp_Object
read_char_x_menu_prompt ();
673 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
675 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
677 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
678 enum scroll_bar_part
,
679 Lisp_Object
, Lisp_Object
,
682 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
683 Lisp_Object
, char **,
684 Lisp_Object
*, unsigned));
685 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
686 static int parse_solitary_modifier
P_ ((Lisp_Object
));
687 static int parse_solitary_modifier ();
688 static void save_getcjmp
P_ ((jmp_buf));
689 static void save_getcjmp ();
690 static void restore_getcjmp
P_ ((jmp_buf));
691 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
692 static void clear_event
P_ ((struct input_event
*));
693 static void any_kboard_state
P_ ((void));
694 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
695 static void handle_interrupt
P_ ((void));
697 /* Nonzero means don't try to suspend even if the operating system seems
699 static int cannot_suspend
;
701 /* Install the string STR as the beginning of the string of echoing,
702 so that it serves as a prompt for the next character.
703 Also start echoing. */
709 current_kboard
->echo_string
= str
;
710 current_kboard
->echo_after_prompt
= SCHARS (str
);
714 /* Add C to the echo string, if echoing is going on.
715 C can be a character, which is printed prettily ("M-C-x" and all that
716 jazz), or a symbol, whose name is printed. */
722 if (current_kboard
->immediate_echo
)
724 int size
= KEY_DESCRIPTION_SIZE
+ 100;
725 char *buffer
= (char *) alloca (size
);
727 Lisp_Object echo_string
;
729 echo_string
= current_kboard
->echo_string
;
731 /* If someone has passed us a composite event, use its head symbol. */
736 ptr
= push_key_description (XINT (c
), ptr
, 1);
738 else if (SYMBOLP (c
))
740 Lisp_Object name
= SYMBOL_NAME (c
);
741 int nbytes
= SBYTES (name
);
743 if (size
- (ptr
- buffer
) < nbytes
)
745 int offset
= ptr
- buffer
;
746 size
= max (2 * size
, size
+ nbytes
);
747 buffer
= (char *) alloca (size
);
748 ptr
= buffer
+ offset
;
751 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
752 STRING_MULTIBYTE (name
), 1);
755 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
758 const char *text
= " (Type ? for further options)";
759 int len
= strlen (text
);
761 if (size
- (ptr
- buffer
) < len
)
763 int offset
= ptr
- buffer
;
765 buffer
= (char *) alloca (size
);
766 ptr
= buffer
+ offset
;
769 bcopy (text
, ptr
, len
);
773 /* Replace a dash from echo_dash with a space, otherwise
774 add a space at the end as a separator between keys. */
775 if (STRINGP (echo_string
)
776 && SCHARS (echo_string
) > 1)
778 Lisp_Object last_char
, prev_char
, idx
;
780 idx
= make_number (SCHARS (echo_string
) - 2);
781 prev_char
= Faref (echo_string
, idx
);
783 idx
= make_number (SCHARS (echo_string
) - 1);
784 last_char
= Faref (echo_string
, idx
);
786 /* We test PREV_CHAR to make sure this isn't the echoing
788 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
789 Faset (echo_string
, idx
, make_number (' '));
791 echo_string
= concat2 (echo_string
, build_string (" "));
794 current_kboard
->echo_string
795 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
801 /* Temporarily add a dash to the end of the echo string if it's not
802 empty, so that it serves as a mini-prompt for the very next character. */
807 /* Do nothing if not echoing at all. */
808 if (NILP (current_kboard
->echo_string
))
811 if (!current_kboard
->immediate_echo
812 && SCHARS (current_kboard
->echo_string
) == 0)
815 /* Do nothing if we just printed a prompt. */
816 if (current_kboard
->echo_after_prompt
817 == SCHARS (current_kboard
->echo_string
))
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 command_loop_level
++;
1019 update_mode_lines
= 1;
1021 if (command_loop_level
1022 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1023 buffer
= Fcurrent_buffer ();
1027 /* If we leave recursive_edit_1 below with a `throw' for instance,
1028 like it is done in the splash screen display, we have to
1029 make sure that we restore single_kboard as command_loop_1
1030 would have done if it were left normally. */
1031 record_unwind_protect (recursive_edit_unwind
,
1032 Fcons (buffer
, single_kboard
? Qt
: Qnil
));
1034 recursive_edit_1 ();
1035 return unbind_to (count
, Qnil
);
1039 recursive_edit_unwind (info
)
1042 if (BUFFERP (XCAR (info
)))
1043 Fset_buffer (XCAR (info
));
1045 if (NILP (XCDR (info
)))
1046 any_kboard_state ();
1048 single_kboard_state ();
1050 command_loop_level
--;
1051 update_mode_lines
= 1;
1060 #if 0 /* Theory: if there's anything in Vunread_command_events,
1061 it will right away be read by read_key_sequence,
1062 and then if we do switch KBOARDS, it will go into the side
1063 queue then. So we don't need to do anything special here -- rms. */
1064 if (CONSP (Vunread_command_events
))
1066 current_kboard
->kbd_queue
1067 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1068 current_kboard
->kbd_queue_has_data
= 1;
1070 Vunread_command_events
= Qnil
;
1076 /* Switch to the single-kboard state, making current_kboard
1077 the only KBOARD from which further input is accepted. */
1080 single_kboard_state ()
1087 /* Maintain a stack of kboards, so other parts of Emacs
1088 can switch temporarily to the kboard of a given frame
1089 and then revert to the previous status. */
1094 struct kboard_stack
*next
;
1097 static struct kboard_stack
*kboard_stack
;
1100 push_frame_kboard (f
)
1104 struct kboard_stack
*p
1105 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1107 p
->next
= kboard_stack
;
1108 p
->kboard
= current_kboard
;
1111 current_kboard
= FRAME_KBOARD (f
);
1119 struct kboard_stack
*p
= kboard_stack
;
1120 current_kboard
= p
->kboard
;
1121 kboard_stack
= p
->next
;
1126 /* Handle errors that are not handled at inner levels
1127 by printing an error message and returning to the editor command loop. */
1133 Lisp_Object old_level
, old_length
;
1134 char macroerror
[50];
1136 #ifdef HAVE_X_WINDOWS
1137 if (display_hourglass_p
)
1138 cancel_hourglass ();
1141 if (!NILP (executing_macro
))
1143 if (executing_macro_iterations
== 1)
1144 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1146 sprintf (macroerror
, "After %d kbd macro iterations: ",
1147 executing_macro_iterations
);
1152 Vstandard_output
= Qt
;
1153 Vstandard_input
= Qt
;
1154 Vexecuting_macro
= Qnil
;
1155 executing_macro
= Qnil
;
1156 current_kboard
->Vprefix_arg
= Qnil
;
1157 current_kboard
->Vlast_prefix_arg
= Qnil
;
1160 /* Avoid unquittable loop if data contains a circular list. */
1161 old_level
= Vprint_level
;
1162 old_length
= Vprint_length
;
1163 XSETFASTINT (Vprint_level
, 10);
1164 XSETFASTINT (Vprint_length
, 10);
1165 cmd_error_internal (data
, macroerror
);
1166 Vprint_level
= old_level
;
1167 Vprint_length
= old_length
;
1171 Vinhibit_quit
= Qnil
;
1173 any_kboard_state ();
1176 return make_number (0);
1179 /* Take actions on handling an error. DATA is the data that describes
1182 CONTEXT is a C-string containing ASCII characters only which
1183 describes the context in which the error happened. If we need to
1184 generalize CONTEXT to allow multibyte characters, make it a Lisp
1188 cmd_error_internal (data
, context
)
1193 int kill_emacs_p
= 0;
1194 struct frame
*sf
= SELECTED_FRAME ();
1198 clear_message (1, 0);
1200 /* If the window system or terminal frame hasn't been initialized
1201 yet, or we're not interactive, it's best to dump this message out
1202 to stderr and exit. */
1203 if (!sf
->glyphs_initialized_p
1204 /* This is the case of the frame dumped with Emacs, when we're
1205 running under a window system. */
1206 || FRAME_INITIAL_P (sf
)
1209 stream
= Qexternal_debugging_output
;
1215 message_log_maybe_newline ();
1220 /* The immediate context is not interesting for Quits,
1221 since they are asyncronous. */
1222 if (EQ (XCAR (data
), Qquit
))
1223 Vsignaling_function
= Qnil
;
1225 print_error_message (data
, stream
, context
, Vsignaling_function
);
1227 Vsignaling_function
= Qnil
;
1229 /* If the window system or terminal frame hasn't been initialized
1230 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1234 Fkill_emacs (make_number (-1));
1238 Lisp_Object
command_loop_1 ();
1239 Lisp_Object
command_loop_2 ();
1240 Lisp_Object
top_level_1 ();
1242 /* Entry to editor-command-loop.
1243 This level has the catches for exiting/returning to editor command loop.
1244 It returns nil to exit recursive edit, t to abort it. */
1249 if (command_loop_level
> 0 || minibuf_level
> 0)
1252 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1253 executing_macro
= Qnil
;
1259 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1260 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1261 executing_macro
= Qnil
;
1263 /* End of file in -batch run causes exit here. */
1269 /* Here we catch errors in execution of commands within the
1270 editing loop, and reenter the editing loop.
1271 When there is an error, cmd_error runs and returns a non-nil
1272 value to us. A value of nil means that command_loop_1 itself
1273 returned due to end of file (or end of kbd macro). */
1278 register Lisp_Object val
;
1281 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1282 while (!NILP (val
));
1290 return Feval (Vtop_level
);
1296 /* On entry to the outer level, run the startup file */
1297 if (!NILP (Vtop_level
))
1298 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1299 else if (!NILP (Vpurify_flag
))
1300 message ("Bare impure Emacs (standard Lisp code not loaded)");
1302 message ("Bare Emacs (standard Lisp code not loaded)");
1306 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1307 doc
: /* Exit all recursive editing levels. */)
1310 #ifdef HAVE_X_WINDOWS
1311 if (display_hourglass_p
)
1312 cancel_hourglass ();
1314 return Fthrow (Qtop_level
, Qnil
);
1317 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1318 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1321 if (command_loop_level
> 0 || minibuf_level
> 0)
1322 Fthrow (Qexit
, Qnil
);
1324 error ("No recursive edit is in progress");
1328 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1329 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1332 if (command_loop_level
> 0 || minibuf_level
> 0)
1335 error ("No recursive edit is in progress");
1339 /* This is the actual command reading loop,
1340 sans error-handling encapsulation. */
1342 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1344 void safe_run_hooks
P_ ((Lisp_Object
));
1345 static void adjust_point_for_property
P_ ((int, int));
1347 /* Cancel hourglass from protect_unwind.
1349 #ifdef HAVE_X_WINDOWS
1351 cancel_hourglass_unwind (arg
)
1354 cancel_hourglass ();
1364 Lisp_Object keybuf
[30];
1368 struct buffer
*prev_buffer
= NULL
;
1370 int was_locked
= single_kboard
;
1372 int already_adjusted
;
1374 current_kboard
->Vprefix_arg
= Qnil
;
1375 current_kboard
->Vlast_prefix_arg
= Qnil
;
1376 Vdeactivate_mark
= Qnil
;
1377 waiting_for_input
= 0;
1381 this_command_key_count
= 0;
1382 this_command_key_count_reset
= 0;
1383 this_single_command_key_start
= 0;
1385 if (NILP (Vmemory_full
))
1387 /* Make sure this hook runs after commands that get errors and
1388 throw to top level. */
1389 /* Note that the value cell will never directly contain nil
1390 if the symbol is a local variable. */
1391 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1392 safe_run_hooks (Qpost_command_hook
);
1394 /* If displaying a message, resize the echo area window to fit
1395 that message's size exactly. */
1396 if (!NILP (echo_area_buffer
[0]))
1397 resize_echo_area_exactly ();
1399 if (!NILP (Vdeferred_action_list
))
1400 call0 (Vdeferred_action_function
);
1402 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1404 if (NILP (Vunread_command_events
)
1405 && NILP (Vunread_input_method_events
)
1406 && NILP (Vunread_post_input_method_events
)
1407 && NILP (Vexecuting_macro
)
1408 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1409 safe_run_hooks (Qpost_command_idle_hook
);
1413 Vmemory_full
= Qnil
;
1415 /* Do this after running Vpost_command_hook, for consistency. */
1416 current_kboard
->Vlast_command
= Vthis_command
;
1417 current_kboard
->Vreal_last_command
= real_this_command
;
1421 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1424 /* Make sure the current window's buffer is selected. */
1425 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1426 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1428 /* Display any malloc warning that just came out. Use while because
1429 displaying one warning can cause another. */
1431 while (pending_malloc_warning
)
1432 display_malloc_warning ();
1436 Vdeactivate_mark
= Qnil
;
1438 /* If minibuffer on and echo area in use,
1439 wait a short time and redraw minibuffer. */
1442 && !NILP (echo_area_buffer
[0])
1443 && EQ (minibuf_window
, echo_area_window
)
1444 && NUMBERP (Vminibuffer_message_timeout
))
1446 /* Bind inhibit-quit to t so that C-g gets read in
1447 rather than quitting back to the minibuffer. */
1448 int count
= SPECPDL_INDEX ();
1449 specbind (Qinhibit_quit
, Qt
);
1451 Fsit_for (Vminibuffer_message_timeout
, Qnil
, Qnil
);
1452 /* Clear the echo area. */
1454 safe_run_hooks (Qecho_area_clear_hook
);
1456 unbind_to (count
, Qnil
);
1458 /* If a C-g came in before, treat it as input now. */
1459 if (!NILP (Vquit_flag
))
1462 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1467 alloca (0); /* Cause a garbage collection now */
1468 /* Since we can free the most stuff here. */
1469 #endif /* C_ALLOCA */
1472 /* Select the frame that the last event came from. Usually,
1473 switch-frame events will take care of this, but if some lisp
1474 code swallows a switch-frame event, we'll fix things up here.
1475 Is this a good idea? */
1476 if (FRAMEP (internal_last_event_frame
)
1477 && !EQ (internal_last_event_frame
, selected_frame
))
1478 Fselect_frame (internal_last_event_frame
, Qnil
);
1480 /* If it has changed current-menubar from previous value,
1481 really recompute the menubar from the value. */
1482 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1483 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1484 call0 (Qrecompute_lucid_menubar
);
1486 before_command_key_count
= this_command_key_count
;
1487 before_command_echo_length
= echo_length ();
1489 Vthis_command
= Qnil
;
1490 real_this_command
= Qnil
;
1492 /* Read next key sequence; i gets its length. */
1493 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1496 /* A filter may have run while we were reading the input. */
1497 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1499 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1500 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1504 /* Now we have read a key sequence of length I,
1505 or else I is 0 and we found end of file. */
1507 if (i
== 0) /* End of file -- happens only in */
1508 return Qnil
; /* a kbd macro, at the end. */
1509 /* -1 means read_key_sequence got a menu that was rejected.
1510 Just loop around and read another command. */
1514 this_command_key_count
= 0;
1515 this_command_key_count_reset
= 0;
1516 this_single_command_key_start
= 0;
1520 last_command_char
= keybuf
[i
- 1];
1522 /* If the previous command tried to force a specific window-start,
1523 forget about that, in case this command moves point far away
1524 from that position. But also throw away beg_unchanged and
1525 end_unchanged information in that case, so that redisplay will
1526 update the whole window properly. */
1527 if (!NILP (XWINDOW (selected_window
)->force_start
))
1530 XWINDOW (selected_window
)->force_start
= Qnil
;
1531 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1532 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1535 cmd
= read_key_sequence_cmd
;
1536 if (!NILP (Vexecuting_macro
))
1538 if (!NILP (Vquit_flag
))
1540 Vexecuting_macro
= Qt
;
1541 QUIT
; /* Make some noise. */
1542 /* Will return since macro now empty. */
1546 /* Do redisplay processing after this command except in special
1547 cases identified below. */
1548 prev_buffer
= current_buffer
;
1549 prev_modiff
= MODIFF
;
1550 last_point_position
= PT
;
1551 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1553 /* By default, we adjust point to a boundary of a region that
1554 has such a property that should be treated intangible
1555 (e.g. composition, display). But, some commands will set
1556 this variable differently. */
1557 Vdisable_point_adjustment
= Qnil
;
1559 /* Process filters and timers may have messed with deactivate-mark.
1560 reset it before we execute the command. */
1561 Vdeactivate_mark
= Qnil
;
1563 /* Remap command through active keymaps */
1564 Vthis_original_command
= cmd
;
1568 if (cmd1
= Fcommand_remapping (cmd
), !NILP (cmd1
))
1572 /* Execute the command. */
1574 Vthis_command
= cmd
;
1575 real_this_command
= cmd
;
1576 /* Note that the value cell will never directly contain nil
1577 if the symbol is a local variable. */
1578 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1579 safe_run_hooks (Qpre_command_hook
);
1581 already_adjusted
= 0;
1583 if (NILP (Vthis_command
))
1585 /* nil means key is undefined. */
1587 current_kboard
->defining_kbd_macro
= Qnil
;
1588 update_mode_lines
= 1;
1589 current_kboard
->Vprefix_arg
= Qnil
;
1593 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1595 /* In case we jump to directly_done. */
1596 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1598 /* Recognize some common commands in common situations and
1599 do them directly. */
1600 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1602 struct Lisp_Char_Table
*dp
1603 = window_display_table (XWINDOW (selected_window
));
1604 lose
= FETCH_CHAR (PT_BYTE
);
1606 if (! NILP (Vpost_command_hook
))
1607 /* Put this before calling adjust_point_for_property
1608 so it will only get called once in any case. */
1610 if (current_buffer
== prev_buffer
1611 && last_point_position
!= PT
1612 && NILP (Vdisable_point_adjustment
)
1613 && NILP (Vglobal_disable_point_adjustment
))
1614 adjust_point_for_property (last_point_position
, 0);
1615 already_adjusted
= 1;
1616 if (PT
== last_point_position
+ 1
1618 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1619 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1620 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1621 && (lose
>= 0x20 && lose
< 0x7f)))
1622 : (lose
>= 0x20 && lose
< 0x7f))
1623 /* To extract the case of continuation on
1624 wide-column characters. */
1625 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE
)) == 1)
1626 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1628 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1630 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1632 && !windows_or_buffers_changed
1633 && EQ (current_buffer
->selective_display
, Qnil
)
1634 && !detect_input_pending ()
1635 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1636 && NILP (Vexecuting_macro
))
1637 direct_output_forward_char (1);
1640 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1642 struct Lisp_Char_Table
*dp
1643 = window_display_table (XWINDOW (selected_window
));
1645 lose
= FETCH_CHAR (PT_BYTE
);
1646 if (! NILP (Vpost_command_hook
))
1648 if (current_buffer
== prev_buffer
1649 && last_point_position
!= PT
1650 && NILP (Vdisable_point_adjustment
)
1651 && NILP (Vglobal_disable_point_adjustment
))
1652 adjust_point_for_property (last_point_position
, 0);
1653 already_adjusted
= 1;
1654 if (PT
== last_point_position
- 1
1656 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1657 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1658 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1659 && (lose
>= 0x20 && lose
< 0x7f)))
1660 : (lose
>= 0x20 && lose
< 0x7f))
1661 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1663 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1665 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1667 && !windows_or_buffers_changed
1668 && EQ (current_buffer
->selective_display
, Qnil
)
1669 && !detect_input_pending ()
1670 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1671 && NILP (Vexecuting_macro
))
1672 direct_output_forward_char (-1);
1675 else if (EQ (Vthis_command
, Qself_insert_command
)
1676 /* Try this optimization only on char keystrokes. */
1677 && NATNUMP (last_command_char
)
1678 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1681 = translate_char (Vtranslation_table_for_input
,
1682 XFASTINT (last_command_char
), 0, 0, 0);
1684 if (NILP (Vexecuting_macro
)
1685 && !EQ (minibuf_window
, selected_window
))
1687 if (!nonundocount
|| nonundocount
>= 20)
1695 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1697 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1699 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1701 || MODIFF
<= SAVE_MODIFF
1702 || windows_or_buffers_changed
1703 || !EQ (current_buffer
->selective_display
, Qnil
)
1704 || detect_input_pending ()
1705 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1706 || !NILP (Vexecuting_macro
));
1708 value
= internal_self_insert (c
, 0);
1713 if (! NILP (Vpost_command_hook
))
1714 /* Put this before calling adjust_point_for_property
1715 so it will only get called once in any case. */
1718 /* VALUE == 1 when AFTER-CHANGE functions are
1719 installed which is the case most of the time
1720 because FONT-LOCK installs one. */
1721 if (!lose
&& !value
)
1722 direct_output_for_insert (c
);
1727 /* Here for a command that isn't executed directly */
1730 #ifdef HAVE_X_WINDOWS
1731 int scount
= SPECPDL_INDEX ();
1733 if (display_hourglass_p
1734 && NILP (Vexecuting_macro
))
1736 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1742 if (NILP (current_kboard
->Vprefix_arg
))
1744 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1746 #ifdef HAVE_X_WINDOWS
1747 /* Do not check display_hourglass_p here, because
1748 Fcommand_execute could change it, but we should cancel
1749 hourglass cursor anyway.
1750 But don't cancel the hourglass within a macro
1751 just because a command in the macro finishes. */
1752 if (NILP (Vexecuting_macro
))
1753 unbind_to (scount
, Qnil
);
1758 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1760 /* Note that the value cell will never directly contain nil
1761 if the symbol is a local variable. */
1762 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1763 safe_run_hooks (Qpost_command_hook
);
1765 /* If displaying a message, resize the echo area window to fit
1766 that message's size exactly. */
1767 if (!NILP (echo_area_buffer
[0]))
1768 resize_echo_area_exactly ();
1770 if (!NILP (Vdeferred_action_list
))
1771 safe_run_hooks (Qdeferred_action_function
);
1773 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1775 if (NILP (Vunread_command_events
)
1776 && NILP (Vunread_input_method_events
)
1777 && NILP (Vunread_post_input_method_events
)
1778 && NILP (Vexecuting_macro
)
1779 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1780 safe_run_hooks (Qpost_command_idle_hook
);
1783 /* If there is a prefix argument,
1784 1) We don't want Vlast_command to be ``universal-argument''
1785 (that would be dumb), so don't set Vlast_command,
1786 2) we want to leave echoing on so that the prefix will be
1787 echoed as part of this key sequence, so don't call
1789 3) we want to leave this_command_key_count non-zero, so that
1790 read_char will realize that it is re-reading a character, and
1791 not echo it a second time.
1793 If the command didn't actually create a prefix arg,
1794 but is merely a frame event that is transparent to prefix args,
1795 then the above doesn't apply. */
1796 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1798 current_kboard
->Vlast_command
= Vthis_command
;
1799 current_kboard
->Vreal_last_command
= real_this_command
;
1801 this_command_key_count
= 0;
1802 this_command_key_count_reset
= 0;
1803 this_single_command_key_start
= 0;
1806 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1808 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1810 /* We could also call `deactivate'mark'. */
1811 if (EQ (Vtransient_mark_mode
, Qlambda
))
1812 Vtransient_mark_mode
= Qnil
;
1815 current_buffer
->mark_active
= Qnil
;
1816 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1819 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1820 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1825 if (current_buffer
== prev_buffer
1826 && last_point_position
!= PT
1827 && NILP (Vdisable_point_adjustment
)
1828 && NILP (Vglobal_disable_point_adjustment
)
1829 && !already_adjusted
)
1830 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
1832 /* Install chars successfully executed in kbd macro. */
1834 if (!NILP (current_kboard
->defining_kbd_macro
)
1835 && NILP (current_kboard
->Vprefix_arg
))
1836 finalize_kbd_macro_chars ();
1840 any_kboard_state ();
1845 extern Lisp_Object Qcomposition
, Qdisplay
;
1847 /* Adjust point to a boundary of a region that has such a property
1848 that should be treated intangible. For the moment, we check
1849 `composition', `display' and `invisible' properties.
1850 LAST_PT is the last position of point. */
1852 extern Lisp_Object Qafter_string
, Qbefore_string
;
1853 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
1856 adjust_point_for_property (last_pt
, modified
)
1861 Lisp_Object val
, overlay
, tmp
;
1862 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
1865 /* FIXME: cycling is probably not necessary because these properties
1866 can't be usefully combined anyway. */
1867 while (check_composition
|| check_display
|| check_invisible
)
1869 if (check_composition
1870 && PT
> BEGV
&& PT
< ZV
1871 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
1872 && COMPOSITION_VALID_P (beg
, end
, val
)
1873 && beg
< PT
/* && end > PT <- It's always the case. */
1874 && (last_pt
<= beg
|| last_pt
>= end
))
1877 SET_PT (PT
< last_pt
? beg
: end
);
1878 check_display
= check_invisible
= 1;
1880 check_composition
= 0;
1882 && PT
> BEGV
&& PT
< ZV
1883 && !NILP (val
= get_char_property_and_overlay
1884 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1885 && display_prop_intangible_p (val
)
1886 && (!OVERLAYP (overlay
)
1887 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1888 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1889 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1890 && beg
< PT
) /* && end > PT <- It's always the case. */
1893 SET_PT (PT
< last_pt
? beg
: end
);
1894 check_composition
= check_invisible
= 1;
1897 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1899 int inv
, ellipsis
= 0;
1902 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1904 && !NILP (val
= get_char_property_and_overlay
1905 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1906 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1908 ellipsis
= ellipsis
|| inv
> 1
1909 || (OVERLAYP (overlay
)
1910 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1911 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1912 tmp
= Fnext_single_char_property_change
1913 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1914 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1917 && !NILP (val
= get_char_property_and_overlay
1918 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1919 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1921 ellipsis
= ellipsis
|| inv
> 1
1922 || (OVERLAYP (overlay
)
1923 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1924 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1925 tmp
= Fprevious_single_char_property_change
1926 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1927 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1930 /* Move away from the inside area. */
1931 if (beg
< PT
&& end
> PT
)
1933 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1934 /* We haven't moved yet (so we don't need to fear
1935 infinite-looping) and we were outside the range
1936 before (so either end of the range still corresponds
1937 to a move in the right direction): pretend we moved
1938 less than we actually did, so that we still have
1939 more freedom below in choosing which end of the range
1941 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1942 /* We either have moved already or the last point
1943 was already in the range: we don't get to choose
1944 which end of the range we have to go to. */
1945 : (PT
< last_pt
? beg
: end
));
1946 check_composition
= check_display
= 1;
1948 xassert (PT
== beg
|| PT
== end
);
1949 /* Pretend the area doesn't exist if the buffer is not
1951 if (!modified
&& !ellipsis
&& beg
< end
)
1953 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1954 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1955 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1956 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1957 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1958 /* We've already moved as far as we can. Trying to go
1959 to the other end would mean moving backwards and thus
1960 could lead to an infinite loop. */
1962 else if (val
= get_pos_property (make_number (PT
),
1964 TEXT_PROP_MEANS_INVISIBLE (val
)
1965 && (val
= get_pos_property
1966 (make_number (PT
== beg
? end
: beg
),
1968 !TEXT_PROP_MEANS_INVISIBLE (val
)))
1969 (check_composition
= check_display
= 1,
1970 SET_PT (PT
== beg
? end
: beg
));
1973 check_invisible
= 0;
1977 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1980 safe_run_hooks_1 (hook
)
1983 return call1 (Vrun_hooks
, Vinhibit_quit
);
1986 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1989 safe_run_hooks_error (data
)
1992 Lisp_Object args
[3];
1993 args
[0] = build_string ("Error in %s: %s");
1994 args
[1] = Vinhibit_quit
;
1997 return Fset (Vinhibit_quit
, Qnil
);
2000 /* If we get an error while running the hook, cause the hook variable
2001 to be nil. Also inhibit quits, so that C-g won't cause the hook
2002 to mysteriously evaporate. */
2005 safe_run_hooks (hook
)
2008 int count
= SPECPDL_INDEX ();
2009 specbind (Qinhibit_quit
, hook
);
2011 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2013 unbind_to (count
, Qnil
);
2017 /* Number of seconds between polling for input. This is a Lisp
2018 variable that can be bound. */
2020 EMACS_INT polling_period
;
2022 /* Nonzero means polling for input is temporarily suppressed. */
2024 int poll_suppress_count
;
2026 /* Asynchronous timer for polling. */
2028 struct atimer
*poll_timer
;
2031 #ifdef POLL_FOR_INPUT
2033 /* Poll for input, so what we catch a C-g if it comes in. This
2034 function is called from x_make_frame_visible, see comment
2040 if (interrupt_input_blocked
== 0
2041 && !waiting_for_input
)
2042 read_avail_input (0);
2045 /* Timer callback function for poll_timer. TIMER is equal to
2049 poll_for_input (timer
)
2050 struct atimer
*timer
;
2052 if (poll_suppress_count
== 0)
2053 poll_for_input_1 ();
2056 #endif /* POLL_FOR_INPUT */
2058 /* Begin signals to poll for input, if they are appropriate.
2059 This function is called unconditionally from various places. */
2064 #ifdef POLL_FOR_INPUT
2065 /* XXX This condition was (read_socket_hook && !interrupt_input),
2066 but read_socket_hook is not global anymore. Let's pretend that
2068 if (!interrupt_input
)
2070 /* Turn alarm handling on unconditionally. It might have
2071 been turned off in process.c. */
2072 turn_on_atimers (1);
2074 /* If poll timer doesn't exist, are we need one with
2075 a different interval, start a new one. */
2076 if (poll_timer
== NULL
2077 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2079 EMACS_TIME interval
;
2082 cancel_atimer (poll_timer
);
2084 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2085 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2086 poll_for_input
, NULL
);
2089 /* Let the timer's callback function poll for input
2090 if this becomes zero. */
2091 --poll_suppress_count
;
2096 /* Nonzero if we are using polling to handle input asynchronously. */
2099 input_polling_used ()
2101 #ifdef POLL_FOR_INPUT
2102 /* XXX This condition was (read_socket_hook && !interrupt_input),
2103 but read_socket_hook is not global anymore. Let's pretend that
2105 return !interrupt_input
;
2111 /* Turn off polling. */
2116 #ifdef POLL_FOR_INPUT
2117 /* XXX This condition was (read_socket_hook && !interrupt_input),
2118 but read_socket_hook is not global anymore. Let's pretend that
2120 if (!interrupt_input
)
2121 ++poll_suppress_count
;
2125 /* Set the value of poll_suppress_count to COUNT
2126 and start or stop polling accordingly. */
2129 set_poll_suppress_count (count
)
2132 #ifdef POLL_FOR_INPUT
2133 if (count
== 0 && poll_suppress_count
!= 0)
2135 poll_suppress_count
= 1;
2138 else if (count
!= 0 && poll_suppress_count
== 0)
2142 poll_suppress_count
= count
;
2146 /* Bind polling_period to a value at least N.
2147 But don't decrease it. */
2150 bind_polling_period (n
)
2153 #ifdef POLL_FOR_INPUT
2154 int new = polling_period
;
2159 stop_other_atimers (poll_timer
);
2161 specbind (Qpolling_period
, make_number (new));
2162 /* Start a new alarm with the new period. */
2167 /* Apply the control modifier to CHARACTER. */
2173 /* Save the upper bits here. */
2174 int upper
= c
& ~0177;
2178 /* Everything in the columns containing the upper-case letters
2179 denotes a control character. */
2180 if (c
>= 0100 && c
< 0140)
2184 /* Set the shift modifier for a control char
2185 made from a shifted letter. But only for letters! */
2186 if (oc
>= 'A' && oc
<= 'Z')
2187 c
|= shift_modifier
;
2190 /* The lower-case letters denote control characters too. */
2191 else if (c
>= 'a' && c
<= 'z')
2194 /* Include the bits for control and shift
2195 only if the basic ASCII code can't indicate them. */
2199 /* Replace the high bits. */
2200 c
|= (upper
& ~ctrl_modifier
);
2205 /* Display help echo in the echo area.
2207 HELP a string means display that string, HELP nil means clear the
2208 help echo. If HELP is a function, call it with OBJECT and POS as
2209 arguments; the function should return a help string or nil for
2210 none. For all other types of HELP evaluate it to obtain a string.
2212 WINDOW is the window in which the help was generated, if any.
2213 It is nil if not in a window.
2215 If OBJECT is a buffer, POS is the position in the buffer where the
2216 `help-echo' text property was found.
2218 If OBJECT is an overlay, that overlay has a `help-echo' property,
2219 and POS is the position in the overlay's buffer under the mouse.
2221 If OBJECT is a string (an overlay string or a string displayed with
2222 the `display' property). POS is the position in that string under
2225 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2226 echo overwrites a keystroke echo currently displayed in the echo
2229 Note: this function may only be called with HELP nil or a string
2230 from X code running asynchronously. */
2233 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2234 Lisp_Object help
, window
, object
, pos
;
2235 int ok_to_overwrite_keystroke_echo
;
2237 if (!NILP (help
) && !STRINGP (help
))
2239 if (FUNCTIONP (help
))
2241 Lisp_Object args
[4];
2246 help
= safe_call (4, args
);
2249 help
= safe_eval (help
);
2251 if (!STRINGP (help
))
2255 if (STRINGP (help
) || NILP (help
))
2257 if (!NILP (Vshow_help_function
))
2258 call1 (Vshow_help_function
, help
);
2259 else if (/* Don't overwrite minibuffer contents. */
2260 !MINI_WINDOW_P (XWINDOW (selected_window
))
2261 /* Don't overwrite a keystroke echo. */
2262 && (NILP (echo_message_buffer
)
2263 || ok_to_overwrite_keystroke_echo
)
2264 /* Don't overwrite a prompt. */
2265 && !cursor_in_echo_area
)
2269 int count
= SPECPDL_INDEX ();
2271 if (!help_echo_showing_p
)
2272 Vpre_help_message
= current_message ();
2274 specbind (Qmessage_truncate_lines
, Qt
);
2275 message3_nolog (help
, SBYTES (help
),
2276 STRING_MULTIBYTE (help
));
2277 unbind_to (count
, Qnil
);
2279 else if (STRINGP (Vpre_help_message
))
2281 message3_nolog (Vpre_help_message
,
2282 SBYTES (Vpre_help_message
),
2283 STRING_MULTIBYTE (Vpre_help_message
));
2284 Vpre_help_message
= Qnil
;
2290 help_echo_showing_p
= STRINGP (help
);
2296 /* Input of single characters from keyboard */
2298 Lisp_Object
print_help ();
2299 static Lisp_Object
kbd_buffer_get_event ();
2300 static void record_char ();
2303 static jmp_buf wrong_kboard_jmpbuf
;
2306 #define STOP_POLLING \
2307 do { if (! polling_stopped_here) stop_polling (); \
2308 polling_stopped_here = 1; } while (0)
2310 #define RESUME_POLLING \
2311 do { if (polling_stopped_here) start_polling (); \
2312 polling_stopped_here = 0; } while (0)
2314 /* read a character from the keyboard; call the redisplay if needed */
2315 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2316 -1 means do not do redisplay, but do do autosaving.
2319 /* The arguments MAPS and NMAPS are for menu prompting.
2320 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2322 PREV_EVENT is the previous input event, or nil if we are reading
2323 the first event of a key sequence (or not reading a key sequence).
2324 If PREV_EVENT is t, that is a "magic" value that says
2325 not to run input methods, but in other respects to act as if
2326 not reading a key sequence.
2328 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2329 if we used a mouse menu to read the input, or zero otherwise. If
2330 USED_MOUSE_MENU is null, we don't dereference it.
2332 Value is t if we showed a menu and the user rejected it. */
2335 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
2339 Lisp_Object prev_event
;
2340 int *used_mouse_menu
;
2342 volatile Lisp_Object c
;
2344 jmp_buf local_getcjmp
;
2346 volatile int key_already_recorded
= 0;
2347 Lisp_Object tem
, save
;
2348 volatile Lisp_Object previous_echo_area_message
;
2349 volatile Lisp_Object also_record
;
2350 volatile int reread
;
2351 struct gcpro gcpro1
, gcpro2
;
2352 EMACS_TIME last_idle_start
;
2353 int polling_stopped_here
= 0;
2357 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2358 before_command_key_count
= this_command_key_count
;
2359 before_command_echo_length
= echo_length ();
2362 previous_echo_area_message
= Qnil
;
2364 GCPRO2 (c
, previous_echo_area_message
);
2369 if (CONSP (Vunread_post_input_method_events
))
2371 c
= XCAR (Vunread_post_input_method_events
);
2372 Vunread_post_input_method_events
2373 = XCDR (Vunread_post_input_method_events
);
2375 /* Undo what read_char_x_menu_prompt did when it unread
2376 additional keys returned by Fx_popup_menu. */
2378 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2386 if (unread_command_char
!= -1)
2388 XSETINT (c
, unread_command_char
);
2389 unread_command_char
= -1;
2395 if (CONSP (Vunread_command_events
))
2397 c
= XCAR (Vunread_command_events
);
2398 Vunread_command_events
= XCDR (Vunread_command_events
);
2400 /* Undo what read_char_x_menu_prompt did when it unread
2401 additional keys returned by Fx_popup_menu. */
2403 && EQ (XCDR (c
), Qdisabled
)
2404 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2407 /* If the queued event is something that used the mouse,
2408 set used_mouse_menu accordingly. */
2410 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2411 *used_mouse_menu
= 1;
2414 goto reread_for_input_method
;
2417 if (CONSP (Vunread_input_method_events
))
2419 c
= XCAR (Vunread_input_method_events
);
2420 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2422 /* Undo what read_char_x_menu_prompt did when it unread
2423 additional keys returned by Fx_popup_menu. */
2425 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2429 goto reread_for_input_method
;
2432 this_command_key_count_reset
= 0;
2434 if (!NILP (Vexecuting_macro
))
2436 /* We set this to Qmacro; since that's not a frame, nobody will
2437 try to switch frames on us, and the selected window will
2440 Since this event came from a macro, it would be misleading to
2441 leave internal_last_event_frame set to wherever the last
2442 real event came from. Normally, a switch-frame event selects
2443 internal_last_event_frame after each command is read, but
2444 events read from a macro should never cause a new frame to be
2446 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2448 /* Exit the macro if we are at the end.
2449 Also, some things replace the macro with t
2450 to force an early exit. */
2451 if (EQ (Vexecuting_macro
, Qt
)
2452 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
2458 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
2459 if (STRINGP (Vexecuting_macro
)
2460 && (XINT (c
) & 0x80))
2461 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2463 executing_macro_index
++;
2468 if (!NILP (unread_switch_frame
))
2470 c
= unread_switch_frame
;
2471 unread_switch_frame
= Qnil
;
2473 /* This event should make it into this_command_keys, and get echoed
2474 again, so we do not set `reread'. */
2478 /* if redisplay was requested */
2479 if (commandflag
>= 0)
2481 /* If there is pending input, process any events which are not
2482 user-visible, such as X selection_request events. */
2484 || detect_input_pending_run_timers (0))
2485 swallow_events (0); /* may clear input_pending */
2487 /* Redisplay if no pending input. */
2488 while (!input_pending
)
2490 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2491 redisplay_preserve_echo_area (5);
2496 /* Normal case: no input arrived during redisplay. */
2499 /* Input arrived and pre-empted redisplay.
2500 Process any events which are not user-visible. */
2502 /* If that cleared input_pending, try again to redisplay. */
2506 /* Message turns off echoing unless more keystrokes turn it on again.
2508 The code in 20.x for the condition was
2510 1. echo_area_glyphs && *echo_area_glyphs
2511 2. && echo_area_glyphs != current_kboard->echobuf
2512 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2514 (1) means there's a current message displayed
2516 (2) means it's not the message from echoing from the current
2519 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2520 is set to a non-null value. This is done in read_char and it is
2521 set to echo_area_glyphs after a call to echo_char. That means
2522 ok_to_echo_at_next_pause is either null or
2523 current_kboard->echobuf with the appropriate current_kboard at
2526 So, condition (3) means in clear text ok_to_echo_at_next_pause
2527 must be either null, or the current message isn't from echoing at
2528 all, or it's from echoing from a different kboard than the
2531 if (/* There currently is something in the echo area. */
2532 !NILP (echo_area_buffer
[0])
2533 && (/* And it's either not from echoing. */
2534 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2535 /* Or it's an echo from a different kboard. */
2536 || echo_kboard
!= current_kboard
2537 /* Or we explicitly allow overwriting whatever there is. */
2538 || ok_to_echo_at_next_pause
== NULL
))
2543 /* Try reading a character via menu prompting in the minibuf.
2544 Try this before the sit-for, because the sit-for
2545 would do the wrong thing if we are supposed to do
2546 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2547 after a mouse event so don't try a minibuf menu. */
2549 if (nmaps
> 0 && INTERACTIVE
2550 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2551 /* Don't bring up a menu if we already have another event. */
2552 && NILP (Vunread_command_events
)
2553 && unread_command_char
< 0
2554 && !detect_input_pending_run_timers (0))
2556 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2559 key_already_recorded
= 1;
2564 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2565 We will do that below, temporarily for short sections of code,
2566 when appropriate. local_getcjmp must be in effect
2567 around any call to sit_for or kbd_buffer_get_event;
2568 it *must not* be in effect when we call redisplay. */
2570 if (_setjmp (local_getcjmp
))
2572 XSETINT (c
, quit_char
);
2573 internal_last_event_frame
= selected_frame
;
2574 Vlast_event_frame
= internal_last_event_frame
;
2575 /* If we report the quit char as an event,
2576 don't do so more than once. */
2577 if (!NILP (Vinhibit_quit
))
2582 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2583 if (kb
!= current_kboard
)
2585 Lisp_Object link
= kb
->kbd_queue
;
2586 /* We shouldn't get here if we were in single-kboard mode! */
2591 while (CONSP (XCDR (link
)))
2593 if (!NILP (XCDR (link
)))
2597 kb
->kbd_queue
= Fcons (c
, Qnil
);
2599 XSETCDR (link
, Fcons (c
, Qnil
));
2600 kb
->kbd_queue_has_data
= 1;
2601 current_kboard
= kb
;
2602 /* This is going to exit from read_char
2603 so we had better get rid of this frame's stuff. */
2605 longjmp (wrong_kboard_jmpbuf
, 1);
2612 timer_start_idle ();
2614 /* If in middle of key sequence and minibuffer not active,
2615 start echoing if enough time elapses. */
2617 if (minibuf_level
== 0
2618 && !current_kboard
->immediate_echo
2619 && this_command_key_count
> 0
2621 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2622 && NILP (Fzerop (Vecho_keystrokes
))
2623 && (/* No message. */
2624 NILP (echo_area_buffer
[0])
2625 /* Or empty message. */
2626 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2627 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2628 /* Or already echoing from same kboard. */
2629 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2630 /* Or not echoing before and echoing allowed. */
2631 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2635 /* After a mouse event, start echoing right away.
2636 This is because we are probably about to display a menu,
2637 and we don't want to delay before doing so. */
2638 if (EVENT_HAS_PARAMETERS (prev_event
))
2643 double duration
= extract_float (Vecho_keystrokes
);
2644 sec
= (int) duration
;
2645 usec
= (duration
- sec
) * 1000000;
2646 save_getcjmp (save_jump
);
2647 restore_getcjmp (local_getcjmp
);
2648 tem0
= sit_for (sec
, usec
, 1, 1, 0);
2649 restore_getcjmp (save_jump
);
2651 && ! CONSP (Vunread_command_events
))
2656 /* Maybe auto save due to number of keystrokes. */
2658 if (commandflag
!= 0
2659 && auto_save_interval
> 0
2660 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2661 && !detect_input_pending_run_timers (0))
2663 Fdo_auto_save (Qnil
, Qnil
);
2664 /* Hooks can actually change some buffers in auto save. */
2668 /* Try reading using an X menu.
2669 This is never confused with reading using the minibuf
2670 because the recursive call of read_char in read_char_minibuf_menu_prompt
2671 does not pass on any keymaps. */
2673 if (nmaps
> 0 && INTERACTIVE
2674 && !NILP (prev_event
)
2675 && EVENT_HAS_PARAMETERS (prev_event
)
2676 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2677 && !EQ (XCAR (prev_event
), Qtool_bar
)
2678 /* Don't bring up a menu if we already have another event. */
2679 && NILP (Vunread_command_events
)
2680 && unread_command_char
< 0)
2682 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2684 /* Now that we have read an event, Emacs is not idle. */
2690 /* Maybe autosave and/or garbage collect due to idleness. */
2692 if (INTERACTIVE
&& NILP (c
))
2694 int delay_level
, buffer_size
;
2696 /* Slow down auto saves logarithmically in size of current buffer,
2697 and garbage collect while we're at it. */
2698 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2699 last_non_minibuf_size
= Z
- BEG
;
2700 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2702 while (buffer_size
> 64)
2703 delay_level
++, buffer_size
-= buffer_size
>> 2;
2704 if (delay_level
< 4) delay_level
= 4;
2705 /* delay_level is 4 for files under around 50k, 7 at 100k,
2706 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2708 /* Auto save if enough time goes by without input. */
2709 if (commandflag
!= 0
2710 && num_nonmacro_input_events
> last_auto_save
2711 && INTEGERP (Vauto_save_timeout
)
2712 && XINT (Vauto_save_timeout
) > 0)
2716 save_getcjmp (save_jump
);
2717 restore_getcjmp (local_getcjmp
);
2718 tem0
= sit_for (delay_level
* XFASTINT (Vauto_save_timeout
) / 4,
2720 restore_getcjmp (save_jump
);
2723 && ! CONSP (Vunread_command_events
))
2725 Fdo_auto_save (Qnil
, Qnil
);
2727 /* If we have auto-saved and there is still no input
2728 available, garbage collect if there has been enough
2729 consing going on to make it worthwhile. */
2730 if (!detect_input_pending_run_timers (0)
2731 && consing_since_gc
> gc_cons_threshold
/ 2)
2732 Fgarbage_collect ();
2739 /* If this has become non-nil here, it has been set by a timer
2740 or sentinel or filter. */
2741 if (CONSP (Vunread_command_events
))
2743 c
= XCAR (Vunread_command_events
);
2744 Vunread_command_events
= XCDR (Vunread_command_events
);
2747 /* Read something from current KBOARD's side queue, if possible. */
2751 if (current_kboard
->kbd_queue_has_data
)
2753 if (!CONSP (current_kboard
->kbd_queue
))
2755 c
= XCAR (current_kboard
->kbd_queue
);
2756 current_kboard
->kbd_queue
2757 = XCDR (current_kboard
->kbd_queue
);
2758 if (NILP (current_kboard
->kbd_queue
))
2759 current_kboard
->kbd_queue_has_data
= 0;
2760 input_pending
= readable_events (0);
2761 if (EVENT_HAS_PARAMETERS (c
)
2762 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2763 internal_last_event_frame
= XCAR (XCDR (c
));
2764 Vlast_event_frame
= internal_last_event_frame
;
2769 /* If current_kboard's side queue is empty check the other kboards.
2770 If one of them has data that we have not yet seen here,
2771 switch to it and process the data waiting for it.
2773 Note: if the events queued up for another kboard
2774 have already been seen here, and therefore are not a complete command,
2775 the kbd_queue_has_data field is 0, so we skip that kboard here.
2776 That's to avoid an infinite loop switching between kboards here. */
2777 if (NILP (c
) && !single_kboard
)
2780 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2781 if (kb
->kbd_queue_has_data
)
2783 current_kboard
= kb
;
2784 /* This is going to exit from read_char
2785 so we had better get rid of this frame's stuff. */
2787 longjmp (wrong_kboard_jmpbuf
, 1);
2796 /* Finally, we read from the main queue,
2797 and if that gives us something we can't use yet, we put it on the
2798 appropriate side queue and try again. */
2804 /* Actually read a character, waiting if necessary. */
2805 save_getcjmp (save_jump
);
2806 restore_getcjmp (local_getcjmp
);
2807 timer_start_idle ();
2808 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
);
2809 restore_getcjmp (save_jump
);
2812 if (! NILP (c
) && (kb
!= current_kboard
))
2814 Lisp_Object link
= kb
->kbd_queue
;
2817 while (CONSP (XCDR (link
)))
2819 if (!NILP (XCDR (link
)))
2823 kb
->kbd_queue
= Fcons (c
, Qnil
);
2825 XSETCDR (link
, Fcons (c
, Qnil
));
2826 kb
->kbd_queue_has_data
= 1;
2830 current_kboard
= kb
;
2831 /* This is going to exit from read_char
2832 so we had better get rid of this frame's stuff. */
2834 longjmp (wrong_kboard_jmpbuf
, 1);
2839 /* Terminate Emacs in batch mode if at eof. */
2840 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2841 Fkill_emacs (make_number (1));
2845 /* Add in any extra modifiers, where appropriate. */
2846 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2847 || ((extra_keyboard_modifiers
& 0177) < ' '
2848 && (extra_keyboard_modifiers
& 0177) != 0))
2849 XSETINT (c
, make_ctrl_char (XINT (c
)));
2851 /* Transfer any other modifier bits directly from
2852 extra_keyboard_modifiers to c. Ignore the actual character code
2853 in the low 16 bits of extra_keyboard_modifiers. */
2854 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2859 /* Record the last idle start time so that we can reset it
2860 should the next event read be a help-echo. */
2861 last_idle_start
= timer_idleness_start_time
;
2867 if (commandflag
>= 0
2868 && !input_pending
&& !detect_input_pending_run_timers (0))
2876 /* Buffer switch events are only for internal wakeups
2877 so don't show them to the user.
2878 Also, don't record a key if we already did. */
2879 if (BUFFERP (c
) || key_already_recorded
)
2882 /* Process special events within read_char
2883 and loop around to read another event. */
2886 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2891 int was_locked
= single_kboard
;
2893 last_input_char
= c
;
2894 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
2896 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
))
2897 /* We stopped being idle for this event; undo that. This
2898 prevents automatic window selection (under
2899 mouse_autoselect_window from acting as a real input event, for
2900 example banishing the mouse under mouse-avoidance-mode. */
2901 timer_idleness_start_time
= last_idle_start
;
2903 /* Resume allowing input from any kboard, if that was true before. */
2905 any_kboard_state ();
2910 /* Handle things that only apply to characters. */
2913 /* If kbd_buffer_get_event gave us an EOF, return that. */
2917 if ((STRINGP (Vkeyboard_translate_table
)
2918 && SCHARS (Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
2919 || (VECTORP (Vkeyboard_translate_table
)
2920 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2921 || (CHAR_TABLE_P (Vkeyboard_translate_table
)
2922 && CHAR_VALID_P (XINT (c
), 0)))
2925 d
= Faref (Vkeyboard_translate_table
, c
);
2926 /* nil in keyboard-translate-table means no translation. */
2932 /* If this event is a mouse click in the menu bar,
2933 return just menu-bar for now. Modify the mouse click event
2934 so we won't do this twice, then queue it up. */
2935 if (EVENT_HAS_PARAMETERS (c
)
2937 && CONSP (EVENT_START (c
))
2938 && CONSP (XCDR (EVENT_START (c
))))
2942 posn
= POSN_POSN (EVENT_START (c
));
2943 /* Handle menu-bar events:
2944 insert the dummy prefix event `menu-bar'. */
2945 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2947 /* Change menu-bar to (menu-bar) as the event "position". */
2948 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2951 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2956 /* Store these characters into recent_keys, the dribble file if any,
2957 and the keyboard macro being defined, if any. */
2959 if (! NILP (also_record
))
2960 record_char (also_record
);
2962 /* Wipe the echo area.
2963 But first, if we are about to use an input method,
2964 save the echo area contents for it to refer to. */
2966 && ! NILP (Vinput_method_function
)
2967 && (unsigned) XINT (c
) >= ' '
2968 && (unsigned) XINT (c
) != 127
2969 && (unsigned) XINT (c
) < 256)
2971 previous_echo_area_message
= Fcurrent_message ();
2972 Vinput_method_previous_message
= previous_echo_area_message
;
2975 /* Now wipe the echo area, except for help events which do their
2976 own stuff with the echo area. */
2978 || (!(EQ (Qhelp_echo
, XCAR (c
)))
2979 && !(EQ (Qswitch_frame
, XCAR (c
)))))
2981 if (!NILP (echo_area_buffer
[0]))
2982 safe_run_hooks (Qecho_area_clear_hook
);
2983 clear_message (1, 0);
2986 reread_for_input_method
:
2988 /* Pass this to the input method, if appropriate. */
2990 && ! NILP (Vinput_method_function
)
2991 /* Don't run the input method within a key sequence,
2992 after the first event of the key sequence. */
2993 && NILP (prev_event
)
2994 && (unsigned) XINT (c
) >= ' '
2995 && (unsigned) XINT (c
) != 127
2996 && (unsigned) XINT (c
) < 256)
2999 int key_count
, key_count_reset
;
3000 struct gcpro gcpro1
;
3001 int count
= SPECPDL_INDEX ();
3003 /* Save the echo status. */
3004 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3005 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3006 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3009 if (before_command_restore_flag
)
3011 this_command_key_count
= before_command_key_count_1
;
3012 if (this_command_key_count
< this_single_command_key_start
)
3013 this_single_command_key_start
= this_command_key_count
;
3014 echo_truncate (before_command_echo_length_1
);
3015 before_command_restore_flag
= 0;
3019 /* Save the this_command_keys status. */
3020 key_count
= this_command_key_count
;
3021 key_count_reset
= this_command_key_count_reset
;
3024 keys
= Fcopy_sequence (this_command_keys
);
3029 /* Clear out this_command_keys. */
3030 this_command_key_count
= 0;
3031 this_command_key_count_reset
= 0;
3033 /* Now wipe the echo area. */
3034 if (!NILP (echo_area_buffer
[0]))
3035 safe_run_hooks (Qecho_area_clear_hook
);
3036 clear_message (1, 0);
3039 /* If we are not reading a key sequence,
3040 never use the echo area. */
3043 specbind (Qinput_method_use_echo_area
, Qt
);
3046 /* Call the input method. */
3047 tem
= call1 (Vinput_method_function
, c
);
3049 tem
= unbind_to (count
, tem
);
3051 /* Restore the saved echoing state
3052 and this_command_keys state. */
3053 this_command_key_count
= key_count
;
3054 this_command_key_count_reset
= key_count_reset
;
3056 this_command_keys
= keys
;
3059 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3060 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3061 if (saved_immediate_echo
)
3066 /* The input method can return no events. */
3069 /* Bring back the previous message, if any. */
3070 if (! NILP (previous_echo_area_message
))
3071 message_with_string ("%s", previous_echo_area_message
, 0);
3074 /* It returned one event or more. */
3076 Vunread_post_input_method_events
3077 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3082 /* Display help if not echoing. */
3083 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3085 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3086 Lisp_Object help
, object
, position
, window
, tem
;
3088 tem
= Fcdr (XCDR (c
));
3091 window
= Fcar (tem
);
3093 object
= Fcar (tem
);
3095 position
= Fcar (tem
);
3097 show_help_echo (help
, window
, object
, position
, 0);
3099 /* We stopped being idle for this event; undo that. */
3100 timer_idleness_start_time
= last_idle_start
;
3104 if (! reread
|| this_command_key_count
== 0
3105 || this_command_key_count_reset
)
3108 /* Don't echo mouse motion events. */
3109 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3110 && NILP (Fzerop (Vecho_keystrokes
))
3111 && ! (EVENT_HAS_PARAMETERS (c
)
3112 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3115 if (! NILP (also_record
))
3116 echo_char (also_record
);
3117 /* Once we reread a character, echoing can happen
3118 the next time we pause to read a new one. */
3119 ok_to_echo_at_next_pause
= current_kboard
;
3122 /* Record this character as part of the current key. */
3123 add_command_key (c
);
3124 if (! NILP (also_record
))
3125 add_command_key (also_record
);
3128 last_input_char
= c
;
3131 /* Process the help character specially if enabled */
3132 if (!NILP (Vhelp_form
) && help_char_p (c
))
3135 count
= SPECPDL_INDEX ();
3137 record_unwind_protect (Fset_window_configuration
,
3138 Fcurrent_window_configuration (Qnil
));
3140 tem0
= Feval (Vhelp_form
);
3142 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3146 c
= read_char (0, 0, 0, Qnil
, 0);
3147 while (BUFFERP (c
));
3148 /* Remove the help from the frame */
3149 unbind_to (count
, Qnil
);
3152 if (EQ (c
, make_number (040)))
3156 c
= read_char (0, 0, 0, Qnil
, 0);
3157 while (BUFFERP (c
));
3166 /* Record a key that came from a mouse menu.
3167 Record it for echoing, for this-command-keys, and so on. */
3173 /* Wipe the echo area. */
3174 clear_message (1, 0);
3179 before_command_key_count
= this_command_key_count
;
3180 before_command_echo_length
= echo_length ();
3183 /* Don't echo mouse motion events. */
3184 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3185 && NILP (Fzerop (Vecho_keystrokes
)))
3189 /* Once we reread a character, echoing can happen
3190 the next time we pause to read a new one. */
3191 ok_to_echo_at_next_pause
= 0;
3194 /* Record this character as part of the current key. */
3195 add_command_key (c
);
3197 /* Re-reading in the middle of a command */
3198 last_input_char
= c
;
3202 /* Return 1 if should recognize C as "the help character". */
3210 if (EQ (c
, Vhelp_char
))
3212 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3213 if (EQ (c
, XCAR (tail
)))
3218 /* Record the input event C in various ways. */
3226 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3228 /* To avoid filling recent_keys with help-echo and mouse-movement
3229 events, we filter out repeated help-echo events, only store the
3230 first and last in a series of mouse-movement events, and don't
3231 store repeated help-echo events which are only separated by
3232 mouse-movement events. */
3234 Lisp_Object ev1
, ev2
, ev3
;
3237 if ((ix1
= recent_keys_index
- 1) < 0)
3238 ix1
= NUM_RECENT_KEYS
- 1;
3239 ev1
= AREF (recent_keys
, ix1
);
3241 if ((ix2
= ix1
- 1) < 0)
3242 ix2
= NUM_RECENT_KEYS
- 1;
3243 ev2
= AREF (recent_keys
, ix2
);
3245 if ((ix3
= ix2
- 1) < 0)
3246 ix3
= NUM_RECENT_KEYS
- 1;
3247 ev3
= AREF (recent_keys
, ix3
);
3249 if (EQ (XCAR (c
), Qhelp_echo
))
3251 /* Don't record `help-echo' in recent_keys unless it shows some help
3252 message, and a different help than the previously recorded
3254 Lisp_Object help
, last_help
;
3256 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3257 if (!STRINGP (help
))
3259 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3260 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3262 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3263 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3264 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3266 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3267 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3268 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3269 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3272 else if (EQ (XCAR (c
), Qmouse_movement
))
3274 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3275 So additional mouse movement events replace the last element. */
3276 Lisp_Object last_window
, window
;
3278 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3279 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3280 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3281 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3282 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3284 ASET (recent_keys
, ix1
, c
);
3290 store_kbd_macro_char (c
);
3295 ASET (recent_keys
, recent_keys_index
, c
);
3296 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3297 recent_keys_index
= 0;
3299 else if (recorded
< 0)
3301 /* We need to remove one or two events from recent_keys.
3302 To do this, we simply put nil at those events and move the
3303 recent_keys_index backwards over those events. Usually,
3304 users will never see those nil events, as they will be
3305 overwritten by the command keys entered to see recent_keys
3308 while (recorded
++ < 0 && total_keys
> 0)
3310 if (total_keys
< NUM_RECENT_KEYS
)
3312 if (--recent_keys_index
< 0)
3313 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3314 ASET (recent_keys
, recent_keys_index
, Qnil
);
3318 num_nonmacro_input_events
++;
3320 /* Write c to the dribble file. If c is a lispy event, write
3321 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3322 If you, dear reader, have a better idea, you've got the source. :-) */
3327 if (XUINT (c
) < 0x100)
3328 putc (XINT (c
), dribble
);
3330 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3334 Lisp_Object dribblee
;
3336 /* If it's a structured event, take the event header. */
3337 dribblee
= EVENT_HEAD (c
);
3339 if (SYMBOLP (dribblee
))
3341 putc ('<', dribble
);
3342 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3343 SBYTES (SYMBOL_NAME (dribblee
)),
3345 putc ('>', dribble
);
3357 struct buffer
*old
= current_buffer
;
3358 Fprinc (object
, Qnil
);
3359 set_buffer_internal (XBUFFER (Vstandard_output
));
3360 call0 (intern ("help-mode"));
3361 set_buffer_internal (old
);
3365 /* Copy out or in the info on where C-g should throw to.
3366 This is used when running Lisp code from within get_char,
3367 in case get_char is called recursively.
3368 See read_process_output. */
3374 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3378 restore_getcjmp (temp
)
3381 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3386 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
3387 of this function. */
3390 tracking_off (old_value
)
3391 Lisp_Object old_value
;
3393 do_mouse_tracking
= old_value
;
3394 if (NILP (old_value
))
3396 /* Redisplay may have been preempted because there was input
3397 available, and it assumes it will be called again after the
3398 input has been processed. If the only input available was
3399 the sort that we have just disabled, then we need to call
3401 if (!readable_events (1))
3403 redisplay_preserve_echo_area (6);
3404 get_input_pending (&input_pending
, 1);
3410 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
3411 doc
: /* Evaluate BODY with mouse movement events enabled.
3412 Within a `track-mouse' form, mouse motion generates input events that
3413 you can read with `read-event'.
3414 Normally, mouse motion is ignored.
3415 usage: (track-mouse BODY ...) */)
3419 int count
= SPECPDL_INDEX ();
3422 record_unwind_protect (tracking_off
, do_mouse_tracking
);
3424 do_mouse_tracking
= Qt
;
3426 val
= Fprogn (args
);
3427 return unbind_to (count
, val
);
3430 /* If mouse has moved on some frame, return one of those frames.
3431 Return 0 otherwise. */
3436 Lisp_Object tail
, frame
;
3438 FOR_EACH_FRAME (tail
, frame
)
3440 if (XFRAME (frame
)->mouse_moved
)
3441 return XFRAME (frame
);
3447 #endif /* HAVE_MOUSE */
3449 /* Low level keyboard/mouse input.
3450 kbd_buffer_store_event places events in kbd_buffer, and
3451 kbd_buffer_get_event retrieves them. */
3453 /* Return true iff there are any events in the queue that read-char
3454 would return. If this returns false, a read-char would block. */
3456 readable_filtered_events (do_timers_now
, filter_events
)
3461 timer_check (do_timers_now
);
3463 /* If the buffer contains only FOCUS_IN_EVENT events,
3464 and FILTER_EVENTS is nonzero, report it as empty. */
3465 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3467 int have_live_event
= 1;
3471 struct input_event
*event
;
3473 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3477 while (have_live_event
&& event
->kind
== FOCUS_IN_EVENT
)
3480 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3482 if (event
== kbd_store_ptr
)
3483 have_live_event
= 0;
3486 if (have_live_event
) return 1;
3490 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3495 if (current_kboard
->kbd_queue_has_data
)
3501 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3502 if (kb
->kbd_queue_has_data
)
3508 /* Return true iff there are any events in the queue that read-char
3509 would return. If this returns false, a read-char would block. */
3511 readable_events (do_timers_now
)
3514 return readable_filtered_events (do_timers_now
, 0);
3517 /* Set this for debugging, to have a way to get out */
3522 event_to_kboard (event
)
3523 struct input_event
*event
;
3526 frame
= event
->frame_or_window
;
3528 frame
= XCAR (frame
);
3529 else if (WINDOWP (frame
))
3530 frame
= WINDOW_FRAME (XWINDOW (frame
));
3532 /* There are still some events that don't set this field.
3533 For now, just ignore the problem.
3534 Also ignore dead frames here. */
3535 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3538 return FRAME_KBOARD (XFRAME (frame
));
3542 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3545 kbd_buffer_store_event (event
)
3546 register struct input_event
*event
;
3548 if (event
->kind
== NO_EVENT
)
3551 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3553 register int c
= event
->code
& 0377;
3555 if (event
->modifiers
& ctrl_modifier
)
3556 c
= make_ctrl_char (c
);
3558 c
|= (event
->modifiers
3559 & (meta_modifier
| alt_modifier
3560 | hyper_modifier
| super_modifier
));
3566 struct input_event
*sp
;
3569 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
3570 kb
!= current_kboard
))
3573 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3574 Fcons (make_number (c
), Qnil
));
3575 kb
->kbd_queue_has_data
= 1;
3576 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3578 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3581 if (event_to_kboard (sp
) == kb
)
3583 sp
->kind
= NO_EVENT
;
3584 sp
->frame_or_window
= Qnil
;
3592 /* If this results in a quit_char being returned to Emacs as
3593 input, set Vlast_event_frame properly. If this doesn't
3594 get returned to Emacs as an event, the next event read
3595 will set Vlast_event_frame again, so this is safe to do. */
3599 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3601 focus
= event
->frame_or_window
;
3602 internal_last_event_frame
= focus
;
3603 Vlast_event_frame
= focus
;
3606 last_event_timestamp
= event
->timestamp
;
3607 handle_interrupt ();
3611 if (c
&& c
== stop_character
)
3617 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3618 Just ignore the second one. */
3619 else if (event
->kind
== BUFFER_SWITCH_EVENT
3620 && kbd_fetch_ptr
!= kbd_store_ptr
3621 && kbd_store_ptr
->kind
== BUFFER_SWITCH_EVENT
)
3624 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3625 kbd_store_ptr
= kbd_buffer
;
3627 /* Don't let the very last slot in the buffer become full,
3628 since that would make the two pointers equal,
3629 and that is indistinguishable from an empty buffer.
3630 Discard the event if it would fill the last slot. */
3631 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3635 #if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
3636 prone to assign individual members for other events, in case
3637 the input_event structure is changed. --2000-07-13, gerd. */
3638 struct input_event
*sp
= kbd_store_ptr
;
3639 sp
->kind
= event
->kind
;
3640 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3642 /* We must not use the ordinary copying code for this case,
3643 since `part' is an enum and copying it might not copy enough
3645 bcopy (event
, (char *) sp
, sizeof (*event
));
3650 sp
->code
= event
->code
;
3651 sp
->part
= event
->part
;
3652 sp
->frame_or_window
= event
->frame_or_window
;
3653 sp
->arg
= event
->arg
;
3654 sp
->modifiers
= event
->modifiers
;
3657 sp
->timestamp
= event
->timestamp
;
3660 *kbd_store_ptr
= *event
;
3663 idx
= 2 * (kbd_store_ptr
- kbd_buffer
);
3664 ASET (kbd_buffer_gcpro
, idx
, event
->frame_or_window
);
3665 ASET (kbd_buffer_gcpro
, idx
+ 1, event
->arg
);
3671 /* Generate HELP_EVENT input_events in BUFP which has room for
3672 SIZE events. If there's not enough room in BUFP, ignore this
3675 HELP is the help form.
3677 FRAME is the frame on which the help is generated. OBJECT is the
3678 Lisp object where the help was found (a buffer, a string, an
3679 overlay, or nil if neither from a string nor from a buffer. POS is
3680 the position within OBJECT where the help was found.
3682 Value is the number of input_events generated. */
3685 gen_help_event (bufp
, size
, help
, frame
, window
, object
, pos
)
3686 struct input_event
*bufp
;
3688 Lisp_Object help
, frame
, object
, window
;
3693 bufp
->kind
= HELP_EVENT
;
3694 bufp
->frame_or_window
= frame
;
3696 bufp
->x
= WINDOWP (window
) ? window
: frame
;
3705 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3708 kbd_buffer_store_help_event (frame
, help
)
3709 Lisp_Object frame
, help
;
3711 struct input_event event
;
3713 event
.kind
= HELP_EVENT
;
3714 event
.frame_or_window
= frame
;
3719 kbd_buffer_store_event (&event
);
3723 /* Discard any mouse events in the event buffer by setting them to
3726 discard_mouse_events ()
3728 struct input_event
*sp
;
3729 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3731 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3734 if (sp
->kind
== MOUSE_CLICK_EVENT
3735 || sp
->kind
== WHEEL_EVENT
3737 || sp
->kind
== W32_SCROLL_BAR_CLICK_EVENT
3739 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3741 sp
->kind
= NO_EVENT
;
3747 /* Return non-zero if there are any real events waiting in the event
3748 buffer, not counting `NO_EVENT's.
3750 If DISCARD is non-zero, discard NO_EVENT events at the front of
3751 the input queue, possibly leaving the input queue empty if there
3752 are no real input events. */
3755 kbd_buffer_events_waiting (discard
)
3758 struct input_event
*sp
;
3760 for (sp
= kbd_fetch_ptr
;
3761 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3764 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3771 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3775 /* Clear input event EVENT. */
3779 struct input_event
*event
;
3781 int idx
= 2 * (event
- kbd_buffer
);
3782 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
3783 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
3784 event
->kind
= NO_EVENT
;
3788 /* Read one event from the event buffer, waiting if necessary.
3789 The value is a Lisp object representing the event.
3790 The value is nil for an event that should be ignored,
3791 or that was handled here.
3792 We always read and discard one event. */
3795 kbd_buffer_get_event (kbp
, used_mouse_menu
)
3797 int *used_mouse_menu
;
3806 *kbp
= current_kboard
;
3810 /* Wait until there is input available. */
3813 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3816 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3820 /* If the quit flag is set, then read_char will return
3821 quit_char, so that counts as "available input." */
3822 if (!NILP (Vquit_flag
))
3823 quit_throw_to_read_char ();
3825 /* One way or another, wait until input is available; then, if
3826 interrupt handlers have not read it, read it now. */
3829 wait_for_kbd_input ();
3831 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3835 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3838 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3842 Lisp_Object minus_one
;
3844 XSETINT (minus_one
, -1);
3845 wait_reading_process_input (0, 0, minus_one
, 1);
3847 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3848 /* Pass 1 for EXPECT since we just waited to have input. */
3849 read_avail_input (1);
3851 #endif /* not VMS */
3854 if (CONSP (Vunread_command_events
))
3857 first
= XCAR (Vunread_command_events
);
3858 Vunread_command_events
= XCDR (Vunread_command_events
);
3859 *kbp
= current_kboard
;
3863 /* At this point, we know that there is a readable event available
3864 somewhere. If the event queue is empty, then there must be a
3865 mouse movement enabled and available. */
3866 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3868 struct input_event
*event
;
3870 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3874 last_event_timestamp
= event
->timestamp
;
3877 *kbp
= event_to_kboard (event
);
3879 *kbp
= current_kboard
; /* Better than returning null ptr? */
3881 *kbp
= &the_only_kboard
;
3886 /* These two kinds of events get special handling
3887 and don't actually appear to the command loop.
3888 We return nil for them. */
3889 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3892 struct input_event copy
;
3894 /* Remove it from the buffer before processing it,
3895 since otherwise swallow_events will see it
3896 and process it again. */
3898 kbd_fetch_ptr
= event
+ 1;
3899 input_pending
= readable_events (0);
3900 x_handle_selection_request (©
);
3902 /* We're getting selection request events, but we don't have
3908 else if (event
->kind
== SELECTION_CLEAR_EVENT
)
3911 struct input_event copy
;
3913 /* Remove it from the buffer before processing it. */
3915 kbd_fetch_ptr
= event
+ 1;
3916 input_pending
= readable_events (0);
3917 x_handle_selection_clear (©
);
3919 /* We're getting selection request events, but we don't have
3924 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
3925 else if (event
->kind
== DELETE_WINDOW_EVENT
)
3927 /* Make an event (delete-frame (FRAME)). */
3928 obj
= Fcons (event
->frame_or_window
, Qnil
);
3929 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3930 kbd_fetch_ptr
= event
+ 1;
3933 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3934 else if (event
->kind
== ICONIFY_EVENT
)
3936 /* Make an event (iconify-frame (FRAME)). */
3937 obj
= Fcons (event
->frame_or_window
, Qnil
);
3938 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3939 kbd_fetch_ptr
= event
+ 1;
3941 else if (event
->kind
== DEICONIFY_EVENT
)
3943 /* Make an event (make-frame-visible (FRAME)). */
3944 obj
= Fcons (event
->frame_or_window
, Qnil
);
3945 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3946 kbd_fetch_ptr
= event
+ 1;
3949 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
3951 /* The value doesn't matter here; only the type is tested. */
3952 XSETBUFFER (obj
, current_buffer
);
3953 kbd_fetch_ptr
= event
+ 1;
3955 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
3956 || defined (USE_GTK)
3957 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
3959 kbd_fetch_ptr
= event
+ 1;
3960 input_pending
= readable_events (0);
3961 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
3962 x_activate_menubar (XFRAME (event
->frame_or_window
));
3966 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
3968 /* Make an event (language-change (FRAME CHARSET LCID)). */
3969 obj
= Fcons (event
->modifiers
, Qnil
);
3970 obj
= Fcons (event
->code
, obj
);
3971 obj
= Fcons (event
->frame_or_window
, obj
);
3972 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
3973 kbd_fetch_ptr
= event
+ 1;
3976 else if (event
->kind
== SAVE_SESSION_EVENT
)
3978 obj
= Fcons (Qsave_session
, Qnil
);
3979 kbd_fetch_ptr
= event
+ 1;
3981 /* Just discard these, by returning nil.
3982 With MULTI_KBOARD, these events are used as placeholders
3983 when we need to randomly delete events from the queue.
3984 (They shouldn't otherwise be found in the buffer,
3985 but on some machines it appears they do show up
3986 even without MULTI_KBOARD.) */
3987 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3988 mouse events during a popup-menu call. */
3989 else if (event
->kind
== NO_EVENT
)
3990 kbd_fetch_ptr
= event
+ 1;
3991 else if (event
->kind
== HELP_EVENT
)
3993 Lisp_Object object
, position
, help
, frame
, window
;
3995 frame
= event
->frame_or_window
;
3996 object
= event
->arg
;
3997 position
= make_number (event
->code
);
4000 clear_event (event
);
4002 kbd_fetch_ptr
= event
+ 1;
4003 if (!WINDOWP (window
))
4005 obj
= Fcons (Qhelp_echo
,
4006 list5 (frame
, help
, window
, object
, position
));
4008 else if (event
->kind
== FOCUS_IN_EVENT
)
4010 /* Notification of a FocusIn event. The frame receiving the
4011 focus is in event->frame_or_window. Generate a
4012 switch-frame event if necessary. */
4013 Lisp_Object frame
, focus
;
4015 frame
= event
->frame_or_window
;
4016 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4020 if (!EQ (frame
, internal_last_event_frame
)
4021 && !EQ (frame
, selected_frame
))
4022 obj
= make_lispy_switch_frame (frame
);
4023 internal_last_event_frame
= frame
;
4024 kbd_fetch_ptr
= event
+ 1;
4028 /* If this event is on a different frame, return a switch-frame this
4029 time, and leave the event in the queue for next time. */
4033 frame
= event
->frame_or_window
;
4035 frame
= XCAR (frame
);
4036 else if (WINDOWP (frame
))
4037 frame
= WINDOW_FRAME (XWINDOW (frame
));
4039 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4043 if (! EQ (frame
, internal_last_event_frame
)
4044 && !EQ (frame
, selected_frame
))
4045 obj
= make_lispy_switch_frame (frame
);
4046 internal_last_event_frame
= frame
;
4048 /* If we didn't decide to make a switch-frame event, go ahead
4049 and build a real event from the queue entry. */
4053 obj
= make_lispy_event (event
);
4055 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4056 || defined (USE_GTK)
4057 /* If this was a menu selection, then set the flag to inhibit
4058 writing to last_nonmenu_event. Don't do this if the event
4059 we're returning is (menu-bar), though; that indicates the
4060 beginning of the menu sequence, and we might as well leave
4061 that as the `event with parameters' for this selection. */
4063 && !EQ (event
->frame_or_window
, event
->arg
)
4064 && (event
->kind
== MENU_BAR_EVENT
4065 || event
->kind
== TOOL_BAR_EVENT
))
4066 *used_mouse_menu
= 1;
4069 /* Wipe out this event, to catch bugs. */
4070 clear_event (event
);
4071 kbd_fetch_ptr
= event
+ 1;
4076 /* Try generating a mouse motion event. */
4077 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4079 FRAME_PTR f
= some_mouse_moved ();
4080 Lisp_Object bar_window
;
4081 enum scroll_bar_part part
;
4085 *kbp
= current_kboard
;
4086 /* Note that this uses F to determine which display to look at.
4087 If there is no valid info, it does not store anything
4088 so x remains nil. */
4090 if (f
&& FRAME_DISPLAY (f
)->mouse_position_hook
) /* XXX Can f or mouse_position_hook be NULL here? */
4091 (*FRAME_DISPLAY (f
)->mouse_position_hook
) (&f
, 0, &bar_window
, &part
, &x
, &y
, &time
);
4095 /* Decide if we should generate a switch-frame event. Don't
4096 generate switch-frame events for motion outside of all Emacs
4102 frame
= FRAME_FOCUS_FRAME (f
);
4104 XSETFRAME (frame
, f
);
4106 if (! EQ (frame
, internal_last_event_frame
)
4107 && !EQ (frame
, selected_frame
))
4108 obj
= make_lispy_switch_frame (frame
);
4109 internal_last_event_frame
= frame
;
4112 /* If we didn't decide to make a switch-frame event, go ahead and
4113 return a mouse-motion event. */
4114 if (!NILP (x
) && NILP (obj
))
4115 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
4117 #endif /* HAVE_MOUSE */
4119 /* We were promised by the above while loop that there was
4120 something for us to read! */
4123 input_pending
= readable_events (0);
4125 Vlast_event_frame
= internal_last_event_frame
;
4130 /* Process any events that are not user-visible,
4131 then return, without reading any user-visible events. */
4134 swallow_events (do_display
)
4139 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4141 struct input_event
*event
;
4143 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4147 last_event_timestamp
= event
->timestamp
;
4149 /* These two kinds of events get special handling
4150 and don't actually appear to the command loop. */
4151 if (event
->kind
== SELECTION_REQUEST_EVENT
)
4154 struct input_event copy
;
4156 /* Remove it from the buffer before processing it,
4157 since otherwise swallow_events called recursively could see it
4158 and process it again. */
4160 kbd_fetch_ptr
= event
+ 1;
4161 input_pending
= readable_events (0);
4162 x_handle_selection_request (©
);
4164 /* We're getting selection request events, but we don't have
4170 else if (event
->kind
== SELECTION_CLEAR_EVENT
)
4173 struct input_event copy
;
4175 /* Remove it from the buffer before processing it, */
4178 kbd_fetch_ptr
= event
+ 1;
4179 input_pending
= readable_events (0);
4180 x_handle_selection_clear (©
);
4182 /* We're getting selection request events, but we don't have
4191 old_timers_run
= timers_run
;
4192 get_input_pending (&input_pending
, 1);
4194 if (timers_run
!= old_timers_run
&& do_display
)
4195 redisplay_preserve_echo_area (7);
4198 /* Record the start of when Emacs is idle,
4199 for the sake of running idle-time timers. */
4206 /* If we are already in the idle state, do nothing. */
4207 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4210 EMACS_GET_TIME (timer_idleness_start_time
);
4212 timer_last_idleness_start_time
= timer_idleness_start_time
;
4214 /* Mark all idle-time timers as once again candidates for running. */
4215 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4219 timer
= XCAR (timers
);
4221 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4223 XVECTOR (timer
)->contents
[0] = Qnil
;
4227 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4232 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4235 /* This is only for debugging. */
4236 struct input_event last_timer_event
;
4238 /* Check whether a timer has fired. To prevent larger problems we simply
4239 disregard elements that are not proper timers. Do not make a circular
4240 timer list for the time being.
4242 Returns the number of seconds to wait until the next timer fires. If a
4243 timer is triggering now, return zero seconds.
4244 If no timer is active, return -1 seconds.
4246 If a timer is ripe, we run it, with quitting turned off.
4248 DO_IT_NOW is now ignored. It used to mean that we should
4249 run the timer directly instead of queueing a timer-event.
4250 Now we always run timers directly. */
4253 timer_check (do_it_now
)
4256 EMACS_TIME nexttime
;
4257 EMACS_TIME now
, idleness_now
;
4258 Lisp_Object timers
, idle_timers
, chosen_timer
;
4259 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4261 EMACS_SET_SECS (nexttime
, -1);
4262 EMACS_SET_USECS (nexttime
, -1);
4264 /* Always consider the ordinary timers. */
4265 timers
= Vtimer_list
;
4266 /* Consider the idle timers only if Emacs is idle. */
4267 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4268 idle_timers
= Vtimer_idle_list
;
4271 chosen_timer
= Qnil
;
4272 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4274 if (CONSP (timers
) || CONSP (idle_timers
))
4276 EMACS_GET_TIME (now
);
4277 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4278 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4281 while (CONSP (timers
) || CONSP (idle_timers
))
4283 Lisp_Object
*vector
;
4284 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4285 EMACS_TIME timer_time
, idle_timer_time
;
4286 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4288 /* Skip past invalid timers and timers already handled. */
4291 timer
= XCAR (timers
);
4292 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4294 timers
= XCDR (timers
);
4297 vector
= XVECTOR (timer
)->contents
;
4299 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4300 || !INTEGERP (vector
[3])
4301 || ! NILP (vector
[0]))
4303 timers
= XCDR (timers
);
4307 if (!NILP (idle_timers
))
4309 timer
= XCAR (idle_timers
);
4310 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4312 idle_timers
= XCDR (idle_timers
);
4315 vector
= XVECTOR (timer
)->contents
;
4317 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4318 || !INTEGERP (vector
[3])
4319 || ! NILP (vector
[0]))
4321 idle_timers
= XCDR (idle_timers
);
4326 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4327 based on the next ordinary timer.
4328 TIMER_DIFFERENCE is the distance in time from NOW to when
4329 this timer becomes ripe (negative if it's already ripe). */
4332 timer
= XCAR (timers
);
4333 vector
= XVECTOR (timer
)->contents
;
4334 EMACS_SET_SECS (timer_time
,
4335 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4336 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4337 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4340 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4341 based on the next idle timer. */
4342 if (!NILP (idle_timers
))
4344 idle_timer
= XCAR (idle_timers
);
4345 vector
= XVECTOR (idle_timer
)->contents
;
4346 EMACS_SET_SECS (idle_timer_time
,
4347 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4348 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4349 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4352 /* Decide which timer is the next timer,
4353 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4354 Also step down the list where we found that timer. */
4356 if (! NILP (timers
) && ! NILP (idle_timers
))
4359 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4360 if (EMACS_TIME_NEG_P (temp
))
4362 chosen_timer
= timer
;
4363 timers
= XCDR (timers
);
4364 difference
= timer_difference
;
4368 chosen_timer
= idle_timer
;
4369 idle_timers
= XCDR (idle_timers
);
4370 difference
= idle_timer_difference
;
4373 else if (! NILP (timers
))
4375 chosen_timer
= timer
;
4376 timers
= XCDR (timers
);
4377 difference
= timer_difference
;
4381 chosen_timer
= idle_timer
;
4382 idle_timers
= XCDR (idle_timers
);
4383 difference
= idle_timer_difference
;
4385 vector
= XVECTOR (chosen_timer
)->contents
;
4387 /* If timer is ripe, run it if it hasn't been run. */
4388 if (EMACS_TIME_NEG_P (difference
)
4389 || (EMACS_SECS (difference
) == 0
4390 && EMACS_USECS (difference
) == 0))
4392 if (NILP (vector
[0]))
4394 int was_locked
= single_kboard
;
4395 int count
= SPECPDL_INDEX ();
4396 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4398 /* Mark the timer as triggered to prevent problems if the lisp
4399 code fails to reschedule it right. */
4402 specbind (Qinhibit_quit
, Qt
);
4404 call1 (Qtimer_event_handler
, chosen_timer
);
4405 Vdeactivate_mark
= old_deactivate_mark
;
4407 unbind_to (count
, Qnil
);
4409 /* Resume allowing input from any kboard, if that was true before. */
4411 any_kboard_state ();
4413 /* Since we have handled the event,
4414 we don't need to tell the caller to wake up and do it. */
4418 /* When we encounter a timer that is still waiting,
4419 return the amount of time to wait before it is ripe. */
4426 /* No timers are pending in the future. */
4427 /* Return 0 if we generated an event, and -1 if not. */
4432 /* Caches for modify_event_symbol. */
4433 static Lisp_Object accent_key_syms
;
4434 static Lisp_Object func_key_syms
;
4435 static Lisp_Object mouse_syms
;
4436 static Lisp_Object wheel_syms
;
4437 static Lisp_Object drag_n_drop_syms
;
4439 /* This is a list of keysym codes for special "accent" characters.
4440 It parallels lispy_accent_keys. */
4442 static int lispy_accent_codes
[] =
4444 #ifdef XK_dead_circumflex
4449 #ifdef XK_dead_grave
4454 #ifdef XK_dead_tilde
4459 #ifdef XK_dead_diaeresis
4464 #ifdef XK_dead_macron
4469 #ifdef XK_dead_degree
4474 #ifdef XK_dead_acute
4479 #ifdef XK_dead_cedilla
4484 #ifdef XK_dead_breve
4489 #ifdef XK_dead_ogonek
4494 #ifdef XK_dead_caron
4499 #ifdef XK_dead_doubleacute
4500 XK_dead_doubleacute
,
4504 #ifdef XK_dead_abovedot
4509 #ifdef XK_dead_abovering
4519 #ifdef XK_dead_belowdot
4524 #ifdef XK_dead_voiced_sound
4525 XK_dead_voiced_sound
,
4529 #ifdef XK_dead_semivoiced_sound
4530 XK_dead_semivoiced_sound
,
4546 /* This is a list of Lisp names for special "accent" characters.
4547 It parallels lispy_accent_codes. */
4549 static char *lispy_accent_keys
[] =
4567 "dead-voiced-sound",
4568 "dead-semivoiced-sound",
4574 #define FUNCTION_KEY_OFFSET 0x0
4576 char *lispy_function_keys
[] =
4580 0, /* VK_LBUTTON 0x01 */
4581 0, /* VK_RBUTTON 0x02 */
4582 "cancel", /* VK_CANCEL 0x03 */
4583 0, /* VK_MBUTTON 0x04 */
4585 0, 0, 0, /* 0x05 .. 0x07 */
4587 "backspace", /* VK_BACK 0x08 */
4588 "tab", /* VK_TAB 0x09 */
4590 0, 0, /* 0x0A .. 0x0B */
4592 "clear", /* VK_CLEAR 0x0C */
4593 "return", /* VK_RETURN 0x0D */
4595 0, 0, /* 0x0E .. 0x0F */
4597 0, /* VK_SHIFT 0x10 */
4598 0, /* VK_CONTROL 0x11 */
4599 0, /* VK_MENU 0x12 */
4600 "pause", /* VK_PAUSE 0x13 */
4601 "capslock", /* VK_CAPITAL 0x14 */
4603 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4605 "escape", /* VK_ESCAPE 0x1B */
4607 0, 0, 0, 0, /* 0x1C .. 0x1F */
4609 0, /* VK_SPACE 0x20 */
4610 "prior", /* VK_PRIOR 0x21 */
4611 "next", /* VK_NEXT 0x22 */
4612 "end", /* VK_END 0x23 */
4613 "home", /* VK_HOME 0x24 */
4614 "left", /* VK_LEFT 0x25 */
4615 "up", /* VK_UP 0x26 */
4616 "right", /* VK_RIGHT 0x27 */
4617 "down", /* VK_DOWN 0x28 */
4618 "select", /* VK_SELECT 0x29 */
4619 "print", /* VK_PRINT 0x2A */
4620 "execute", /* VK_EXECUTE 0x2B */
4621 "snapshot", /* VK_SNAPSHOT 0x2C */
4622 "insert", /* VK_INSERT 0x2D */
4623 "delete", /* VK_DELETE 0x2E */
4624 "help", /* VK_HELP 0x2F */
4626 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4628 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4630 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4632 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4634 0, 0, 0, 0, 0, 0, 0, 0, 0,
4635 0, 0, 0, 0, 0, 0, 0, 0, 0,
4636 0, 0, 0, 0, 0, 0, 0, 0,
4638 "lwindow", /* VK_LWIN 0x5B */
4639 "rwindow", /* VK_RWIN 0x5C */
4640 "apps", /* VK_APPS 0x5D */
4642 0, 0, /* 0x5E .. 0x5F */
4644 "kp-0", /* VK_NUMPAD0 0x60 */
4645 "kp-1", /* VK_NUMPAD1 0x61 */
4646 "kp-2", /* VK_NUMPAD2 0x62 */
4647 "kp-3", /* VK_NUMPAD3 0x63 */
4648 "kp-4", /* VK_NUMPAD4 0x64 */
4649 "kp-5", /* VK_NUMPAD5 0x65 */
4650 "kp-6", /* VK_NUMPAD6 0x66 */
4651 "kp-7", /* VK_NUMPAD7 0x67 */
4652 "kp-8", /* VK_NUMPAD8 0x68 */
4653 "kp-9", /* VK_NUMPAD9 0x69 */
4654 "kp-multiply", /* VK_MULTIPLY 0x6A */
4655 "kp-add", /* VK_ADD 0x6B */
4656 "kp-separator", /* VK_SEPARATOR 0x6C */
4657 "kp-subtract", /* VK_SUBTRACT 0x6D */
4658 "kp-decimal", /* VK_DECIMAL 0x6E */
4659 "kp-divide", /* VK_DIVIDE 0x6F */
4660 "f1", /* VK_F1 0x70 */
4661 "f2", /* VK_F2 0x71 */
4662 "f3", /* VK_F3 0x72 */
4663 "f4", /* VK_F4 0x73 */
4664 "f5", /* VK_F5 0x74 */
4665 "f6", /* VK_F6 0x75 */
4666 "f7", /* VK_F7 0x76 */
4667 "f8", /* VK_F8 0x77 */
4668 "f9", /* VK_F9 0x78 */
4669 "f10", /* VK_F10 0x79 */
4670 "f11", /* VK_F11 0x7A */
4671 "f12", /* VK_F12 0x7B */
4672 "f13", /* VK_F13 0x7C */
4673 "f14", /* VK_F14 0x7D */
4674 "f15", /* VK_F15 0x7E */
4675 "f16", /* VK_F16 0x7F */
4676 "f17", /* VK_F17 0x80 */
4677 "f18", /* VK_F18 0x81 */
4678 "f19", /* VK_F19 0x82 */
4679 "f20", /* VK_F20 0x83 */
4680 "f21", /* VK_F21 0x84 */
4681 "f22", /* VK_F22 0x85 */
4682 "f23", /* VK_F23 0x86 */
4683 "f24", /* VK_F24 0x87 */
4685 0, 0, 0, 0, /* 0x88 .. 0x8B */
4686 0, 0, 0, 0, /* 0x8C .. 0x8F */
4688 "kp-numlock", /* VK_NUMLOCK 0x90 */
4689 "scroll", /* VK_SCROLL 0x91 */
4691 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4692 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4693 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4694 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4695 "kp-end", /* VK_NUMPAD_END 0x96 */
4696 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4697 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4698 "kp-up", /* VK_NUMPAD_UP 0x99 */
4699 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4700 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4701 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4702 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4704 0, 0, /* 0x9E .. 0x9F */
4707 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4708 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4709 * No other API or message will distinguish left and right keys this way.
4713 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4714 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4715 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4716 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4717 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4723 "attn", /* VK_ATTN 0xF6 */
4724 "crsel", /* VK_CRSEL 0xF7 */
4725 "exsel", /* VK_EXSEL 0xF8 */
4726 "ereof", /* VK_EREOF 0xF9 */
4727 "play", /* VK_PLAY 0xFA */
4728 "zoom", /* VK_ZOOM 0xFB */
4729 "noname", /* VK_NONAME 0xFC */
4730 "pa1", /* VK_PA1 0xFD */
4731 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4735 #else /* not HAVE_NTGUI */
4737 /* This should be dealt with in XTread_socket now, and that doesn't
4738 depend on the client system having the Kana syms defined. See also
4739 the XK_kana_A case below. */
4742 static char *lispy_kana_keys
[] =
4744 /* X Keysym value */
4745 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4746 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4747 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4748 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4750 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4751 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4752 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4753 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4754 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4755 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4756 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4757 "kana-i", "kana-u", "kana-e", "kana-o",
4758 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4759 "prolongedsound", "kana-A", "kana-I", "kana-U",
4760 "kana-E", "kana-O", "kana-KA", "kana-KI",
4761 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4762 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4763 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4764 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4765 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4766 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4767 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4768 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4769 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4770 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4771 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4772 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4774 #endif /* XK_kana_A */
4777 #define FUNCTION_KEY_OFFSET 0xff00
4779 /* You'll notice that this table is arranged to be conveniently
4780 indexed by X Windows keysym values. */
4781 static char *lispy_function_keys
[] =
4783 /* X Keysym value */
4785 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4786 "backspace", "tab", "linefeed", "clear",
4788 0, 0, 0, "pause", /* 0xff10...1f */
4789 0, 0, 0, 0, 0, 0, 0, "escape",
4791 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4792 "romaji", "hiragana", "katakana", "hiragana-katakana",
4793 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4794 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4795 "eisu-toggle", /* 0xff30...3f */
4796 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4797 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4799 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4800 "down", "prior", "next", "end",
4801 "begin", 0, 0, 0, 0, 0, 0, 0,
4802 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4813 "break", /* 0xff6b */
4816 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4817 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4818 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4819 0, 0, 0, 0, 0, 0, 0, 0,
4820 "kp-tab", /* 0xff89 */
4822 "kp-enter", /* 0xff8d */
4824 "kp-f1", /* 0xff91 */
4828 "kp-home", /* 0xff95 */
4833 "kp-prior", /* kp-page-up */
4834 "kp-next", /* kp-page-down */
4840 0, 0, 0, 0, 0, 0, 0, 0, 0,
4841 "kp-multiply", /* 0xffaa */
4846 "kp-divide", /* 0xffaf */
4847 "kp-0", /* 0xffb0 */
4848 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4851 "kp-equal", /* 0xffbd */
4852 "f1", /* 0xffbe */ /* IsFunctionKey */
4854 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4855 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4856 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4857 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4858 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4859 0, 0, 0, 0, 0, 0, 0, 0,
4860 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4861 0, 0, 0, 0, 0, 0, 0, "delete"
4864 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4865 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4867 static char *iso_lispy_function_keys
[] =
4869 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4870 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4871 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4872 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4873 "iso-lefttab", /* 0xfe20 */
4874 "iso-move-line-up", "iso-move-line-down",
4875 "iso-partial-line-up", "iso-partial-line-down",
4876 "iso-partial-space-left", "iso-partial-space-right",
4877 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4878 "iso-release-margin-left", "iso-release-margin-right",
4879 "iso-release-both-margins",
4880 "iso-fast-cursor-left", "iso-fast-cursor-right",
4881 "iso-fast-cursor-up", "iso-fast-cursor-down",
4882 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4883 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4886 #endif /* not HAVE_NTGUI */
4888 Lisp_Object Vlispy_mouse_stem
;
4890 static char *lispy_wheel_names
[] =
4892 "wheel-up", "wheel-down"
4895 /* drag-n-drop events are generated when a set of selected files are
4896 dragged from another application and dropped onto an Emacs window. */
4897 static char *lispy_drag_n_drop_names
[] =
4902 /* Scroll bar parts. */
4903 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
4904 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
4905 Lisp_Object Qtop
, Qratio
;
4907 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
4908 Lisp_Object
*scroll_bar_parts
[] = {
4909 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
4910 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
4913 /* User signal events. */
4914 Lisp_Object Qusr1_signal
, Qusr2_signal
;
4916 Lisp_Object
*lispy_user_signals
[] =
4918 &Qusr1_signal
, &Qusr2_signal
4922 /* A vector, indexed by button number, giving the down-going location
4923 of currently depressed buttons, both scroll bar and non-scroll bar.
4925 The elements have the form
4926 (BUTTON-NUMBER MODIFIER-MASK . REST)
4927 where REST is the cdr of a position as it would be reported in the event.
4929 The make_lispy_event function stores positions here to tell the
4930 difference between click and drag events, and to store the starting
4931 location to be included in drag events. */
4933 static Lisp_Object button_down_location
;
4935 /* Information about the most recent up-going button event: Which
4936 button, what location, and what time. */
4938 static int last_mouse_button
;
4939 static int last_mouse_x
;
4940 static int last_mouse_y
;
4941 static unsigned long button_down_time
;
4943 /* The maximum time between clicks to make a double-click, or Qnil to
4944 disable double-click detection, or Qt for no time limit. */
4946 Lisp_Object Vdouble_click_time
;
4948 /* Maximum number of pixels the mouse may be moved between clicks
4949 to make a double-click. */
4951 EMACS_INT double_click_fuzz
;
4953 /* The number of clicks in this multiple-click. */
4955 int double_click_count
;
4957 /* Return position of a mouse click or wheel event */
4960 make_lispy_position (f
, x
, y
, time
)
4966 enum window_part part
;
4967 Lisp_Object posn
= Qnil
;
4968 Lisp_Object extra_info
= Qnil
;
4971 /* Set `window' to the window under frame pixel coordinates (x,y) */
4973 window
= window_from_coordinates (f
, XINT (*x
), XINT (*y
),
4974 &part
, &wx
, &wy
, 0);
4978 if (WINDOWP (window
))
4980 /* It's a click in window window at frame coordinates (x,y) */
4981 struct window
*w
= XWINDOW (window
);
4982 Lisp_Object string_info
= Qnil
;
4983 int textpos
= -1, rx
= -1, ry
= -1;
4984 int dx
= -1, dy
= -1;
4985 int width
= -1, height
= -1;
4986 Lisp_Object object
= Qnil
;
4988 /* Set event coordinates to window-relative coordinates
4989 for constructing the Lisp event below. */
4993 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
4995 /* Mode line or header line. Look for a string under
4996 the mouse that may have a `local-map' property. */
5000 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5002 string
= mode_line_string (w
, part
, &rx
, &ry
, &charpos
,
5003 &object
, &dx
, &dy
, &width
, &height
);
5004 if (STRINGP (string
))
5005 string_info
= Fcons (string
, make_number (charpos
));
5006 if (w
== XWINDOW (selected_window
))
5009 textpos
= XMARKER (w
->pointm
)->charpos
;
5011 else if (part
== ON_VERTICAL_BORDER
)
5013 posn
= Qvertical_line
;
5018 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5023 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5025 string
= marginal_area_string (w
, part
, &rx
, &ry
, &charpos
,
5026 &object
, &dx
, &dy
, &width
, &height
);
5027 if (STRINGP (string
))
5028 string_info
= Fcons (string
, make_number (charpos
));
5030 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
)
5032 posn
= (part
== ON_LEFT_FRINGE
) ? Qleft_fringe
: Qright_fringe
;
5035 if (part
== ON_RIGHT_FRINGE
)
5036 dx
-= (window_box_width (w
, LEFT_MARGIN_AREA
)
5037 + window_box_width (w
, TEXT_AREA
)
5038 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5039 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5041 else if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
5042 dx
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5047 Lisp_Object string2
, object2
= Qnil
;
5048 struct display_pos p
;
5050 int width2
, height2
;
5051 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5052 string2
= buffer_posn_from_coords (w
, &wx
, &wy
, &p
,
5053 &object2
, &dx2
, &dy2
,
5055 textpos
= CHARPOS (p
.pos
);
5056 if (rx
< 0) rx
= wx
;
5057 if (ry
< 0) ry
= wy
;
5058 if (dx
< 0) dx
= dx2
;
5059 if (dy
< 0) dy
= dy2
;
5060 if (width
< 0) width
= width2
;
5061 if (height
< 0) height
= height2
;
5065 posn
= make_number (textpos
);
5066 if (STRINGP (string2
))
5067 string_info
= Fcons (string2
,
5068 make_number (CHARPOS (p
.string_pos
)));
5074 #ifdef HAVE_WINDOW_SYSTEM
5075 if (IMAGEP (object
))
5077 Lisp_Object image_map
, hotspot
;
5078 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5080 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5082 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5083 posn
= XCAR (hotspot
);
5088 extra_info
= Fcons (object
,
5089 Fcons (Fcons (make_number (dx
),
5091 Fcons (Fcons (make_number (width
),
5092 make_number (height
)),
5096 extra_info
= Fcons (string_info
,
5097 Fcons (make_number (textpos
),
5098 Fcons (Fcons (make_number (rx
),
5104 XSETFRAME (window
, f
);
5109 XSETFASTINT (*x
, 0);
5110 XSETFASTINT (*y
, 0);
5113 return Fcons (window
,
5115 Fcons (Fcons (*x
, *y
),
5116 Fcons (make_number (time
),
5120 /* Given a struct input_event, build the lisp event which represents
5121 it. If EVENT is 0, build a mouse movement event from the mouse
5122 movement buffer, which should have a movement event in it.
5124 Note that events must be passed to this function in the order they
5125 are received; this function stores the location of button presses
5126 in order to build drag events when the button is released. */
5129 make_lispy_event (event
)
5130 struct input_event
*event
;
5134 switch (SWITCH_ENUM_CAST (event
->kind
))
5136 /* A simple keystroke. */
5137 case ASCII_KEYSTROKE_EVENT
:
5139 Lisp_Object lispy_c
;
5140 int c
= event
->code
& 0377;
5141 /* Turn ASCII characters into control characters
5143 if (event
->modifiers
& ctrl_modifier
)
5144 c
= make_ctrl_char (c
);
5146 /* Add in the other modifier bits. We took care of ctrl_modifier
5147 just above, and the shift key was taken care of by the X code,
5148 and applied to control characters by make_ctrl_char. */
5149 c
|= (event
->modifiers
5150 & (meta_modifier
| alt_modifier
5151 | hyper_modifier
| super_modifier
));
5152 /* Distinguish Shift-SPC from SPC. */
5153 if ((event
->code
& 0377) == 040
5154 && event
->modifiers
& shift_modifier
)
5155 c
|= shift_modifier
;
5156 button_down_time
= 0;
5157 XSETFASTINT (lispy_c
, c
);
5161 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5163 Lisp_Object lispy_c
;
5164 int c
= event
->code
;
5166 /* Add in the other modifier bits. We took care of ctrl_modifier
5167 just above, and the shift key was taken care of by the X code,
5168 and applied to control characters by make_ctrl_char. */
5169 c
|= (event
->modifiers
5170 & (meta_modifier
| alt_modifier
5171 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5172 /* What about the `shift' modifier ? */
5173 button_down_time
= 0;
5174 XSETFASTINT (lispy_c
, c
);
5178 /* A function key. The symbol may need to have modifier prefixes
5180 case NON_ASCII_KEYSTROKE_EVENT
:
5181 button_down_time
= 0;
5183 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5184 if (event
->code
== lispy_accent_codes
[i
])
5185 return modify_event_symbol (i
,
5187 Qfunction_key
, Qnil
,
5188 lispy_accent_keys
, &accent_key_syms
,
5189 (sizeof (lispy_accent_keys
)
5190 / sizeof (lispy_accent_keys
[0])));
5194 if (event
->code
>= 0x400 && event
->code
< 0x500)
5195 return modify_event_symbol (event
->code
- 0x400,
5196 event
->modifiers
& ~shift_modifier
,
5197 Qfunction_key
, Qnil
,
5198 lispy_kana_keys
, &func_key_syms
,
5199 (sizeof (lispy_kana_keys
)
5200 / sizeof (lispy_kana_keys
[0])));
5201 #endif /* XK_kana_A */
5204 #ifdef ISO_FUNCTION_KEY_OFFSET
5205 if (event
->code
< FUNCTION_KEY_OFFSET
5206 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5207 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5209 Qfunction_key
, Qnil
,
5210 iso_lispy_function_keys
, &func_key_syms
,
5211 (sizeof (iso_lispy_function_keys
)
5212 / sizeof (iso_lispy_function_keys
[0])));
5215 /* Handle system-specific or unknown keysyms. */
5216 if (event
->code
& (1 << 28)
5217 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5218 || (event
->code
- FUNCTION_KEY_OFFSET
5219 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5220 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5222 /* We need to use an alist rather than a vector as the cache
5223 since we can't make a vector long enuf. */
5224 if (NILP (current_kboard
->system_key_syms
))
5225 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5226 return modify_event_symbol (event
->code
,
5229 current_kboard
->Vsystem_key_alist
,
5230 0, ¤t_kboard
->system_key_syms
,
5234 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5236 Qfunction_key
, Qnil
,
5237 lispy_function_keys
, &func_key_syms
,
5238 (sizeof (lispy_function_keys
)
5239 / sizeof (lispy_function_keys
[0])));
5242 /* A mouse click. Figure out where it is, decide whether it's
5243 a press, click or drag, and build the appropriate structure. */
5244 case MOUSE_CLICK_EVENT
:
5245 #ifndef USE_TOOLKIT_SCROLL_BARS
5246 case SCROLL_BAR_CLICK_EVENT
:
5249 int button
= event
->code
;
5251 Lisp_Object position
;
5252 Lisp_Object
*start_pos_ptr
;
5253 Lisp_Object start_pos
;
5257 /* Build the position as appropriate for this mouse click. */
5258 if (event
->kind
== MOUSE_CLICK_EVENT
)
5260 struct frame
*f
= XFRAME (event
->frame_or_window
);
5261 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5265 /* Ignore mouse events that were made on frame that
5266 have been deleted. */
5267 if (! FRAME_LIVE_P (f
))
5270 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5271 /* EVENT->x and EVENT->y are frame-relative pixel
5272 coordinates at this place. Under old redisplay, COLUMN
5273 and ROW are set to frame relative glyph coordinates
5274 which are then used to determine whether this click is
5275 in a menu (non-toolkit version). */
5276 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5277 &column
, &row
, NULL
, 1);
5279 /* In the non-toolkit version, clicks on the menu bar
5280 are ordinary button events in the event buffer.
5281 Distinguish them, and invoke the menu.
5283 (In the toolkit version, the toolkit handles the menu bar
5284 and Emacs doesn't know about it until after the user
5285 makes a selection.) */
5286 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5287 && (event
->modifiers
& down_modifier
))
5289 Lisp_Object items
, item
;
5294 /* Activate the menu bar on the down event. If the
5295 up event comes in before the menu code can deal with it,
5297 if (! (event
->modifiers
& down_modifier
))
5301 /* Find the menu bar item under `column'. */
5303 items
= FRAME_MENU_BAR_ITEMS (f
);
5304 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5306 Lisp_Object pos
, string
;
5307 string
= AREF (items
, i
+ 1);
5308 pos
= AREF (items
, i
+ 3);
5311 if (column
>= XINT (pos
)
5312 && column
< XINT (pos
) + SCHARS (string
))
5314 item
= AREF (items
, i
);
5319 /* ELisp manual 2.4b says (x y) are window relative but
5320 code says they are frame-relative. */
5322 = Fcons (event
->frame_or_window
,
5324 Fcons (Fcons (event
->x
, event
->y
),
5325 Fcons (make_number (event
->timestamp
),
5328 return Fcons (item
, Fcons (position
, Qnil
));
5330 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5332 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5335 #ifndef USE_TOOLKIT_SCROLL_BARS
5338 /* It's a scrollbar click. */
5340 Lisp_Object portion_whole
;
5343 window
= event
->frame_or_window
;
5344 portion_whole
= Fcons (event
->x
, event
->y
);
5345 part
= *scroll_bar_parts
[(int) event
->part
];
5349 Fcons (Qvertical_scroll_bar
,
5350 Fcons (portion_whole
,
5351 Fcons (make_number (event
->timestamp
),
5352 Fcons (part
, Qnil
)))));
5354 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5356 if (button
>= ASIZE (button_down_location
))
5358 button_down_location
= larger_vector (button_down_location
,
5360 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5363 start_pos_ptr
= &AREF (button_down_location
, button
);
5364 start_pos
= *start_pos_ptr
;
5365 *start_pos_ptr
= Qnil
;
5368 /* On window-system frames, use the value of
5369 double-click-fuzz as is. On other frames, interpret it
5370 as a multiple of 1/8 characters. */
5374 if (WINDOWP (event
->frame_or_window
))
5375 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5376 else if (FRAMEP (event
->frame_or_window
))
5377 f
= XFRAME (event
->frame_or_window
);
5381 if (FRAME_WINDOW_P (f
))
5382 fuzz
= double_click_fuzz
;
5384 fuzz
= double_click_fuzz
/ 8;
5386 is_double
= (button
== last_mouse_button
5387 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5388 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5389 && button_down_time
!= 0
5390 && (EQ (Vdouble_click_time
, Qt
)
5391 || (INTEGERP (Vdouble_click_time
)
5392 && ((int)(event
->timestamp
- button_down_time
)
5393 < XINT (Vdouble_click_time
)))));
5396 last_mouse_button
= button
;
5397 last_mouse_x
= XINT (event
->x
);
5398 last_mouse_y
= XINT (event
->y
);
5400 /* If this is a button press, squirrel away the location, so
5401 we can decide later whether it was a click or a drag. */
5402 if (event
->modifiers
& down_modifier
)
5406 double_click_count
++;
5407 event
->modifiers
|= ((double_click_count
> 2)
5412 double_click_count
= 1;
5413 button_down_time
= event
->timestamp
;
5414 *start_pos_ptr
= Fcopy_alist (position
);
5417 /* Now we're releasing a button - check the co-ordinates to
5418 see if this was a click or a drag. */
5419 else if (event
->modifiers
& up_modifier
)
5421 /* If we did not see a down before this up, ignore the up.
5422 Probably this happened because the down event chose a
5423 menu item. It would be an annoyance to treat the
5424 release of the button that chose the menu item as a
5427 if (!CONSP (start_pos
))
5430 event
->modifiers
&= ~up_modifier
;
5431 #if 0 /* Formerly we treated an up with no down as a click event. */
5432 if (!CONSP (start_pos
))
5433 event
->modifiers
|= click_modifier
;
5438 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5440 /* The third element of every position
5441 should be the (x,y) pair. */
5442 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5444 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5446 xdiff
= XFASTINT (event
->x
) - XFASTINT (XCAR (down
));
5447 ydiff
= XFASTINT (event
->y
) - XFASTINT (XCDR (down
));
5450 if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5451 && ydiff
< double_click_fuzz
5452 && ydiff
> - double_click_fuzz
)
5453 /* Mouse hasn't moved (much). */
5454 event
->modifiers
|= click_modifier
;
5457 button_down_time
= 0;
5458 event
->modifiers
|= drag_modifier
;
5461 /* Don't check is_double; treat this as multiple
5462 if the down-event was multiple. */
5463 if (double_click_count
> 1)
5464 event
->modifiers
|= ((double_click_count
> 2)
5470 /* Every mouse event should either have the down_modifier or
5471 the up_modifier set. */
5475 /* Get the symbol we should use for the mouse click. */
5478 head
= modify_event_symbol (button
,
5480 Qmouse_click
, Vlispy_mouse_stem
,
5483 XVECTOR (mouse_syms
)->size
);
5484 if (event
->modifiers
& drag_modifier
)
5489 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5492 Fcons (make_number (double_click_count
),
5503 Lisp_Object position
;
5506 /* Build the position as appropriate for this mouse click. */
5507 struct frame
*f
= XFRAME (event
->frame_or_window
);
5509 /* Ignore wheel events that were made on frame that have been
5511 if (! FRAME_LIVE_P (f
))
5514 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5517 /* Set double or triple modifiers to indicate the wheel speed. */
5519 /* On window-system frames, use the value of
5520 double-click-fuzz as is. On other frames, interpret it
5521 as a multiple of 1/8 characters. */
5526 if (WINDOWP (event
->frame_or_window
))
5527 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5528 else if (FRAMEP (event
->frame_or_window
))
5529 f
= XFRAME (event
->frame_or_window
);
5533 if (FRAME_WINDOW_P (f
))
5534 fuzz
= double_click_fuzz
;
5536 fuzz
= double_click_fuzz
/ 8;
5538 is_double
= (last_mouse_button
< 0
5539 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5540 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5541 && button_down_time
!= 0
5542 && (EQ (Vdouble_click_time
, Qt
)
5543 || (INTEGERP (Vdouble_click_time
)
5544 && ((int)(event
->timestamp
- button_down_time
)
5545 < XINT (Vdouble_click_time
)))));
5548 double_click_count
++;
5549 event
->modifiers
|= ((double_click_count
> 2)
5555 double_click_count
= 1;
5556 event
->modifiers
|= click_modifier
;
5559 button_down_time
= event
->timestamp
;
5560 /* Use a negative value to distinguish wheel from mouse button. */
5561 last_mouse_button
= -1;
5562 last_mouse_x
= XINT (event
->x
);
5563 last_mouse_y
= XINT (event
->y
);
5569 if (event
->modifiers
& up_modifier
)
5571 /* Emit a wheel-up event. */
5572 event
->modifiers
&= ~up_modifier
;
5575 else if (event
->modifiers
& down_modifier
)
5577 /* Emit a wheel-down event. */
5578 event
->modifiers
&= ~down_modifier
;
5582 /* Every wheel event should either have the down_modifier or
5583 the up_modifier set. */
5586 /* Get the symbol we should use for the wheel event. */
5587 head
= modify_event_symbol (symbol_num
,
5593 ASIZE (wheel_syms
));
5596 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5599 Fcons (make_number (double_click_count
),
5608 #ifdef USE_TOOLKIT_SCROLL_BARS
5610 /* We don't have down and up events if using toolkit scroll bars,
5611 so make this always a click event. Store in the `part' of
5612 the Lisp event a symbol which maps to the following actions:
5614 `above_handle' page up
5615 `below_handle' page down
5619 `bottom' bottom of buffer
5620 `handle' thumb has been dragged.
5621 `end-scroll' end of interaction with scroll bar
5623 The incoming input_event contains in its `part' member an
5624 index of type `enum scroll_bar_part' which we can use as an
5625 index in scroll_bar_parts to get the appropriate symbol. */
5627 case SCROLL_BAR_CLICK_EVENT
:
5629 Lisp_Object position
, head
, window
, portion_whole
, part
;
5631 window
= event
->frame_or_window
;
5632 portion_whole
= Fcons (event
->x
, event
->y
);
5633 part
= *scroll_bar_parts
[(int) event
->part
];
5637 Fcons (Qvertical_scroll_bar
,
5638 Fcons (portion_whole
,
5639 Fcons (make_number (event
->timestamp
),
5640 Fcons (part
, Qnil
)))));
5642 /* Always treat scroll bar events as clicks. */
5643 event
->modifiers
|= click_modifier
;
5644 event
->modifiers
&= ~up_modifier
;
5646 if (event
->code
>= ASIZE (mouse_syms
))
5647 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5649 /* Get the symbol we should use for the mouse click. */
5650 head
= modify_event_symbol (event
->code
,
5655 XVECTOR (mouse_syms
)->size
);
5656 return Fcons (head
, Fcons (position
, Qnil
));
5659 #endif /* USE_TOOLKIT_SCROLL_BARS */
5662 case W32_SCROLL_BAR_CLICK_EVENT
:
5664 int button
= event
->code
;
5666 Lisp_Object position
;
5667 Lisp_Object
*start_pos_ptr
;
5668 Lisp_Object start_pos
;
5672 Lisp_Object portion_whole
;
5675 window
= event
->frame_or_window
;
5676 portion_whole
= Fcons (event
->x
, event
->y
);
5677 part
= *scroll_bar_parts
[(int) event
->part
];
5681 Fcons (Qvertical_scroll_bar
,
5682 Fcons (portion_whole
,
5683 Fcons (make_number (event
->timestamp
),
5684 Fcons (part
, Qnil
)))));
5687 /* Always treat W32 scroll bar events as clicks. */
5688 event
->modifiers
|= click_modifier
;
5691 /* Get the symbol we should use for the mouse click. */
5694 head
= modify_event_symbol (button
,
5699 XVECTOR (mouse_syms
)->size
);
5705 #endif /* WINDOWSNT */
5707 case DRAG_N_DROP_EVENT
:
5710 Lisp_Object head
, position
;
5713 /* The frame_or_window field should be a cons of the frame in
5714 which the event occurred and a list of the filenames
5716 if (! CONSP (event
->frame_or_window
))
5719 f
= XFRAME (XCAR (event
->frame_or_window
));
5720 files
= XCDR (event
->frame_or_window
);
5722 /* Ignore mouse events that were made on frames that
5723 have been deleted. */
5724 if (! FRAME_LIVE_P (f
))
5727 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5730 head
= modify_event_symbol (0, event
->modifiers
,
5732 lispy_drag_n_drop_names
,
5733 &drag_n_drop_syms
, 1);
5739 #endif /* HAVE_MOUSE */
5741 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
5742 || defined (USE_GTK)
5743 case MENU_BAR_EVENT
:
5744 if (EQ (event
->arg
, event
->frame_or_window
))
5745 /* This is the prefix key. We translate this to
5746 `(menu_bar)' because the code in keyboard.c for menu
5747 events, which we use, relies on this. */
5748 return Fcons (Qmenu_bar
, Qnil
);
5752 case SELECT_WINDOW_EVENT
:
5753 /* Make an event (select-window (WINDOW)). */
5754 return Fcons (Qselect_window
,
5755 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5758 case TOOL_BAR_EVENT
:
5759 if (EQ (event
->arg
, event
->frame_or_window
))
5760 /* This is the prefix key. We translate this to
5761 `(tool_bar)' because the code in keyboard.c for tool bar
5762 events, which we use, relies on this. */
5763 return Fcons (Qtool_bar
, Qnil
);
5764 else if (SYMBOLP (event
->arg
))
5765 return apply_modifiers (event
->modifiers
, event
->arg
);
5768 case USER_SIGNAL_EVENT
:
5769 /* A user signal. */
5770 return *lispy_user_signals
[event
->code
];
5772 case SAVE_SESSION_EVENT
:
5773 return Qsave_session
;
5775 /* The 'kind' field of the event is something we don't recognize. */
5784 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
5786 Lisp_Object bar_window
;
5787 enum scroll_bar_part part
;
5791 /* Is it a scroll bar movement? */
5792 if (frame
&& ! NILP (bar_window
))
5794 Lisp_Object part_sym
;
5796 part_sym
= *scroll_bar_parts
[(int) part
];
5797 return Fcons (Qscroll_bar_movement
,
5798 (Fcons (Fcons (bar_window
,
5799 Fcons (Qvertical_scroll_bar
,
5800 Fcons (Fcons (x
, y
),
5801 Fcons (make_number (time
),
5807 /* Or is it an ordinary mouse movement? */
5810 Lisp_Object position
;
5812 position
= make_lispy_position (frame
, &x
, &y
, time
);
5814 return Fcons (Qmouse_movement
,
5820 #endif /* HAVE_MOUSE */
5822 /* Construct a switch frame event. */
5824 make_lispy_switch_frame (frame
)
5827 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
5830 /* Manipulating modifiers. */
5832 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5834 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5835 SYMBOL's name of the end of the modifiers; the string from this
5836 position is the unmodified symbol name.
5838 This doesn't use any caches. */
5841 parse_modifiers_uncached (symbol
, modifier_end
)
5849 CHECK_SYMBOL (symbol
);
5852 name
= SYMBOL_NAME (symbol
);
5854 for (i
= 0; i
+2 <= SBYTES (name
); )
5856 int this_mod_end
= 0;
5859 /* See if the name continues with a modifier word.
5860 Check that the word appears, but don't check what follows it.
5861 Set this_mod and this_mod_end to record what we find. */
5863 switch (SREF (name
, i
))
5865 #define SINGLE_LETTER_MOD(BIT) \
5866 (this_mod_end = i + 1, this_mod = BIT)
5869 SINGLE_LETTER_MOD (alt_modifier
);
5873 SINGLE_LETTER_MOD (ctrl_modifier
);
5877 SINGLE_LETTER_MOD (hyper_modifier
);
5881 SINGLE_LETTER_MOD (meta_modifier
);
5885 SINGLE_LETTER_MOD (shift_modifier
);
5889 SINGLE_LETTER_MOD (super_modifier
);
5892 #undef SINGLE_LETTER_MOD
5894 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
5895 if (i + LEN + 1 <= SBYTES (name) \
5896 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
5898 this_mod_end = i + LEN; \
5903 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
5904 MULTI_LETTER_MOD (down_modifier
, "down", 4);
5905 MULTI_LETTER_MOD (double_modifier
, "double", 6);
5909 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
5911 #undef MULTI_LETTER_MOD
5915 /* If we found no modifier, stop looking for them. */
5916 if (this_mod_end
== 0)
5919 /* Check there is a dash after the modifier, so that it
5920 really is a modifier. */
5921 if (this_mod_end
>= SBYTES (name
)
5922 || SREF (name
, this_mod_end
) != '-')
5925 /* This modifier is real; look for another. */
5926 modifiers
|= this_mod
;
5927 i
= this_mod_end
+ 1;
5930 /* Should we include the `click' modifier? */
5931 if (! (modifiers
& (down_modifier
| drag_modifier
5932 | double_modifier
| triple_modifier
))
5933 && i
+ 7 == SBYTES (name
)
5934 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
5935 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
5936 modifiers
|= click_modifier
;
5944 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5945 prepended to the string BASE[0..BASE_LEN-1].
5946 This doesn't use any caches. */
5948 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
5951 int base_len
, base_len_byte
;
5953 /* Since BASE could contain nulls, we can't use intern here; we have
5954 to use Fintern, which expects a genuine Lisp_String, and keeps a
5957 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
5963 /* Only the event queue may use the `up' modifier; it should always
5964 be turned into a click or drag event before presented to lisp code. */
5965 if (modifiers
& up_modifier
)
5968 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
5969 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
5970 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
5971 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
5972 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
5973 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
5974 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
5975 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
5976 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
5977 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
5978 /* The click modifier is denoted by the absence of other modifiers. */
5982 mod_len
= p
- new_mods
;
5986 Lisp_Object new_name
;
5988 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
5989 mod_len
+ base_len_byte
);
5990 bcopy (new_mods
, SDATA (new_name
), mod_len
);
5991 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
5993 return Fintern (new_name
, Qnil
);
5998 static char *modifier_names
[] =
6000 "up", "down", "drag", "click", "double", "triple", 0, 0,
6001 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6002 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6004 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6006 static Lisp_Object modifier_symbols
;
6008 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6010 lispy_modifier_list (modifiers
)
6013 Lisp_Object modifier_list
;
6016 modifier_list
= Qnil
;
6017 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6018 if (modifiers
& (1<<i
))
6019 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6022 return modifier_list
;
6026 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6027 where UNMODIFIED is the unmodified form of SYMBOL,
6028 MASK is the set of modifiers present in SYMBOL's name.
6029 This is similar to parse_modifiers_uncached, but uses the cache in
6030 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6031 Qevent_symbol_elements property. */
6034 parse_modifiers (symbol
)
6037 Lisp_Object elements
;
6039 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6040 if (CONSP (elements
))
6045 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6046 Lisp_Object unmodified
;
6049 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6050 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6053 if (modifiers
& ~INTMASK
)
6055 XSETFASTINT (mask
, modifiers
);
6056 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6058 /* Cache the parsing results on SYMBOL. */
6059 Fput (symbol
, Qevent_symbol_element_mask
,
6061 Fput (symbol
, Qevent_symbol_elements
,
6062 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6064 /* Since we know that SYMBOL is modifiers applied to unmodified,
6065 it would be nice to put that in unmodified's cache.
6066 But we can't, since we're not sure that parse_modifiers is
6073 /* Apply the modifiers MODIFIERS to the symbol BASE.
6074 BASE must be unmodified.
6076 This is like apply_modifiers_uncached, but uses BASE's
6077 Qmodifier_cache property, if present. It also builds
6078 Qevent_symbol_elements properties, since it has that info anyway.
6080 apply_modifiers copies the value of BASE's Qevent_kind property to
6081 the modified symbol. */
6083 apply_modifiers (modifiers
, base
)
6087 Lisp_Object cache
, index
, entry
, new_symbol
;
6089 /* Mask out upper bits. We don't know where this value's been. */
6090 modifiers
&= INTMASK
;
6092 /* The click modifier never figures into cache indices. */
6093 cache
= Fget (base
, Qmodifier_cache
);
6094 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6095 entry
= assq_no_quit (index
, cache
);
6098 new_symbol
= XCDR (entry
);
6101 /* We have to create the symbol ourselves. */
6102 new_symbol
= apply_modifiers_uncached (modifiers
,
6103 SDATA (SYMBOL_NAME (base
)),
6104 SCHARS (SYMBOL_NAME (base
)),
6105 SBYTES (SYMBOL_NAME (base
)));
6107 /* Add the new symbol to the base's cache. */
6108 entry
= Fcons (index
, new_symbol
);
6109 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6111 /* We have the parsing info now for free, so we could add it to
6113 XSETFASTINT (index, modifiers);
6114 Fput (new_symbol, Qevent_symbol_element_mask,
6115 Fcons (base, Fcons (index, Qnil)));
6116 Fput (new_symbol, Qevent_symbol_elements,
6117 Fcons (base, lispy_modifier_list (modifiers)));
6118 Sadly, this is only correct if `base' is indeed a base event,
6119 which is not necessarily the case. -stef */
6122 /* Make sure this symbol is of the same kind as BASE.
6124 You'd think we could just set this once and for all when we
6125 intern the symbol above, but reorder_modifiers may call us when
6126 BASE's property isn't set right; we can't assume that just
6127 because it has a Qmodifier_cache property it must have its
6128 Qevent_kind set right as well. */
6129 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6133 kind
= Fget (base
, Qevent_kind
);
6135 Fput (new_symbol
, Qevent_kind
, kind
);
6142 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6143 return a symbol with the modifiers placed in the canonical order.
6144 Canonical order is alphabetical, except for down and drag, which
6145 always come last. The 'click' modifier is never written out.
6147 Fdefine_key calls this to make sure that (for example) C-M-foo
6148 and M-C-foo end up being equivalent in the keymap. */
6151 reorder_modifiers (symbol
)
6154 /* It's hopefully okay to write the code this way, since everything
6155 will soon be in caches, and no consing will be done at all. */
6158 parsed
= parse_modifiers (symbol
);
6159 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6164 /* For handling events, we often want to produce a symbol whose name
6165 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6166 to some base, like the name of a function key or mouse button.
6167 modify_event_symbol produces symbols of this sort.
6169 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6170 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6173 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6174 into symbol names, or a string specifying a name stem used to
6175 construct a symbol name or the form `STEM-N', where N is the decimal
6176 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6177 non-nil; otherwise NAME_TABLE is used.
6179 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6180 persist between calls to modify_event_symbol that it can use to
6181 store a cache of the symbols it's generated for this NAME_TABLE
6182 before. The object stored there may be a vector or an alist.
6184 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6186 MODIFIERS is a set of modifier bits (as given in struct input_events)
6187 whose prefixes should be applied to the symbol name.
6189 SYMBOL_KIND is the value to be placed in the event_kind property of
6190 the returned symbol.
6192 The symbols we create are supposed to have an
6193 `event-symbol-elements' property, which lists the modifiers present
6194 in the symbol's name. */
6197 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6198 name_table
, symbol_table
, table_size
)
6201 Lisp_Object symbol_kind
;
6202 Lisp_Object name_alist_or_stem
;
6204 Lisp_Object
*symbol_table
;
6205 unsigned int table_size
;
6208 Lisp_Object symbol_int
;
6210 /* Get rid of the "vendor-specific" bit here. */
6211 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6213 /* Is this a request for a valid symbol? */
6214 if (symbol_num
< 0 || symbol_num
>= table_size
)
6217 if (CONSP (*symbol_table
))
6218 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6220 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6221 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6222 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6223 we've never used that symbol before. */
6226 if (! VECTORP (*symbol_table
)
6227 || XVECTOR (*symbol_table
)->size
!= table_size
)
6231 XSETFASTINT (size
, table_size
);
6232 *symbol_table
= Fmake_vector (size
, Qnil
);
6235 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6238 /* Have we already used this symbol before? */
6241 /* No; let's create it. */
6242 if (CONSP (name_alist_or_stem
))
6243 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6244 else if (STRINGP (name_alist_or_stem
))
6246 int len
= SBYTES (name_alist_or_stem
);
6247 char *buf
= (char *) alloca (len
+ 50);
6248 if (sizeof (int) == sizeof (EMACS_INT
))
6249 sprintf (buf
, "%s-%d", SDATA (name_alist_or_stem
),
6250 XINT (symbol_int
) + 1);
6251 else if (sizeof (long) == sizeof (EMACS_INT
))
6252 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6253 XINT (symbol_int
) + 1);
6254 value
= intern (buf
);
6256 else if (name_table
!= 0 && name_table
[symbol_num
])
6257 value
= intern (name_table
[symbol_num
]);
6259 #ifdef HAVE_WINDOW_SYSTEM
6262 char *name
= x_get_keysym_name (symbol_num
);
6264 value
= intern (name
);
6271 sprintf (buf
, "key-%d", symbol_num
);
6272 value
= intern (buf
);
6275 if (CONSP (*symbol_table
))
6276 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6278 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6280 /* Fill in the cache entries for this symbol; this also
6281 builds the Qevent_symbol_elements property, which the user
6283 apply_modifiers (modifiers
& click_modifier
, value
);
6284 Fput (value
, Qevent_kind
, symbol_kind
);
6287 /* Apply modifiers to that symbol. */
6288 return apply_modifiers (modifiers
, value
);
6291 /* Convert a list that represents an event type,
6292 such as (ctrl meta backspace), into the usual representation of that
6293 event type as a number or a symbol. */
6295 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6296 doc
: /* Convert the event description list EVENT-DESC to an event type.
6297 EVENT-DESC should contain one base event type (a character or symbol)
6298 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6299 drag, down, double or triple). The base must be last.
6300 The return value is an event type (a character or symbol) which
6301 has the same base event type and all the specified modifiers. */)
6303 Lisp_Object event_desc
;
6311 while (CONSP (rest
))
6319 /* Given a symbol, see if it is a modifier name. */
6320 if (SYMBOLP (elt
) && CONSP (rest
))
6321 this = parse_solitary_modifier (elt
);
6325 else if (!NILP (base
))
6326 error ("Two bases given in one event");
6332 /* Let the symbol A refer to the character A. */
6333 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6334 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6336 if (INTEGERP (base
))
6338 /* Turn (shift a) into A. */
6339 if ((modifiers
& shift_modifier
) != 0
6340 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6342 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6343 modifiers
&= ~shift_modifier
;
6346 /* Turn (control a) into C-a. */
6347 if (modifiers
& ctrl_modifier
)
6348 return make_number ((modifiers
& ~ctrl_modifier
)
6349 | make_ctrl_char (XINT (base
)));
6351 return make_number (modifiers
| XINT (base
));
6353 else if (SYMBOLP (base
))
6354 return apply_modifiers (modifiers
, base
);
6357 error ("Invalid base event");
6362 /* Try to recognize SYMBOL as a modifier name.
6363 Return the modifier flag bit, or 0 if not recognized. */
6366 parse_solitary_modifier (symbol
)
6369 Lisp_Object name
= SYMBOL_NAME (symbol
);
6371 switch (SREF (name
, 0))
6373 #define SINGLE_LETTER_MOD(BIT) \
6374 if (SBYTES (name) == 1) \
6377 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6378 if (LEN == SBYTES (name) \
6379 && ! strncmp (SDATA (name), NAME, LEN)) \
6383 SINGLE_LETTER_MOD (alt_modifier
);
6387 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6391 SINGLE_LETTER_MOD (ctrl_modifier
);
6395 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6396 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6400 SINGLE_LETTER_MOD (hyper_modifier
);
6404 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6408 SINGLE_LETTER_MOD (meta_modifier
);
6412 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6416 SINGLE_LETTER_MOD (shift_modifier
);
6420 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6421 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6422 SINGLE_LETTER_MOD (super_modifier
);
6426 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6427 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6428 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6432 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6435 #undef SINGLE_LETTER_MOD
6436 #undef MULTI_LETTER_MOD
6442 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6443 Such a list is not valid as an event,
6444 but it can be a Lucid-style event type list. */
6447 lucid_event_type_list_p (object
)
6452 if (! CONSP (object
))
6455 if (EQ (XCAR (object
), Qhelp_echo
)
6456 || EQ (XCAR (object
), Qvertical_line
)
6457 || EQ (XCAR (object
), Qmode_line
)
6458 || EQ (XCAR (object
), Qheader_line
))
6461 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6465 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6472 /* Store into *addr a value nonzero if terminal input chars are available.
6473 Serves the purpose of ioctl (0, FIONREAD, addr)
6474 but works even if FIONREAD does not exist.
6475 (In fact, this may actually read some input.)
6477 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
6478 If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
6481 get_filtered_input_pending (addr
, do_timers_now
, filter_events
)
6486 /* First of all, have we already counted some input? */
6487 *addr
= (!NILP (Vquit_flag
)
6488 || readable_filtered_events (do_timers_now
, filter_events
));
6490 /* If input is being read as it arrives, and we have none, there is none. */
6491 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6494 /* Try to read some input and see how much we get. */
6496 *addr
= (!NILP (Vquit_flag
)
6497 || readable_filtered_events (do_timers_now
, filter_events
));
6500 /* Store into *addr a value nonzero if terminal input chars are available.
6501 Serves the purpose of ioctl (0, FIONREAD, addr)
6502 but works even if FIONREAD does not exist.
6503 (In fact, this may actually read some input.)
6505 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
6508 get_input_pending (addr
, do_timers_now
)
6512 get_filtered_input_pending (addr
, do_timers_now
, 0);
6515 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6518 gobble_input (expected
)
6523 if (interrupt_input
)
6526 mask
= sigblock (sigmask (SIGIO
));
6527 read_avail_input (expected
);
6531 #ifdef POLL_FOR_INPUT
6532 /* XXX This condition was (read_socket_hook && !interrupt_input),
6533 but read_socket_hook is not global anymore. Let's pretend that
6535 if (!interrupt_input
&& poll_suppress_count
== 0)
6538 mask
= sigblock (sigmask (SIGALRM
));
6539 read_avail_input (expected
);
6545 read_avail_input (expected
);
6549 /* Put a BUFFER_SWITCH_EVENT in the buffer
6550 so that read_key_sequence will notice the new current buffer. */
6553 record_asynch_buffer_change ()
6555 struct input_event event
;
6559 event
.kind
= BUFFER_SWITCH_EVENT
;
6560 event
.frame_or_window
= Qnil
;
6564 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6565 The purpose of the event is to make read_key_sequence look up the
6566 keymaps again. If we aren't in read_key_sequence, we don't need one,
6567 and the event could cause trouble by messing up (input-pending-p). */
6568 tem
= Fwaiting_for_user_input_p ();
6572 /* We never need these events if we have no asynchronous subprocesses. */
6576 /* Make sure no interrupt happens while storing the event. */
6578 if (interrupt_input
)
6581 mask
= sigblock (sigmask (SIGIO
));
6582 kbd_buffer_store_event (&event
);
6589 kbd_buffer_store_event (&event
);
6596 /* Read any terminal input already buffered up by the system
6597 into the kbd_buffer, but do not wait.
6599 EXPECTED should be nonzero if the caller knows there is some input.
6601 Except on VMS, all input is read by this function.
6602 If interrupt_input is nonzero, this function MUST be called
6603 only when SIGIO is blocked.
6605 Returns the number of keyboard chars read, or -1 meaning
6606 this is a bad time to try to read input. */
6609 read_avail_input (expected
)
6612 struct input_event buf
[KBD_BUFFER_SIZE
];
6617 for (i
= 0; i
< KBD_BUFFER_SIZE
; i
++)
6618 EVENT_INIT (buf
[i
]);
6620 for (d
= display_list
; d
; d
= d
->next_display
)
6622 if (d
->read_socket_hook
)
6623 /* No need for FIONREAD or fcntl; just say don't wait. */
6624 nread
= (*d
->read_socket_hook
) (d
, buf
, KBD_BUFFER_SIZE
, expected
);
6630 /* Scan the chars for C-g and store them in kbd_buffer. */
6631 for (i
= 0; i
< nread
; i
++)
6633 kbd_buffer_store_event (&buf
[i
]);
6634 /* Don't look at input that follows a C-g too closely.
6635 This reduces lossage due to autorepeat on C-g. */
6636 if (buf
[i
].kind
== ASCII_KEYSTROKE_EVENT
6637 && buf
[i
].code
== quit_char
)
6644 /* This is the tty way of reading available input.
6646 Note that each terminal device has its own `struct display' object,
6647 and so this function is called once for each individual termcap
6648 display. The first parameter indicates which device to read from. */
6650 tty_read_avail_input (struct display
*display
,
6651 struct input_event
*buf
,
6652 int numchars
, int expected
)
6654 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6655 the kbd_buffer can really hold. That may prevent loss
6656 of characters on some systems when input is stuffed at us. */
6657 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6659 struct tty_display_info
*tty
= display
->display_info
.tty
;
6663 if (display
->type
!= output_termcap
)
6666 /* XXX I think the following code should be moved to separate
6667 functions in system-dependent files. */
6670 #else /* not WINDOWSNT */
6672 n_to_read
= dos_keysns ();
6676 cbuf
[0] = dos_keyread ();
6679 #else /* not MSDOS */
6681 if (! tty
->term_initted
)
6684 /* Determine how many characters we should *try* to read. */
6686 /* Find out how much input is available. */
6687 if (ioctl (fileno (TTY_INPUT (tty
)), FIONREAD
, &n_to_read
) < 0)
6689 if (! noninteractive
)
6691 delete_tty (tty
); /* XXX I wonder if this is safe here. */
6693 /* Formerly simply reported no input, but that sometimes led to
6694 a failure of Emacs to terminate.
6695 SIGHUP seems appropriate if we can't reach the terminal. */
6696 /* ??? Is it really right to send the signal just to this process
6697 rather than to the whole process group?
6698 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6699 /* It appears to be the case, see narrow_foreground_group. */
6700 if (! tty_list
->next
)
6701 kill (getpid (), SIGHUP
); /* This was the last terminal. */
6710 if (n_to_read
> sizeof cbuf
)
6711 n_to_read
= sizeof cbuf
;
6712 #else /* no FIONREAD */
6713 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
6714 /* Read some input if available, but don't wait. */
6715 n_to_read
= sizeof cbuf
;
6716 fcntl (fileno (TTY_INPUT (tty
)), F_SETFL
, O_NDELAY
);
6722 /* Now read; for one reason or another, this will not block.
6723 NREAD is set to the number of chars read. */
6726 nread
= emacs_read (fileno (TTY_INPUT (tty
)), 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 (! tty_list
->next
)
6735 kill (0, SIGHUP
); /* This was the last terminal. */
6737 delete_tty (tty
); /* XXX I wonder if this is safe here. */
6739 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6740 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6741 This looks incorrect, but it isn't, because _BSD causes
6742 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6743 and that causes a value other than 0 when there is no input. */
6746 if (! tty_list
->next
)
6747 kill (0, SIGHUP
); /* This was the last terminal. */
6749 delete_tty (tty
); /* XXX I wonder if this is safe here. */
6754 /* We used to retry the read if it was interrupted.
6755 But this does the wrong thing when O_NDELAY causes
6756 an EAGAIN error. Does anybody know of a situation
6757 where a retry is actually needed? */
6759 nread
< 0 && (errno
== EAGAIN
6773 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
6774 fcntl (fileno (TTY_INPUT (tty
)), F_SETFL
, 0);
6775 #endif /* USG or DGUX or CYGWIN */
6776 #endif /* no FIONREAD */
6781 #endif /* not MSDOS */
6782 #endif /* not WINDOWSNT */
6784 /* Select the frame corresponding to the active tty. Note that the
6785 value of selected_frame is not reliable here, redisplay tends to
6786 temporarily change it. */
6787 frame
= tty
->top_frame
;
6789 for (i
= 0; i
< nread
; i
++)
6791 buf
[i
].kind
= ASCII_KEYSTROKE_EVENT
;
6792 buf
[i
].modifiers
= 0;
6793 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
6794 buf
[i
].modifiers
= meta_modifier
;
6795 if (tty
->meta_key
!= 2)
6798 buf
[i
].code
= cbuf
[i
];
6799 buf
[i
].frame_or_window
= frame
;
6806 #endif /* not VMS */
6808 #ifdef SIGIO /* for entire page */
6809 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6812 input_available_signal (signo
)
6815 /* Must preserve main program's value of errno. */
6816 int old_errno
= errno
;
6818 extern int select_alarmed
;
6821 #if defined (USG) && !defined (POSIX_SIGNALS)
6822 /* USG systems forget handlers when they are used;
6823 must reestablish each time */
6824 signal (signo
, input_available_signal
);
6831 if (input_available_clear_time
)
6832 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6837 nread
= read_avail_input (1);
6838 /* -1 means it's not ok to read the input now.
6839 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6840 0 means there was no keyboard input available. */
6845 select_alarmed
= 1; /* Force the select emulator back to life */
6856 /* Send ourselves a SIGIO.
6858 This function exists so that the UNBLOCK_INPUT macro in
6859 blockinput.h can have some way to take care of input we put off
6860 dealing with, without assuming that every file which uses
6861 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6863 reinvoke_input_signal ()
6866 kill (getpid (), SIGIO
);
6872 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
6873 static Lisp_Object menu_bar_one_keymap_changed_items
;
6875 /* These variables hold the vector under construction within
6876 menu_bar_items and its subroutines, and the current index
6877 for storing into that vector. */
6878 static Lisp_Object menu_bar_items_vector
;
6879 static int menu_bar_items_index
;
6881 /* Return a vector of menu items for a menu bar, appropriate
6882 to the current buffer. Each item has three elements in the vector:
6885 OLD is an old vector we can optionally reuse, or nil. */
6888 menu_bar_items (old
)
6891 /* The number of keymaps we're scanning right now, and the number of
6892 keymaps we have allocated space for. */
6895 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6896 in the current keymaps, or nil where it is not a prefix. */
6899 Lisp_Object def
, tail
;
6908 struct gcpro gcpro1
;
6910 /* In order to build the menus, we need to call the keymap
6911 accessors. They all call QUIT. But this function is called
6912 during redisplay, during which a quit is fatal. So inhibit
6913 quitting while building the menus.
6914 We do this instead of specbind because (1) errors will clear it anyway
6915 and (2) this avoids risk of specpdl overflow. */
6916 oquit
= Vinhibit_quit
;
6920 menu_bar_items_vector
= old
;
6922 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
6923 menu_bar_items_index
= 0;
6925 GCPRO1 (menu_bar_items_vector
);
6927 /* Build our list of keymaps.
6928 If we recognize a function key and replace its escape sequence in
6929 keybuf with its symbol, or if the sequence starts with a mouse
6930 click and we need to switch buffers, we jump back here to rebuild
6931 the initial keymaps from the current buffer. */
6935 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6936 if (!NILP (Voverriding_local_map_menu_flag
))
6938 /* Yes, use them (if non-nil) as well as the global map. */
6939 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
6941 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
6942 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
6943 if (!NILP (Voverriding_local_map
))
6944 maps
[nmaps
++] = Voverriding_local_map
;
6948 /* No, so use major and minor mode keymaps and keymap property.
6949 Note that menu-bar bindings in the local-map and keymap
6950 properties may not work reliable, as they are only
6951 recognized when the menu-bar (or mode-line) is updated,
6952 which does not normally happen after every command. */
6955 nminor
= current_minor_maps (NULL
, &tmaps
);
6956 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
6958 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
6959 maps
[nmaps
++] = tem
;
6960 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
6962 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
6964 maps
[nmaps
++] = current_global_map
;
6967 /* Look up in each map the dummy prefix key `menu-bar'. */
6971 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
6972 if (!NILP (maps
[mapno
]))
6974 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
6978 menu_bar_one_keymap_changed_items
= Qnil
;
6979 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
6983 /* Move to the end those items that should be at the end. */
6985 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
6988 int end
= menu_bar_items_index
;
6990 for (i
= 0; i
< end
; i
+= 4)
6991 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6993 Lisp_Object tem0
, tem1
, tem2
, tem3
;
6994 /* Move the item at index I to the end,
6995 shifting all the others forward. */
6996 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
6997 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
6998 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
6999 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7001 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7002 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7003 (end
- i
- 4) * sizeof (Lisp_Object
));
7004 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7005 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7006 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7007 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7012 /* Add nil, nil, nil, nil at the end. */
7013 i
= menu_bar_items_index
;
7014 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7017 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7018 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7019 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7020 menu_bar_items_vector
= tem
;
7022 /* Add this item. */
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 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7027 menu_bar_items_index
= i
;
7029 Vinhibit_quit
= oquit
;
7031 return menu_bar_items_vector
;
7034 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7035 If there's already an item for KEY, add this DEF to it. */
7037 Lisp_Object item_properties
;
7040 menu_bar_item (key
, item
, dummy1
, dummy2
)
7041 Lisp_Object key
, item
, dummy1
;
7044 struct gcpro gcpro1
;
7048 if (EQ (item
, Qundefined
))
7050 /* If a map has an explicit `undefined' as definition,
7051 discard any previously made menu bar item. */
7053 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7054 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7056 if (menu_bar_items_index
> i
+ 4)
7057 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7058 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7059 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7060 menu_bar_items_index
-= 4;
7064 /* If this keymap has already contributed to this KEY,
7065 don't contribute to it a second time. */
7066 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7067 if (!NILP (tem
) || NILP (item
))
7070 menu_bar_one_keymap_changed_items
7071 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7073 /* We add to menu_bar_one_keymap_changed_items before doing the
7074 parse_menu_item, so that if it turns out it wasn't a menu item,
7075 it still correctly hides any further menu item. */
7077 i
= parse_menu_item (item
, 0, 1);
7082 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7084 /* Find any existing item for this KEY. */
7085 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7086 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7089 /* If we did not find this KEY, add it at the end. */
7090 if (i
== menu_bar_items_index
)
7092 /* If vector is too small, get a bigger one. */
7093 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7096 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7097 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7098 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7099 menu_bar_items_vector
= tem
;
7102 /* Add this item. */
7103 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7104 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7105 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7106 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7107 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7108 menu_bar_items_index
= i
;
7110 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7114 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7115 /* If the new and the old items are not both keymaps,
7116 the lookup will only find `item'. */
7117 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7118 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7122 /* This is used as the handler when calling menu_item_eval_property. */
7124 menu_item_eval_property_1 (arg
)
7127 /* If we got a quit from within the menu computation,
7128 quit all the way out of it. This takes care of C-] in the debugger. */
7129 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7130 Fsignal (Qquit
, Qnil
);
7135 /* Evaluate an expression and return the result (or nil if something
7136 went wrong). Used to evaluate dynamic parts of menu items. */
7138 menu_item_eval_property (sexpr
)
7141 int count
= SPECPDL_INDEX ();
7143 specbind (Qinhibit_redisplay
, Qt
);
7144 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7145 menu_item_eval_property_1
);
7146 return unbind_to (count
, val
);
7149 /* This function parses a menu item and leaves the result in the
7150 vector item_properties.
7151 ITEM is a key binding, a possible menu item.
7152 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7153 evaluate dynamic expressions in the menu item.
7154 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7156 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7157 parse_menu_item returns true if the item is a menu item and false
7161 parse_menu_item (item
, notreal
, inmenubar
)
7163 int notreal
, inmenubar
;
7165 Lisp_Object def
, tem
, item_string
, start
;
7166 Lisp_Object cachelist
;
7168 Lisp_Object keyhint
;
7179 /* Create item_properties vector if necessary. */
7180 if (NILP (item_properties
))
7182 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7184 /* Initialize optional entries. */
7185 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7186 AREF (item_properties
, i
) = Qnil
;
7187 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7189 /* Save the item here to protect it from GC. */
7190 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7192 item_string
= XCAR (item
);
7196 if (STRINGP (item_string
))
7198 /* Old format menu item. */
7199 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7201 /* Maybe help string. */
7202 if (CONSP (item
) && STRINGP (XCAR (item
)))
7204 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7209 /* Maybe key binding cache. */
7210 if (CONSP (item
) && CONSP (XCAR (item
))
7211 && (NILP (XCAR (XCAR (item
)))
7212 || VECTORP (XCAR (XCAR (item
)))))
7214 cachelist
= XCAR (item
);
7218 /* This is the real definition--the function to run. */
7219 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7221 /* Get enable property, if any. */
7224 tem
= Fget (item
, Qmenu_enable
);
7226 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7229 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7231 /* New format menu item. */
7232 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7233 start
= XCDR (item
);
7236 /* We have a real binding. */
7237 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7239 item
= XCDR (start
);
7240 /* Is there a cache list with key equivalences. */
7241 if (CONSP (item
) && CONSP (XCAR (item
)))
7243 cachelist
= XCAR (item
);
7247 /* Parse properties. */
7248 while (CONSP (item
) && CONSP (XCDR (item
)))
7253 if (EQ (tem
, QCenable
))
7254 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7255 else if (EQ (tem
, QCvisible
) && !notreal
)
7257 /* If got a visible property and that evaluates to nil
7258 then ignore this item. */
7259 tem
= menu_item_eval_property (XCAR (item
));
7263 else if (EQ (tem
, QChelp
))
7264 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7265 else if (EQ (tem
, QCfilter
))
7267 else if (EQ (tem
, QCkey_sequence
))
7270 if (NILP (cachelist
)
7271 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7272 /* Be GC protected. Set keyhint to item instead of tem. */
7275 else if (EQ (tem
, QCkeys
))
7278 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7279 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7281 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7286 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7288 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7290 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7297 else if (inmenubar
|| !NILP (start
))
7301 return 0; /* not a menu item */
7303 /* If item string is not a string, evaluate it to get string.
7304 If we don't get a string, skip this item. */
7305 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7306 if (!(STRINGP (item_string
) || notreal
))
7308 item_string
= menu_item_eval_property (item_string
);
7309 if (!STRINGP (item_string
))
7311 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7314 /* If got a filter apply it on definition. */
7315 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7318 def
= menu_item_eval_property (list2 (XCAR (filter
),
7319 list2 (Qquote
, def
)));
7321 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7324 /* Enable or disable selection of item. */
7325 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7331 tem
= menu_item_eval_property (tem
);
7332 if (inmenubar
&& NILP (tem
))
7333 return 0; /* Ignore disabled items in menu bar. */
7334 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7337 /* If we got no definition, this item is just unselectable text which
7338 is OK in a submenu but not in the menubar. */
7340 return (inmenubar
? 0 : 1);
7342 /* See if this is a separate pane or a submenu. */
7343 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7344 tem
= get_keymap (def
, 0, 1);
7345 /* For a subkeymap, just record its details and exit. */
7348 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7349 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7353 /* At the top level in the menu bar, do likewise for commands also.
7354 The menu bar does not display equivalent key bindings anyway.
7355 ITEM_PROPERTY_DEF is already set up properly. */
7359 /* This is a command. See if there is an equivalent key binding. */
7360 if (NILP (cachelist
))
7362 /* We have to create a cachelist. */
7363 CHECK_IMPURE (start
);
7364 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
7365 cachelist
= XCAR (XCDR (start
));
7367 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7368 if (!NILP (keyhint
))
7370 XSETCAR (cachelist
, XCAR (keyhint
));
7373 else if (STRINGP (tem
))
7375 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
7376 XSETCAR (cachelist
, Qt
);
7380 tem
= XCAR (cachelist
);
7387 tem
= Fkey_binding (tem
, Qnil
, Qnil
);
7389 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7392 def
= XCAR (prefix
);
7393 prefix
= XCDR (prefix
);
7396 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7398 if (!update_menu_bindings
)
7400 else if (NILP (XCAR (cachelist
))) /* Have no saved key. */
7402 if (newcache
/* Always check first time. */
7403 /* Should we check everything when precomputing key
7405 /* If something had no key binding before, don't recheck it
7406 because that is too slow--except if we have a list of
7407 rebound commands in Vdefine_key_rebound_commands, do
7408 recheck any command that appears in that list. */
7409 || (CONSP (Vdefine_key_rebound_commands
)
7410 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
7413 /* We had a saved key. Is it still bound to the command? */
7416 /* If the command is an alias for another
7417 (such as lmenu.el set it up), check if the
7418 original command matches the cached command. */
7419 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7420 chkcache
= 1; /* Need to recompute key binding. */
7424 /* Recompute equivalent key binding. If the command is an alias
7425 for another (such as lmenu.el set it up), see if the original
7426 command name has equivalent keys. Otherwise look up the
7427 specified command itself. We don't try both, because that
7428 makes lmenu menus slow. */
7430 && SYMBOLP (XSYMBOL (def
)->function
)
7431 && ! NILP (Fget (def
, Qmenu_alias
)))
7432 def
= XSYMBOL (def
)->function
;
7433 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
7434 XSETCAR (cachelist
, tem
);
7437 XSETCDR (cachelist
, Qnil
);
7441 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
7443 tem
= XCAR (cachelist
);
7447 newcache
= chkcache
;
7450 tem
= Fkey_description (tem
);
7453 if (STRINGP (XCAR (prefix
)))
7454 tem
= concat2 (XCAR (prefix
), tem
);
7455 if (STRINGP (XCDR (prefix
)))
7456 tem
= concat2 (tem
, XCDR (prefix
));
7458 XSETCDR (cachelist
, tem
);
7462 tem
= XCDR (cachelist
);
7463 if (newcache
&& !NILP (tem
))
7465 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
7466 XSETCDR (cachelist
, tem
);
7469 /* If we only want to precompute equivalent key bindings, stop here. */
7473 /* If we have an equivalent key binding, use that. */
7474 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7476 /* Include this when menu help is implemented.
7477 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7478 if (!(NILP (tem) || STRINGP (tem)))
7480 tem = menu_item_eval_property (tem);
7483 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7487 /* Handle radio buttons or toggle boxes. */
7488 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7490 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7491 = menu_item_eval_property (tem
);
7498 /***********************************************************************
7500 ***********************************************************************/
7502 /* A vector holding tool bar items while they are parsed in function
7503 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7506 static Lisp_Object tool_bar_items_vector
;
7508 /* A vector holding the result of parse_tool_bar_item. Layout is like
7509 the one for a single item in tool_bar_items_vector. */
7511 static Lisp_Object tool_bar_item_properties
;
7513 /* Next free index in tool_bar_items_vector. */
7515 static int ntool_bar_items
;
7517 /* The symbols `tool-bar', and `:image'. */
7519 extern Lisp_Object Qtool_bar
;
7520 Lisp_Object QCimage
;
7522 /* Function prototypes. */
7524 static void init_tool_bar_items
P_ ((Lisp_Object
));
7525 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7526 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7527 static void append_tool_bar_item
P_ ((void));
7530 /* Return a vector of tool bar items for keymaps currently in effect.
7531 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7532 tool bar items found. */
7535 tool_bar_items (reuse
, nitems
)
7546 /* In order to build the menus, we need to call the keymap
7547 accessors. They all call QUIT. But this function is called
7548 during redisplay, during which a quit is fatal. So inhibit
7549 quitting while building the menus. We do this instead of
7550 specbind because (1) errors will clear it anyway and (2) this
7551 avoids risk of specpdl overflow. */
7552 oquit
= Vinhibit_quit
;
7555 /* Initialize tool_bar_items_vector and protect it from GC. */
7556 init_tool_bar_items (reuse
);
7558 /* Build list of keymaps in maps. Set nmaps to the number of maps
7561 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7562 if (!NILP (Voverriding_local_map_menu_flag
))
7564 /* Yes, use them (if non-nil) as well as the global map. */
7565 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7567 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7568 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7569 if (!NILP (Voverriding_local_map
))
7570 maps
[nmaps
++] = Voverriding_local_map
;
7574 /* No, so use major and minor mode keymaps and keymap property.
7575 Note that tool-bar bindings in the local-map and keymap
7576 properties may not work reliable, as they are only
7577 recognized when the tool-bar (or mode-line) is updated,
7578 which does not normally happen after every command. */
7581 nminor
= current_minor_maps (NULL
, &tmaps
);
7582 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7584 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7585 maps
[nmaps
++] = tem
;
7586 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7588 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7591 /* Add global keymap at the end. */
7592 maps
[nmaps
++] = current_global_map
;
7594 /* Process maps in reverse order and look up in each map the prefix
7596 for (i
= nmaps
- 1; i
>= 0; --i
)
7597 if (!NILP (maps
[i
]))
7601 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7606 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
7607 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
7609 Lisp_Object keydef
= XCAR (tail
);
7611 process_tool_bar_item (XCAR (keydef
), XCDR (keydef
));
7616 Vinhibit_quit
= oquit
;
7617 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7618 return tool_bar_items_vector
;
7622 /* Process the definition of KEY which is DEF. */
7625 process_tool_bar_item (key
, def
)
7626 Lisp_Object key
, def
;
7629 extern Lisp_Object Qundefined
;
7630 struct gcpro gcpro1
, gcpro2
;
7632 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7636 if (EQ (def
, Qundefined
))
7638 /* If a map has an explicit `undefined' as definition,
7639 discard any previously made item. */
7640 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
7642 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
7644 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
7646 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
7647 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
7648 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
7649 * sizeof (Lisp_Object
)));
7650 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
7655 else if (parse_tool_bar_item (key
, def
))
7656 /* Append a new tool bar item to tool_bar_items_vector. Accept
7657 more than one definition for the same key. */
7658 append_tool_bar_item ();
7664 /* Parse a tool bar item specification ITEM for key KEY and return the
7665 result in tool_bar_item_properties. Value is zero if ITEM is
7668 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7670 CAPTION is the caption of the item, If it's not a string, it is
7671 evaluated to get a string.
7673 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7674 as binding are currently ignored.
7676 The following properties are recognized:
7680 FORM is evaluated and specifies whether the tool bar item is
7681 enabled or disabled.
7685 FORM is evaluated and specifies whether the tool bar item is visible.
7687 - `:filter FUNCTION'
7689 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
7690 result is stored as the new binding.
7692 - `:button (TYPE SELECTED)'
7694 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
7695 and specifies whether the button is selected (pressed) or not.
7699 IMAGES is either a single image specification or a vector of four
7700 image specifications. See enum tool_bar_item_images.
7702 - `:help HELP-STRING'.
7704 Gives a help string to display for the tool bar item. */
7707 parse_tool_bar_item (key
, item
)
7708 Lisp_Object key
, item
;
7710 /* Access slot with index IDX of vector tool_bar_item_properties. */
7711 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
7713 Lisp_Object filter
= Qnil
;
7714 Lisp_Object caption
;
7717 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
7718 Rule out items that aren't lists, don't start with
7719 `menu-item' or whose rest following `tool-bar-item' is not a
7722 || !EQ (XCAR (item
), Qmenu_item
)
7723 || (item
= XCDR (item
),
7727 /* Create tool_bar_item_properties vector if necessary. Reset it to
7729 if (VECTORP (tool_bar_item_properties
))
7731 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
7735 tool_bar_item_properties
7736 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
7739 PROP (TOOL_BAR_ITEM_KEY
) = key
;
7740 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
7742 /* Get the caption of the item. If the caption is not a string,
7743 evaluate it to get a string. If we don't get a string, skip this
7745 caption
= XCAR (item
);
7746 if (!STRINGP (caption
))
7748 caption
= menu_item_eval_property (caption
);
7749 if (!STRINGP (caption
))
7752 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
7754 /* Give up if rest following the caption is not a list. */
7759 /* Store the binding. */
7760 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
7763 /* Ignore cached key binding, if any. */
7764 if (CONSP (item
) && CONSP (XCAR (item
)))
7767 /* Process the rest of the properties. */
7768 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
7770 Lisp_Object key
, value
;
7773 value
= XCAR (XCDR (item
));
7775 if (EQ (key
, QCenable
))
7776 /* `:enable FORM'. */
7777 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
7778 else if (EQ (key
, QCvisible
))
7780 /* `:visible FORM'. If got a visible property and that
7781 evaluates to nil then ignore this item. */
7782 if (NILP (menu_item_eval_property (value
)))
7785 else if (EQ (key
, QChelp
))
7786 /* `:help HELP-STRING'. */
7787 PROP (TOOL_BAR_ITEM_HELP
) = value
;
7788 else if (EQ (key
, QCfilter
))
7789 /* ':filter FORM'. */
7791 else if (EQ (key
, QCbutton
) && CONSP (value
))
7793 /* `:button (TYPE . SELECTED)'. */
7794 Lisp_Object type
, selected
;
7796 type
= XCAR (value
);
7797 selected
= XCDR (value
);
7798 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7800 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
7801 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
7804 else if (EQ (key
, QCimage
)
7806 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
7807 /* Value is either a single image specification or a vector
7808 of 4 such specifications for the different button states. */
7809 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
7812 /* If got a filter apply it on binding. */
7814 PROP (TOOL_BAR_ITEM_BINDING
)
7815 = menu_item_eval_property (list2 (filter
,
7817 PROP (TOOL_BAR_ITEM_BINDING
))));
7819 /* See if the binding is a keymap. Give up if it is. */
7820 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
7823 /* Enable or disable selection of item. */
7824 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
7825 PROP (TOOL_BAR_ITEM_ENABLED_P
)
7826 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7828 /* Handle radio buttons or toggle boxes. */
7829 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
7830 PROP (TOOL_BAR_ITEM_SELECTED_P
)
7831 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7839 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7840 that can be reused. */
7843 init_tool_bar_items (reuse
)
7846 if (VECTORP (reuse
))
7847 tool_bar_items_vector
= reuse
;
7849 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
7850 ntool_bar_items
= 0;
7854 /* Append parsed tool bar item properties from
7855 tool_bar_item_properties */
7858 append_tool_bar_item ()
7860 Lisp_Object
*to
, *from
;
7862 /* Enlarge tool_bar_items_vector if necessary. */
7863 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
7864 >= XVECTOR (tool_bar_items_vector
)->size
)
7866 Lisp_Object new_vector
;
7867 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
7869 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
7870 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
7871 XVECTOR (new_vector
)->contents
,
7872 old_size
* sizeof (Lisp_Object
));
7873 tool_bar_items_vector
= new_vector
;
7876 /* Append entries from tool_bar_item_properties to the end of
7877 tool_bar_items_vector. */
7878 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
7879 from
= XVECTOR (tool_bar_item_properties
)->contents
;
7880 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
7881 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
7888 /* Read a character using menus based on maps in the array MAPS.
7889 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7890 Return t if we displayed a menu but the user rejected it.
7892 PREV_EVENT is the previous input event, or nil if we are reading
7893 the first event of a key sequence.
7895 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7896 if we used a mouse menu to read the input, or zero otherwise. If
7897 USED_MOUSE_MENU is null, we don't dereference it.
7899 The prompting is done based on the prompt-string of the map
7900 and the strings associated with various map elements.
7902 This can be done with X menus or with menus put in the minibuf.
7903 These are done in different ways, depending on how the input will be read.
7904 Menus using X are done after auto-saving in read-char, getting the input
7905 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7906 and do auto-saving in the inner call of read_char. */
7909 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
7912 Lisp_Object prev_event
;
7913 int *used_mouse_menu
;
7916 register Lisp_Object name
= Qnil
;
7918 if (used_mouse_menu
)
7919 *used_mouse_menu
= 0;
7921 /* Use local over global Menu maps */
7923 if (! menu_prompting
)
7926 /* Optionally disregard all but the global map. */
7927 if (inhibit_local_menu_bar_menus
)
7929 maps
+= (nmaps
- 1);
7933 /* Get the menu name from the first map that has one (a prompt string). */
7934 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7936 name
= Fkeymap_prompt (maps
[mapno
]);
7941 /* If we don't have any menus, just read a character normally. */
7942 if (!STRINGP (name
))
7946 /* If we got to this point via a mouse click,
7947 use a real menu for mouse selection. */
7948 if (EVENT_HAS_PARAMETERS (prev_event
)
7949 && !EQ (XCAR (prev_event
), Qmenu_bar
)
7950 && !EQ (XCAR (prev_event
), Qtool_bar
))
7952 /* Display the menu and get the selection. */
7953 Lisp_Object
*realmaps
7954 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
7958 /* Use the maps that are not nil. */
7959 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7960 if (!NILP (maps
[mapno
]))
7961 realmaps
[nmaps1
++] = maps
[mapno
];
7963 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
7968 record_menu_key (XCAR (value
));
7970 /* If we got multiple events, unread all but
7972 There is no way to prevent those unread events
7973 from showing up later in last_nonmenu_event.
7974 So turn symbol and integer events into lists,
7975 to indicate that they came from a mouse menu,
7976 so that when present in last_nonmenu_event
7977 they won't confuse things. */
7978 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
7980 record_menu_key (XCAR (tem
));
7981 if (SYMBOLP (XCAR (tem
))
7982 || INTEGERP (XCAR (tem
)))
7983 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
7986 /* If we got more than one event, put all but the first
7987 onto this list to be read later.
7988 Return just the first event now. */
7989 Vunread_command_events
7990 = nconc2 (XCDR (value
), Vunread_command_events
);
7991 value
= XCAR (value
);
7993 else if (NILP (value
))
7995 if (used_mouse_menu
)
7996 *used_mouse_menu
= 1;
7999 #endif /* HAVE_MENUS */
8003 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8004 We make this bigger when necessary, and never free it. */
8005 static char *read_char_minibuf_menu_text
;
8006 /* Size of that buffer. */
8007 static int read_char_minibuf_menu_width
;
8010 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
8016 register Lisp_Object name
;
8018 /* FIXME: Use the minibuffer's frame width. */
8019 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8022 Lisp_Object rest
, vector
;
8028 if (! menu_prompting
)
8031 /* Make sure we have a big enough buffer for the menu text. */
8032 if (read_char_minibuf_menu_text
== 0)
8034 read_char_minibuf_menu_width
= width
+ 4;
8035 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8037 else if (width
+ 4 > read_char_minibuf_menu_width
)
8039 read_char_minibuf_menu_width
= width
+ 4;
8040 read_char_minibuf_menu_text
8041 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8043 menu
= read_char_minibuf_menu_text
;
8045 /* Get the menu name from the first map that has one (a prompt string). */
8046 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8048 name
= Fkeymap_prompt (maps
[mapno
]);
8053 /* If we don't have any menus, just read a character normally. */
8054 if (!STRINGP (name
))
8057 /* Prompt string always starts with map's prompt, and a space. */
8058 strcpy (menu
, SDATA (name
));
8059 nlength
= SBYTES (name
);
8060 menu
[nlength
++] = ':';
8061 menu
[nlength
++] = ' ';
8064 /* Start prompting at start of first map. */
8068 /* Present the documented bindings, a line at a time. */
8075 Lisp_Object orig_defn_macro
;
8077 /* Loop over elements of map. */
8082 /* If reached end of map, start at beginning of next map. */
8086 /* At end of last map, wrap around to first map if just starting,
8087 or end this line if already have something on it. */
8091 if (notfirst
|| nobindings
) break;
8096 /* Look at the next element of the map. */
8098 elt
= XVECTOR (vector
)->contents
[idx
];
8100 elt
= Fcar_safe (rest
);
8102 if (idx
< 0 && VECTORP (elt
))
8104 /* If we found a dense table in the keymap,
8105 advanced past it, but start scanning its contents. */
8106 rest
= Fcdr_safe (rest
);
8112 /* An ordinary element. */
8113 Lisp_Object event
, tem
;
8117 event
= Fcar_safe (elt
); /* alist */
8118 elt
= Fcdr_safe (elt
);
8122 XSETINT (event
, idx
); /* vector */
8125 /* Ignore the element if it has no prompt string. */
8126 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8128 /* 1 if the char to type matches the string. */
8130 Lisp_Object upcased_event
, downcased_event
;
8131 Lisp_Object desc
= Qnil
;
8133 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8135 upcased_event
= Fupcase (event
);
8136 downcased_event
= Fdowncase (event
);
8137 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8138 || XINT (downcased_event
) == SREF (s
, 0));
8140 desc
= Fsingle_key_description (event
, Qnil
);
8142 #if 0 /* It is redundant to list the equivalent key bindings because
8143 the prefix is what the user has already typed. */
8145 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8147 /* Insert equivalent keybinding. */
8148 s
= concat2 (s
, tem
);
8151 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8152 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8154 /* Insert button prefix. */
8155 Lisp_Object selected
8156 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8157 if (EQ (tem
, QCradio
))
8158 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8160 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8161 s
= concat2 (tem
, s
);
8165 /* If we have room for the prompt string, add it to this line.
8166 If this is the first on the line, always add it. */
8167 if ((SCHARS (s
) + i
+ 2
8168 + (char_matches
? 0 : SCHARS (desc
) + 3))
8174 /* Punctuate between strings. */
8177 strcpy (menu
+ i
, ", ");
8183 /* If the char to type doesn't match the string's
8184 first char, explicitly show what char to type. */
8187 /* Add as much of string as fits. */
8188 thiswidth
= SCHARS (desc
);
8189 if (thiswidth
+ i
> width
)
8190 thiswidth
= width
- i
;
8191 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8193 strcpy (menu
+ i
, " = ");
8197 /* Add as much of string as fits. */
8198 thiswidth
= SCHARS (s
);
8199 if (thiswidth
+ i
> width
)
8200 thiswidth
= width
- i
;
8201 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8207 /* If this element does not fit, end the line now,
8208 and save the element for the next line. */
8209 strcpy (menu
+ i
, "...");
8214 /* Move past this element. */
8215 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8216 /* Handle reaching end of dense table. */
8221 rest
= Fcdr_safe (rest
);
8225 /* Prompt with that and read response. */
8226 message2_nolog (menu
, strlen (menu
),
8227 ! NILP (current_buffer
->enable_multibyte_characters
));
8229 /* Make believe its not a keyboard macro in case the help char
8230 is pressed. Help characters are not recorded because menu prompting
8231 is not used on replay.
8233 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8234 current_kboard
->defining_kbd_macro
= Qnil
;
8236 obj
= read_char (commandflag
, 0, 0, Qt
, 0);
8237 while (BUFFERP (obj
));
8238 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8240 if (!INTEGERP (obj
))
8245 if (! EQ (obj
, menu_prompt_more_char
)
8246 && (!INTEGERP (menu_prompt_more_char
)
8247 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8249 if (!NILP (current_kboard
->defining_kbd_macro
))
8250 store_kbd_macro_char (obj
);
8253 /* Help char - go round again */
8257 /* Reading key sequences. */
8259 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8260 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8261 keymap, or nil otherwise. Return the index of the first keymap in
8262 which KEY has any binding, or NMAPS if no map has a binding.
8264 If KEY is a meta ASCII character, treat it like meta-prefix-char
8265 followed by the corresponding non-meta character. Keymaps in
8266 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8269 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8272 NEXT may be the same array as CURRENT. */
8275 follow_key (key
, nmaps
, current
, defs
, next
)
8277 Lisp_Object
*current
, *defs
, *next
;
8280 int i
, first_binding
;
8282 first_binding
= nmaps
;
8283 for (i
= nmaps
- 1; i
>= 0; i
--)
8285 if (! NILP (current
[i
]))
8287 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8288 if (! NILP (defs
[i
]))
8295 /* Given the set of bindings we've found, produce the next set of maps. */
8296 if (first_binding
< nmaps
)
8297 for (i
= 0; i
< nmaps
; i
++)
8298 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8300 return first_binding
;
8303 /* Structure used to keep track of partial application of key remapping
8304 such as Vfunction_key_map and Vkey_translation_map. */
8305 typedef struct keyremap
8307 Lisp_Object map
, parent
;
8311 /* Lookup KEY in MAP.
8312 MAP is a keymap mapping keys to key vectors or functions.
8313 If the mapping is a function and DO_FUNCTION is non-zero, then
8314 the function is called with PROMPT as parameter and its return
8315 value is used as the return value of this function (after checking
8316 that it is indeed a vector). */
8319 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8320 Lisp_Object map
, key
, prompt
;
8325 next
= access_keymap (map
, key
, 1, 0, 1);
8327 /* Handle symbol with autoload definition. */
8328 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8329 && CONSP (XSYMBOL (next
)->function
)
8330 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8331 do_autoload (XSYMBOL (next
)->function
, next
);
8333 /* Handle a symbol whose function definition is a keymap
8335 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8336 && (!NILP (Farrayp (XSYMBOL (next
)->function
))
8337 || KEYMAPP (XSYMBOL (next
)->function
)))
8338 next
= XSYMBOL (next
)->function
;
8340 /* If the keymap gives a function, not an
8341 array, then call the function with one arg and use
8342 its value instead. */
8343 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8348 next
= call1 (next
, prompt
);
8349 /* If the function returned something invalid,
8350 barf--don't ignore it.
8351 (To ignore it safely, we would need to gcpro a bunch of
8352 other variables.) */
8353 if (! (VECTORP (next
) || STRINGP (next
)))
8354 error ("Function %s returns invalid key sequence", tem
);
8359 /* Do one step of the key remapping used for function-key-map and
8360 key-translation-map:
8361 KEYBUF is the buffer holding the input events.
8362 BUFSIZE is its maximum size.
8363 FKEY is a pointer to the keyremap structure to use.
8364 INPUT is the index of the last element in KEYBUF.
8365 DOIT if non-zero says that the remapping can actually take place.
8366 DIFF is used to return the number of keys added/removed by the remapping.
8367 PARENT is the root of the keymap.
8368 PROMPT is the prompt to use if the remapping happens through a function.
8369 The return value is non-zero if the remapping actually took place. */
8372 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
8373 Lisp_Object
*keybuf
, prompt
;
8375 int input
, doit
, *diff
, bufsize
;
8377 Lisp_Object next
, key
;
8379 key
= keybuf
[fkey
->end
++];
8380 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8382 /* If keybuf[fkey->start..fkey->end] is bound in the
8383 map and we're in a position to do the key remapping, replace it with
8384 the binding and restart with fkey->start at the end. */
8385 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8387 int len
= XFASTINT (Flength (next
));
8390 *diff
= len
- (fkey
->end
- fkey
->start
);
8392 if (input
+ *diff
>= bufsize
)
8393 error ("Key sequence too long");
8395 /* Shift the keys that follow fkey->end. */
8397 for (i
= fkey
->end
; i
< input
; i
++)
8398 keybuf
[i
+ *diff
] = keybuf
[i
];
8400 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8401 keybuf
[i
+ *diff
] = keybuf
[i
];
8402 /* Overwrite the old keys with the new ones. */
8403 for (i
= 0; i
< len
; i
++)
8404 keybuf
[fkey
->start
+ i
]
8405 = Faref (next
, make_number (i
));
8407 fkey
->start
= fkey
->end
+= *diff
;
8408 fkey
->map
= fkey
->parent
;
8413 fkey
->map
= get_keymap (next
, 0, 1);
8415 /* If we no longer have a bound suffix, try a new position for
8417 if (!CONSP (fkey
->map
))
8419 fkey
->end
= ++fkey
->start
;
8420 fkey
->map
= fkey
->parent
;
8425 /* Read a sequence of keys that ends with a non prefix character,
8426 storing it in KEYBUF, a buffer of size BUFSIZE.
8428 Return the length of the key sequence stored.
8429 Return -1 if the user rejected a command menu.
8431 Echo starting immediately unless `prompt' is 0.
8433 Where a key sequence ends depends on the currently active keymaps.
8434 These include any minor mode keymaps active in the current buffer,
8435 the current buffer's local map, and the global map.
8437 If a key sequence has no other bindings, we check Vfunction_key_map
8438 to see if some trailing subsequence might be the beginning of a
8439 function key's sequence. If so, we try to read the whole function
8440 key, and substitute its symbolic name into the key sequence.
8442 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8443 `double-' events into similar click events, if that would make them
8444 bound. We try to turn `triple-' events first into `double-' events,
8447 If we get a mouse click in a mode line, vertical divider, or other
8448 non-text area, we treat the click as if it were prefixed by the
8449 symbol denoting that area - `mode-line', `vertical-line', or
8452 If the sequence starts with a mouse click, we read the key sequence
8453 with respect to the buffer clicked on, not the current buffer.
8455 If the user switches frames in the midst of a key sequence, we put
8456 off the switch-frame event until later; the next call to
8457 read_char will return it.
8459 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8460 from the selected window's buffer. */
8463 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
8464 can_return_switch_frame
, fix_current_buffer
)
8465 Lisp_Object
*keybuf
;
8468 int dont_downcase_last
;
8469 int can_return_switch_frame
;
8470 int fix_current_buffer
;
8472 volatile Lisp_Object from_string
;
8473 volatile int count
= SPECPDL_INDEX ();
8475 /* How many keys there are in the current key sequence. */
8478 /* The length of the echo buffer when we started reading, and
8479 the length of this_command_keys when we started reading. */
8480 volatile int echo_start
;
8481 volatile int keys_start
;
8483 /* The number of keymaps we're scanning right now, and the number of
8484 keymaps we have allocated space for. */
8486 volatile int nmaps_allocated
= 0;
8488 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8489 the current keymaps. */
8490 Lisp_Object
*volatile defs
= NULL
;
8492 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8493 in the current keymaps, or nil where it is not a prefix. */
8494 Lisp_Object
*volatile submaps
= NULL
;
8496 /* The local map to start out with at start of key sequence. */
8497 volatile Lisp_Object orig_local_map
;
8499 /* The map from the `keymap' property to start out with at start of
8501 volatile Lisp_Object orig_keymap
;
8503 /* 1 if we have already considered switching to the local-map property
8504 of the place where a mouse click occurred. */
8505 volatile int localized_local_map
= 0;
8507 /* The index in defs[] of the first keymap that has a binding for
8508 this key sequence. In other words, the lowest i such that
8509 defs[i] is non-nil. */
8510 volatile int first_binding
;
8511 /* Index of the first key that has no binding.
8512 It is useless to try fkey.start larger than that. */
8513 volatile int first_unbound
;
8515 /* If t < mock_input, then KEYBUF[t] should be read as the next
8518 We use this to recover after recognizing a function key. Once we
8519 realize that a suffix of the current key sequence is actually a
8520 function key's escape sequence, we replace the suffix with the
8521 function key's binding from Vfunction_key_map. Now keybuf
8522 contains a new and different key sequence, so the echo area,
8523 this_command_keys, and the submaps and defs arrays are wrong. In
8524 this situation, we set mock_input to t, set t to 0, and jump to
8525 restart_sequence; the loop will read keys from keybuf up until
8526 mock_input, thus rebuilding the state; and then it will resume
8527 reading characters from the keyboard. */
8528 volatile int mock_input
= 0;
8530 /* If the sequence is unbound in submaps[], then
8531 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8532 and fkey.map is its binding.
8534 These might be > t, indicating that all function key scanning
8535 should hold off until t reaches them. We do this when we've just
8536 recognized a function key, to avoid searching for the function
8537 key's again in Vfunction_key_map. */
8538 volatile keyremap fkey
;
8540 /* Likewise, for key_translation_map. */
8541 volatile keyremap keytran
;
8543 /* If we receive a `switch-frame' or `select-window' event in the middle of
8544 a key sequence, we put it off for later.
8545 While we're reading, we keep the event here. */
8546 volatile Lisp_Object delayed_switch_frame
;
8548 /* See the comment below... */
8549 #if defined (GOBBLE_FIRST_EVENT)
8550 Lisp_Object first_event
;
8553 volatile Lisp_Object original_uppercase
;
8554 volatile int original_uppercase_position
= -1;
8556 /* Gets around Microsoft compiler limitations. */
8559 struct buffer
*starting_buffer
;
8561 /* List of events for which a fake prefix key has been generated. */
8562 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
8564 #if defined (GOBBLE_FIRST_EVENT)
8568 struct gcpro gcpro1
;
8570 GCPRO1 (fake_prefixed_keys
);
8571 raw_keybuf_count
= 0;
8573 last_nonmenu_event
= Qnil
;
8575 delayed_switch_frame
= Qnil
;
8576 fkey
.map
= fkey
.parent
= Vfunction_key_map
;
8577 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
8578 /* If there is no translation-map, turn off scanning. */
8579 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
8580 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
8585 echo_prompt (prompt
);
8586 else if (cursor_in_echo_area
8587 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8588 && NILP (Fzerop (Vecho_keystrokes
)))
8589 /* This doesn't put in a dash if the echo buffer is empty, so
8590 you don't always see a dash hanging out in the minibuffer. */
8594 /* Record the initial state of the echo area and this_command_keys;
8595 we will need to restore them if we replay a key sequence. */
8597 echo_start
= echo_length ();
8598 keys_start
= this_command_key_count
;
8599 this_single_command_key_start
= keys_start
;
8601 #if defined (GOBBLE_FIRST_EVENT)
8602 /* This doesn't quite work, because some of the things that read_char
8603 does cannot safely be bypassed. It seems too risky to try to make
8606 /* Read the first char of the sequence specially, before setting
8607 up any keymaps, in case a filter runs and switches buffers on us. */
8608 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
8610 #endif /* GOBBLE_FIRST_EVENT */
8612 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8613 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8616 /* We jump here when the key sequence has been thoroughly changed, and
8617 we need to rescan it starting from the beginning. When we jump here,
8618 keybuf[0..mock_input] holds the sequence we should reread. */
8621 starting_buffer
= current_buffer
;
8622 first_unbound
= bufsize
+ 1;
8624 /* Build our list of keymaps.
8625 If we recognize a function key and replace its escape sequence in
8626 keybuf with its symbol, or if the sequence starts with a mouse
8627 click and we need to switch buffers, we jump back here to rebuild
8628 the initial keymaps from the current buffer. */
8631 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
8632 || !NILP (Voverriding_local_map
))
8634 if (3 > nmaps_allocated
)
8636 submaps
= (Lisp_Object
*) alloca (3 * sizeof (submaps
[0]));
8637 defs
= (Lisp_Object
*) alloca (3 * sizeof (defs
[0]));
8638 nmaps_allocated
= 3;
8640 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8641 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8642 if (!NILP (Voverriding_local_map
))
8643 submaps
[nmaps
++] = Voverriding_local_map
;
8651 nminor
= current_minor_maps (0, &maps
);
8652 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
8654 if (total
> nmaps_allocated
)
8656 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
8657 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
8658 nmaps_allocated
= total
;
8661 if (!NILP (orig_keymap
))
8662 submaps
[nmaps
++] = orig_keymap
;
8664 bcopy (maps
, (void *) (submaps
+ nmaps
),
8665 nminor
* sizeof (submaps
[0]));
8669 submaps
[nmaps
++] = orig_local_map
;
8671 submaps
[nmaps
++] = current_global_map
;
8673 /* Find an accurate initial value for first_binding. */
8674 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
8675 if (! NILP (submaps
[first_binding
]))
8678 /* Start from the beginning in keybuf. */
8681 /* These are no-ops the first time through, but if we restart, they
8682 revert the echo area and this_command_keys to their original state. */
8683 this_command_key_count
= keys_start
;
8684 if (INTERACTIVE
&& t
< mock_input
)
8685 echo_truncate (echo_start
);
8687 /* If the best binding for the current key sequence is a keymap, or
8688 we may be looking at a function key's escape sequence, keep on
8690 while (first_binding
< nmaps
8691 /* Keep reading as long as there's a prefix binding. */
8692 ? !NILP (submaps
[first_binding
])
8693 /* Don't return in the middle of a possible function key sequence,
8694 if the only bindings we found were via case conversion.
8695 Thus, if ESC O a has a function-key-map translation
8696 and ESC o has a binding, don't return after ESC O,
8697 so that we can translate ESC O plus the next character. */
8698 : (fkey
.start
< t
|| keytran
.start
< t
))
8701 int used_mouse_menu
= 0;
8703 /* Where the last real key started. If we need to throw away a
8704 key that has expanded into more than one element of keybuf
8705 (say, a mouse click on the mode line which is being treated
8706 as [mode-line (mouse-...)], then we backtrack to this point
8708 volatile int last_real_key_start
;
8710 /* These variables are analogous to echo_start and keys_start;
8711 while those allow us to restart the entire key sequence,
8712 echo_local_start and keys_local_start allow us to throw away
8714 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
8716 eassert (fkey
.end
== t
|| (fkey
.end
> t
&& fkey
.end
<= mock_input
));
8717 eassert (fkey
.start
<= fkey
.end
);
8718 eassert (keytran
.start
<= keytran
.end
);
8719 /* key-translation-map is applied *after* function-key-map. */
8720 eassert (keytran
.end
<= fkey
.start
);
8722 if (first_unbound
< fkey
.start
&& first_unbound
< keytran
.start
)
8723 { /* The prefix upto first_unbound has no binding and has
8724 no translation left to do either, so we know it's unbound.
8725 If we don't stop now, we risk staying here indefinitely
8726 (if the user keeps entering fkey or keytran prefixes
8727 like C-c ESC ESC ESC ESC ...) */
8729 for (i
= first_unbound
+ 1; i
< t
; i
++)
8730 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
8731 mock_input
= t
- first_unbound
- 1;
8732 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
8733 fkey
.map
= fkey
.parent
;
8734 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
8735 keytran
.map
= keytran
.parent
;
8736 goto replay_sequence
;
8740 error ("Key sequence too long");
8743 echo_local_start
= echo_length ();
8744 keys_local_start
= this_command_key_count
;
8745 local_first_binding
= first_binding
;
8748 /* These are no-ops, unless we throw away a keystroke below and
8749 jumped back up to replay_key; in that case, these restore the
8750 variables to their original state, allowing us to replay the
8752 if (INTERACTIVE
&& t
< mock_input
)
8753 echo_truncate (echo_local_start
);
8754 this_command_key_count
= keys_local_start
;
8755 first_binding
= local_first_binding
;
8757 /* By default, assume each event is "real". */
8758 last_real_key_start
= t
;
8760 /* Does mock_input indicate that we are re-reading a key sequence? */
8764 add_command_key (key
);
8765 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8766 && NILP (Fzerop (Vecho_keystrokes
)))
8770 /* If not, we should actually read a character. */
8775 KBOARD
*interrupted_kboard
= current_kboard
;
8776 struct frame
*interrupted_frame
= SELECTED_FRAME ();
8777 if (setjmp (wrong_kboard_jmpbuf
))
8779 if (!NILP (delayed_switch_frame
))
8781 interrupted_kboard
->kbd_queue
8782 = Fcons (delayed_switch_frame
,
8783 interrupted_kboard
->kbd_queue
);
8784 delayed_switch_frame
= Qnil
;
8787 interrupted_kboard
->kbd_queue
8788 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
8790 /* If the side queue is non-empty, ensure it begins with a
8791 switch-frame, so we'll replay it in the right context. */
8792 if (CONSP (interrupted_kboard
->kbd_queue
)
8793 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
8794 !(EVENT_HAS_PARAMETERS (key
)
8795 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
8799 XSETFRAME (frame
, interrupted_frame
);
8800 interrupted_kboard
->kbd_queue
8801 = Fcons (make_lispy_switch_frame (frame
),
8802 interrupted_kboard
->kbd_queue
);
8805 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8806 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8807 goto replay_sequence
;
8810 key
= read_char (NILP (prompt
), nmaps
,
8811 (Lisp_Object
*) submaps
, last_nonmenu_event
,
8815 /* read_char returns t when it shows a menu and the user rejects it.
8819 unbind_to (count
, Qnil
);
8824 /* read_char returns -1 at the end of a macro.
8825 Emacs 18 handles this by returning immediately with a
8826 zero, so that's what we'll do. */
8827 if (INTEGERP (key
) && XINT (key
) == -1)
8830 /* The Microsoft C compiler can't handle the goto that
8836 /* If the current buffer has been changed from under us, the
8837 keymap may have changed, so replay the sequence. */
8840 EMACS_TIME initial_idleness_start_time
;
8841 EMACS_SET_SECS_USECS (initial_idleness_start_time
,
8842 EMACS_SECS (timer_last_idleness_start_time
),
8843 EMACS_USECS (timer_last_idleness_start_time
));
8845 /* Resume idle state, using the same start-time as before. */
8846 timer_start_idle ();
8847 timer_idleness_start_time
= initial_idleness_start_time
;
8850 /* Reset the current buffer from the selected window
8851 in case something changed the former and not the latter.
8852 This is to be more consistent with the behavior
8853 of the command_loop_1. */
8854 if (fix_current_buffer
)
8856 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8858 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
8859 Fset_buffer (XWINDOW (selected_window
)->buffer
);
8862 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8863 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8864 goto replay_sequence
;
8867 /* If we have a quit that was typed in another frame, and
8868 quit_throw_to_read_char switched buffers,
8869 replay to get the right keymap. */
8871 && XINT (key
) == quit_char
8872 && current_buffer
!= starting_buffer
)
8875 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8879 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8880 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8881 goto replay_sequence
;
8886 if (EVENT_HAS_PARAMETERS (key
)
8887 /* Either a `switch-frame' or a `select-window' event. */
8888 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
8890 /* If we're at the beginning of a key sequence, and the caller
8891 says it's okay, go ahead and return this event. If we're
8892 in the midst of a key sequence, delay it until the end. */
8893 if (t
> 0 || !can_return_switch_frame
)
8895 delayed_switch_frame
= key
;
8901 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8904 /* Clicks in non-text areas get prefixed by the symbol
8905 in their CHAR-ADDRESS field. For example, a click on
8906 the mode line is prefixed by the symbol `mode-line'.
8908 Furthermore, key sequences beginning with mouse clicks
8909 are read using the keymaps of the buffer clicked on, not
8910 the current buffer. So we may have to switch the buffer
8913 When we turn one event into two events, we must make sure
8914 that neither of the two looks like the original--so that,
8915 if we replay the events, they won't be expanded again.
8916 If not for this, such reexpansion could happen either here
8917 or when user programs play with this-command-keys. */
8918 if (EVENT_HAS_PARAMETERS (key
))
8923 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
8924 if (EQ (kind
, Qmouse_click
))
8926 Lisp_Object window
, posn
;
8928 window
= POSN_WINDOW (EVENT_START (key
));
8929 posn
= POSN_POSN (EVENT_START (key
));
8932 || (!NILP (fake_prefixed_keys
)
8933 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
8935 /* We're looking a second time at an event for which
8936 we generated a fake prefix key. Set
8937 last_real_key_start appropriately. */
8939 last_real_key_start
= t
- 1;
8942 /* Key sequences beginning with mouse clicks are
8943 read using the keymaps in the buffer clicked on,
8944 not the current buffer. If we're at the
8945 beginning of a key sequence, switch buffers. */
8946 if (last_real_key_start
== 0
8948 && BUFFERP (XWINDOW (window
)->buffer
)
8949 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
8951 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8955 /* Arrange to go back to the original buffer once we're
8956 done reading the key sequence. Note that we can't
8957 use save_excursion_{save,restore} here, because they
8958 save point as well as the current buffer; we don't
8959 want to save point, because redisplay may change it,
8960 to accommodate a Fset_window_start or something. We
8961 don't want to do this at the top of the function,
8962 because we may get input from a subprocess which
8963 wants to change the selected window and stuff (say,
8965 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
8967 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8969 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
8970 orig_local_map
= get_local_map (PT
, current_buffer
,
8972 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8973 goto replay_sequence
;
8976 /* For a mouse click, get the local text-property keymap
8977 of the place clicked on, rather than point. */
8978 if (last_real_key_start
== 0
8979 && CONSP (XCDR (key
))
8980 && ! localized_local_map
)
8982 Lisp_Object map_here
, start
, pos
;
8984 localized_local_map
= 1;
8985 start
= EVENT_START (key
);
8987 if (CONSP (start
) && POSN_INBUFFER_P (start
))
8989 pos
= POSN_BUFFER_POSN (start
);
8991 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
8993 map_here
= get_local_map (XINT (pos
),
8994 current_buffer
, Qlocal_map
);
8995 if (!EQ (map_here
, orig_local_map
))
8997 orig_local_map
= map_here
;
9001 goto replay_sequence
;
9003 map_here
= get_local_map (XINT (pos
),
9004 current_buffer
, Qkeymap
);
9005 if (!EQ (map_here
, orig_keymap
))
9007 orig_keymap
= map_here
;
9011 goto replay_sequence
;
9017 /* Expand mode-line and scroll-bar events into two events:
9018 use posn as a fake prefix key. */
9020 && (NILP (fake_prefixed_keys
)
9021 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9023 if (t
+ 1 >= bufsize
)
9024 error ("Key sequence too long");
9027 keybuf
[t
+ 1] = key
;
9030 /* Record that a fake prefix key has been generated
9031 for KEY. Don't modify the event; this would
9032 prevent proper action when the event is pushed
9033 back into unread-command-events. */
9034 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9036 /* If on a mode line string with a local keymap,
9037 reconsider the key sequence with that keymap. */
9038 if (string
= POSN_STRING (EVENT_START (key
)),
9039 (CONSP (string
) && STRINGP (XCAR (string
))))
9041 Lisp_Object pos
, map
, map2
;
9043 pos
= XCDR (string
);
9044 string
= XCAR (string
);
9046 && XINT (pos
) < SCHARS (string
))
9048 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9050 orig_local_map
= map
;
9051 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9054 if (!NILP (map
) || !NILP (map2
))
9055 goto replay_sequence
;
9061 else if (NILP (from_string
)
9062 && (string
= POSN_STRING (EVENT_START (key
)),
9063 (CONSP (string
) && STRINGP (XCAR (string
)))))
9065 /* For a click on a string, i.e. overlay string or a
9066 string displayed via the `display' property,
9067 consider `local-map' and `keymap' properties of
9069 Lisp_Object pos
, map
, map2
;
9071 pos
= XCDR (string
);
9072 string
= XCAR (string
);
9074 && XINT (pos
) < SCHARS (string
))
9076 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9078 orig_local_map
= map
;
9079 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9083 if (!NILP (map
) || !NILP (map2
))
9085 from_string
= string
;
9086 goto replay_sequence
;
9091 else if (CONSP (XCDR (key
))
9092 && CONSP (EVENT_START (key
))
9093 && CONSP (XCDR (EVENT_START (key
))))
9097 posn
= POSN_POSN (EVENT_START (key
));
9098 /* Handle menu-bar events:
9099 insert the dummy prefix event `menu-bar'. */
9100 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9102 if (t
+ 1 >= bufsize
)
9103 error ("Key sequence too long");
9107 /* Zap the position in key, so we know that we've
9108 expanded it, and don't try to do so again. */
9109 POSN_SET_POSN (EVENT_START (key
),
9110 Fcons (posn
, Qnil
));
9113 goto replay_sequence
;
9115 else if (CONSP (posn
))
9117 /* We're looking at the second event of a
9118 sequence which we expanded before. Set
9119 last_real_key_start appropriately. */
9120 if (last_real_key_start
== t
&& t
> 0)
9121 last_real_key_start
= t
- 1;
9126 /* We have finally decided that KEY is something we might want
9128 first_binding
= (follow_key (key
,
9129 nmaps
- first_binding
,
9130 submaps
+ first_binding
,
9131 defs
+ first_binding
,
9132 submaps
+ first_binding
)
9135 /* If KEY wasn't bound, we'll try some fallbacks. */
9136 if (first_binding
< nmaps
)
9137 /* This is needed for the following scenario:
9138 event 0: a down-event that gets dropped by calling replay_key.
9139 event 1: some normal prefix like C-h.
9140 After event 0, first_unbound is 0, after event 1 fkey.start
9141 and keytran.start are both 1, so when we see that C-h is bound,
9142 we need to update first_unbound. */
9143 first_unbound
= max (t
+ 1, first_unbound
);
9148 /* Remember the position to put an upper bound on fkey.start. */
9149 first_unbound
= min (t
, first_unbound
);
9151 head
= EVENT_HEAD (key
);
9152 if (help_char_p (head
) && t
> 0)
9154 read_key_sequence_cmd
= Vprefix_help_command
;
9156 last_nonmenu_event
= key
;
9157 /* The Microsoft C compiler can't handle the goto that
9165 Lisp_Object breakdown
;
9168 breakdown
= parse_modifiers (head
);
9169 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9170 /* Attempt to reduce an unbound mouse event to a simpler
9171 event that is bound:
9172 Drags reduce to clicks.
9173 Double-clicks reduce to clicks.
9174 Triple-clicks reduce to double-clicks, then to clicks.
9175 Down-clicks are eliminated.
9176 Double-downs reduce to downs, then are eliminated.
9177 Triple-downs reduce to double-downs, then to downs,
9178 then are eliminated. */
9179 if (modifiers
& (down_modifier
| drag_modifier
9180 | double_modifier
| triple_modifier
))
9182 while (modifiers
& (down_modifier
| drag_modifier
9183 | double_modifier
| triple_modifier
))
9185 Lisp_Object new_head
, new_click
;
9186 if (modifiers
& triple_modifier
)
9187 modifiers
^= (double_modifier
| triple_modifier
);
9188 else if (modifiers
& double_modifier
)
9189 modifiers
&= ~double_modifier
;
9190 else if (modifiers
& drag_modifier
)
9191 modifiers
&= ~drag_modifier
;
9194 /* Dispose of this `down' event by simply jumping
9195 back to replay_key, to get another event.
9197 Note that if this event came from mock input,
9198 then just jumping back to replay_key will just
9199 hand it to us again. So we have to wipe out any
9202 We could delete keybuf[t] and shift everything
9203 after that to the left by one spot, but we'd also
9204 have to fix up any variable that points into
9205 keybuf, and shifting isn't really necessary
9208 Adding prefixes for non-textual mouse clicks
9209 creates two characters of mock input, and both
9210 must be thrown away. If we're only looking at
9211 the prefix now, we can just jump back to
9212 replay_key. On the other hand, if we've already
9213 processed the prefix, and now the actual click
9214 itself is giving us trouble, then we've lost the
9215 state of the keymaps we want to backtrack to, and
9216 we need to replay the whole sequence to rebuild
9219 Beyond that, only function key expansion could
9220 create more than two keys, but that should never
9221 generate mouse events, so it's okay to zero
9222 mock_input in that case too.
9224 FIXME: The above paragraph seems just plain
9225 wrong, if you consider things like
9226 xterm-mouse-mode. -stef
9228 Isn't this just the most wonderful code ever? */
9230 /* If mock_input > t + 1, the above simplification
9231 will actually end up dropping keys on the floor.
9232 This is probably OK for now, but even
9233 if mock_input <= t + 1, we need to adjust fkey
9235 Typical case [header-line down-mouse-N]:
9236 mock_input = 2, t = 1, fkey.end = 1,
9237 last_real_key_start = 0. */
9238 if (fkey
.end
> last_real_key_start
)
9240 fkey
.end
= fkey
.start
9241 = min (last_real_key_start
, fkey
.start
);
9242 fkey
.map
= fkey
.parent
;
9243 if (keytran
.end
> last_real_key_start
)
9245 keytran
.end
= keytran
.start
9246 = min (last_real_key_start
, keytran
.start
);
9247 keytran
.map
= keytran
.parent
;
9250 if (t
== last_real_key_start
)
9257 mock_input
= last_real_key_start
;
9258 goto replay_sequence
;
9263 = apply_modifiers (modifiers
, XCAR (breakdown
));
9265 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9267 /* Look for a binding for this new key. follow_key
9268 promises that it didn't munge submaps the
9269 last time we called it, since key was unbound. */
9271 = (follow_key (new_click
,
9272 nmaps
- local_first_binding
,
9273 submaps
+ local_first_binding
,
9274 defs
+ local_first_binding
,
9275 submaps
+ local_first_binding
)
9276 + local_first_binding
);
9278 /* If that click is bound, go for it. */
9279 if (first_binding
< nmaps
)
9284 /* Otherwise, we'll leave key set to the drag event. */
9291 /* Normally, last_nonmenu_event gets the previous key we read.
9292 But when a mouse popup menu is being used,
9293 we don't update last_nonmenu_event; it continues to hold the mouse
9294 event that preceded the first level of menu. */
9295 if (!used_mouse_menu
)
9296 last_nonmenu_event
= key
;
9298 /* Record what part of this_command_keys is the current key sequence. */
9299 this_single_command_key_start
= this_command_key_count
- t
;
9301 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
]))
9302 /* There is a binding and it's not a prefix.
9303 There is thus no function-key in this sequence.
9304 Moving fkey.start is important in this case to allow keytran.start
9305 to go over the sequence before we return (since we keep the
9306 invariant that keytran.end <= fkey.start). */
9309 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9312 /* If the sequence is unbound, see if we can hang a function key
9313 off the end of it. */
9314 /* Continue scan from fkey.end until we find a bound suffix. */
9315 while (fkey
.end
< t
)
9317 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9320 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9321 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9322 max (t
, mock_input
),
9323 /* If there's a binding (i.e.
9324 first_binding >= nmaps) we don't want
9325 to apply this function-key-mapping. */
9326 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9331 mock_input
= diff
+ max (t
, mock_input
);
9332 goto replay_sequence
;
9336 /* Look for this sequence in key-translation-map.
9337 Scan from keytran.end until we find a bound suffix. */
9338 while (keytran
.end
< fkey
.start
)
9340 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9343 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9344 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9349 mock_input
= diff
+ max (t
, mock_input
);
9350 /* Adjust the function-key-map counters. */
9354 goto replay_sequence
;
9358 /* If KEY is not defined in any of the keymaps,
9359 and cannot be part of a function key or translation,
9360 and is an upper case letter
9361 use the corresponding lower-case letter instead. */
9362 if (first_binding
>= nmaps
9363 && fkey
.start
>= t
&& keytran
.start
>= t
9365 && ((((XINT (key
) & 0x3ffff)
9366 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
9367 && UPPERCASEP (XINT (key
) & 0x3ffff))
9368 || (XINT (key
) & shift_modifier
)))
9370 Lisp_Object new_key
;
9372 original_uppercase
= key
;
9373 original_uppercase_position
= t
- 1;
9375 if (XINT (key
) & shift_modifier
)
9376 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9378 XSETINT (new_key
, (DOWNCASE (XINT (key
) & 0x3ffff)
9379 | (XINT (key
) & ~0x3ffff)));
9381 /* We have to do this unconditionally, regardless of whether
9382 the lower-case char is defined in the keymaps, because they
9383 might get translated through function-key-map. */
9384 keybuf
[t
- 1] = new_key
;
9385 mock_input
= max (t
, mock_input
);
9387 goto replay_sequence
;
9389 /* If KEY is not defined in any of the keymaps,
9390 and cannot be part of a function key or translation,
9391 and is a shifted function key,
9392 use the corresponding unshifted function key instead. */
9393 if (first_binding
>= nmaps
9394 && fkey
.start
>= t
&& keytran
.start
>= t
9397 Lisp_Object breakdown
;
9400 breakdown
= parse_modifiers (key
);
9401 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9402 if (modifiers
& shift_modifier
)
9404 Lisp_Object new_key
;
9406 original_uppercase
= key
;
9407 original_uppercase_position
= t
- 1;
9409 modifiers
&= ~shift_modifier
;
9410 new_key
= apply_modifiers (modifiers
,
9413 keybuf
[t
- 1] = new_key
;
9414 mock_input
= max (t
, mock_input
);
9415 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
9416 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
9418 goto replay_sequence
;
9424 read_key_sequence_cmd
= (first_binding
< nmaps
9425 ? defs
[first_binding
]
9428 unread_switch_frame
= delayed_switch_frame
;
9429 unbind_to (count
, Qnil
);
9431 /* Don't downcase the last character if the caller says don't.
9432 Don't downcase it if the result is undefined, either. */
9433 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9434 && t
- 1 == original_uppercase_position
)
9435 keybuf
[t
- 1] = original_uppercase
;
9437 /* Occasionally we fabricate events, perhaps by expanding something
9438 according to function-key-map, or by adding a prefix symbol to a
9439 mouse click in the scroll bar or modeline. In this cases, return
9440 the entire generated key sequence, even if we hit an unbound
9441 prefix or a definition before the end. This means that you will
9442 be able to push back the event properly, and also means that
9443 read-key-sequence will always return a logical unit.
9446 for (; t
< mock_input
; t
++)
9448 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9449 && NILP (Fzerop (Vecho_keystrokes
)))
9450 echo_char (keybuf
[t
]);
9451 add_command_key (keybuf
[t
]);
9460 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9461 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9462 The sequence is sufficient to specify a non-prefix command in the
9463 current local and global maps.
9465 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9466 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9467 as a continuation of the previous key.
9469 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9470 convert the last event to lower case. (Normally any upper case event
9471 is converted to lower case if the original event is undefined and the lower
9472 case equivalent is defined.) A non-nil value is appropriate for reading
9473 a key sequence to be defined.
9475 A C-g typed while in this function is treated like any other character,
9476 and `quit-flag' is not set.
9478 If the key sequence starts with a mouse click, then the sequence is read
9479 using the keymaps of the buffer of the window clicked in, not the buffer
9480 of the selected window as normal.
9482 `read-key-sequence' drops unbound button-down events, since you normally
9483 only care about the click or drag events which follow them. If a drag
9484 or multi-click event is unbound, but the corresponding click event would
9485 be bound, `read-key-sequence' turns the event into a click event at the
9486 drag's starting position. This means that you don't have to distinguish
9487 between click and drag, double, or triple events unless you want to.
9489 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9490 lines separating windows, and scroll bars with imaginary keys
9491 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9493 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9494 function will process a switch-frame event if the user switches frames
9495 before typing anything. If the user switches frames in the middle of a
9496 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9497 is nil, then the event will be put off until after the current key sequence.
9499 `read-key-sequence' checks `function-key-map' for function key
9500 sequences, where they wouldn't conflict with ordinary bindings. See
9501 `function-key-map' for more details.
9503 The optional fifth argument COMMAND-LOOP, if non-nil, means
9504 that this key sequence is being read by something that will
9505 read commands one after another. It should be nil if the caller
9506 will read just one key sequence. */)
9507 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9509 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9510 Lisp_Object can_return_switch_frame
, command_loop
;
9512 Lisp_Object keybuf
[30];
9514 struct gcpro gcpro1
;
9515 int count
= SPECPDL_INDEX ();
9518 CHECK_STRING (prompt
);
9521 specbind (Qinput_method_exit_on_first_char
,
9522 (NILP (command_loop
) ? Qt
: Qnil
));
9523 specbind (Qinput_method_use_echo_area
,
9524 (NILP (command_loop
) ? Qt
: Qnil
));
9526 bzero (keybuf
, sizeof keybuf
);
9528 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9530 if (NILP (continue_echo
))
9532 this_command_key_count
= 0;
9533 this_command_key_count_reset
= 0;
9534 this_single_command_key_start
= 0;
9537 #ifdef HAVE_X_WINDOWS
9538 if (display_hourglass_p
)
9539 cancel_hourglass ();
9542 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9543 prompt
, ! NILP (dont_downcase_last
),
9544 ! NILP (can_return_switch_frame
), 0);
9546 #if 0 /* The following is fine for code reading a key sequence and
9547 then proceeding with a lenghty computation, but it's not good
9548 for code reading keys in a loop, like an input method. */
9549 #ifdef HAVE_X_WINDOWS
9550 if (display_hourglass_p
)
9561 return unbind_to (count
, make_event_array (i
, keybuf
));
9564 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
9565 Sread_key_sequence_vector
, 1, 5, 0,
9566 doc
: /* Like `read-key-sequence' but always return a vector. */)
9567 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9569 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9570 Lisp_Object can_return_switch_frame
, command_loop
;
9572 Lisp_Object keybuf
[30];
9574 struct gcpro gcpro1
;
9575 int count
= SPECPDL_INDEX ();
9578 CHECK_STRING (prompt
);
9581 specbind (Qinput_method_exit_on_first_char
,
9582 (NILP (command_loop
) ? Qt
: Qnil
));
9583 specbind (Qinput_method_use_echo_area
,
9584 (NILP (command_loop
) ? Qt
: Qnil
));
9586 bzero (keybuf
, sizeof keybuf
);
9588 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9590 if (NILP (continue_echo
))
9592 this_command_key_count
= 0;
9593 this_command_key_count_reset
= 0;
9594 this_single_command_key_start
= 0;
9597 #ifdef HAVE_X_WINDOWS
9598 if (display_hourglass_p
)
9599 cancel_hourglass ();
9602 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9603 prompt
, ! NILP (dont_downcase_last
),
9604 ! NILP (can_return_switch_frame
), 0);
9606 #ifdef HAVE_X_WINDOWS
9607 if (display_hourglass_p
)
9617 return unbind_to (count
, Fvector (i
, keybuf
));
9620 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
9621 doc
: /* Execute CMD as an editor command.
9622 CMD must be a symbol that satisfies the `commandp' predicate.
9623 Optional second arg RECORD-FLAG non-nil
9624 means unconditionally put this command in `command-history'.
9625 Otherwise, that is done only if an arg is read using the minibuffer.
9626 The argument KEYS specifies the value to use instead of (this-command-keys)
9627 when reading the arguments; if it is nil, (this-command-keys) is used.
9628 The argument SPECIAL, if non-nil, means that this command is executing
9629 a special event, so ignore the prefix argument and don't clear it. */)
9630 (cmd
, record_flag
, keys
, special
)
9631 Lisp_Object cmd
, record_flag
, keys
, special
;
9633 register Lisp_Object final
;
9634 register Lisp_Object tem
;
9635 Lisp_Object prefixarg
;
9636 struct backtrace backtrace
;
9637 extern int debug_on_next_call
;
9639 debug_on_next_call
= 0;
9643 prefixarg
= current_kboard
->Vprefix_arg
;
9644 Vcurrent_prefix_arg
= prefixarg
;
9645 current_kboard
->Vprefix_arg
= Qnil
;
9652 tem
= Fget (cmd
, Qdisabled
);
9653 if (!NILP (tem
) && !NILP (Vrun_hooks
))
9655 tem
= Fsymbol_value (Qdisabled_command_hook
);
9657 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
9663 final
= Findirect_function (cmd
);
9665 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
9667 struct gcpro gcpro1
, gcpro2
;
9669 GCPRO2 (cmd
, prefixarg
);
9670 do_autoload (final
, cmd
);
9677 if (STRINGP (final
) || VECTORP (final
))
9679 /* If requested, place the macro in the command history. For
9680 other sorts of commands, call-interactively takes care of
9682 if (!NILP (record_flag
))
9685 = Fcons (Fcons (Qexecute_kbd_macro
,
9686 Fcons (final
, Fcons (prefixarg
, Qnil
))),
9689 /* Don't keep command history around forever. */
9690 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
9692 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
9694 XSETCDR (tem
, Qnil
);
9698 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
9701 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
9703 backtrace
.next
= backtrace_list
;
9704 backtrace_list
= &backtrace
;
9705 backtrace
.function
= &Qcall_interactively
;
9706 backtrace
.args
= &cmd
;
9707 backtrace
.nargs
= 1;
9708 backtrace
.evalargs
= 0;
9710 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
9712 backtrace_list
= backtrace
.next
;
9720 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
9722 doc
: /* Read function name, then read its arguments and call it. */)
9724 Lisp_Object prefixarg
;
9726 Lisp_Object function
;
9728 int saved_last_point_position
;
9729 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
9730 Lisp_Object bindings
, value
;
9731 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9733 saved_keys
= Fvector (this_command_key_count
,
9734 XVECTOR (this_command_keys
)->contents
);
9735 saved_last_point_position_buffer
= last_point_position_buffer
;
9736 saved_last_point_position
= last_point_position
;
9738 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
9740 if (EQ (prefixarg
, Qminus
))
9742 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
9743 strcpy (buf
, "C-u ");
9744 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
9746 if (sizeof (int) == sizeof (EMACS_INT
))
9747 sprintf (buf
, "%d ", XINT (XCAR (prefixarg
)));
9748 else if (sizeof (long) == sizeof (EMACS_INT
))
9749 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
9753 else if (INTEGERP (prefixarg
))
9755 if (sizeof (int) == sizeof (EMACS_INT
))
9756 sprintf (buf
, "%d ", XINT (prefixarg
));
9757 else if (sizeof (long) == sizeof (EMACS_INT
))
9758 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
9763 /* This isn't strictly correct if execute-extended-command
9764 is bound to anything else. Perhaps it should use
9765 this_command_keys? */
9766 strcat (buf
, "M-x ");
9768 /* Prompt with buf, and then read a string, completing from and
9769 restricting to the set of all defined commands. Don't provide
9770 any initial input. Save the command read on the extended-command
9772 function
= Fcompleting_read (build_string (buf
),
9773 Vobarray
, Qcommandp
,
9774 Qt
, Qnil
, Qextended_command_history
, Qnil
,
9777 if (STRINGP (function
) && SCHARS (function
) == 0)
9778 error ("No command name given");
9780 /* Set this_command_keys to the concatenation of saved_keys and
9781 function, followed by a RET. */
9786 this_command_key_count
= 0;
9787 this_command_key_count_reset
= 0;
9788 this_single_command_key_start
= 0;
9790 keys
= XVECTOR (saved_keys
)->contents
;
9791 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
9792 add_command_key (keys
[i
]);
9794 for (i
= 0; i
< SCHARS (function
); i
++)
9795 add_command_key (Faref (function
, make_number (i
)));
9797 add_command_key (make_number ('\015'));
9800 last_point_position
= saved_last_point_position
;
9801 last_point_position_buffer
= saved_last_point_position_buffer
;
9805 function
= Fintern (function
, Qnil
);
9806 current_kboard
->Vprefix_arg
= prefixarg
;
9807 Vthis_command
= function
;
9808 real_this_command
= function
;
9810 /* If enabled, show which key runs this command. */
9811 if (!NILP (Vsuggest_key_bindings
)
9812 && NILP (Vexecuting_macro
)
9813 && SYMBOLP (function
))
9814 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
9820 GCPRO2 (bindings
, value
);
9821 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
9823 /* If the command has a key binding, print it now. */
9824 if (!NILP (bindings
)
9825 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
9828 /* But first wait, and skip the message if there is input. */
9830 if (!NILP (echo_area_buffer
[0]))
9831 /* This command displayed something in the echo area;
9832 so wait a few seconds, then display our suggestion message. */
9833 delay_time
= (NUMBERP (Vsuggest_key_bindings
)
9834 ? XINT (Vsuggest_key_bindings
) : 2);
9836 /* This command left the echo area empty,
9837 so display our message immediately. */
9840 if (!NILP (Fsit_for (make_number (delay_time
), Qnil
, Qnil
))
9841 && ! CONSP (Vunread_command_events
))
9843 Lisp_Object binding
;
9845 int message_p
= push_message ();
9846 int count
= SPECPDL_INDEX ();
9848 record_unwind_protect (pop_message_unwind
, Qnil
);
9849 binding
= Fkey_description (bindings
);
9852 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
9855 sprintf (newmessage
, "You can run the command `%s' with %s",
9856 SDATA (SYMBOL_NAME (function
)),
9858 message2_nolog (newmessage
,
9859 strlen (newmessage
),
9860 STRING_MULTIBYTE (binding
));
9861 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
9862 ? Vsuggest_key_bindings
: make_number (2)),
9867 unbind_to (count
, Qnil
);
9871 RETURN_UNGCPRO (value
);
9875 /* Return nonzero if input events are pending. */
9878 detect_input_pending ()
9881 get_input_pending (&input_pending
, 0);
9883 return input_pending
;
9886 /* Return nonzero if input events are pending, and run any pending timers. */
9889 detect_input_pending_run_timers (do_display
)
9892 int old_timers_run
= timers_run
;
9895 get_input_pending (&input_pending
, 1);
9897 if (old_timers_run
!= timers_run
&& do_display
)
9899 redisplay_preserve_echo_area (8);
9900 /* The following fixes a bug when using lazy-lock with
9901 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9902 from an idle timer function. The symptom of the bug is that
9903 the cursor sometimes doesn't become visible until the next X
9904 event is processed. --gerd. */
9906 Lisp_Object tail
, frame
;
9907 FOR_EACH_FRAME (tail
, frame
)
9908 if (FRAME_RIF (XFRAME (frame
)))
9909 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
9913 return input_pending
;
9916 /* This is called in some cases before a possible quit.
9917 It cases the next call to detect_input_pending to recompute input_pending.
9918 So calling this function unnecessarily can't do any harm. */
9921 clear_input_pending ()
9926 /* Return nonzero if there are pending requeued events.
9927 This isn't used yet. The hope is to make wait_reading_process_input
9928 call it, and return if it runs Lisp code that unreads something.
9929 The problem is, kbd_buffer_get_event needs to be fixed to know what
9930 to do in that case. It isn't trivial. */
9933 requeued_events_pending_p ()
9935 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
9939 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
9940 doc
: /* Return t if command input is currently available with no wait.
9941 Actually, the value is nil only if we can be sure that no input is available;
9942 if there is a doubt, the value is t. */)
9945 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
9948 get_filtered_input_pending (&input_pending
, 1, 1);
9949 return input_pending
> 0 ? Qt
: Qnil
;
9952 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
9953 doc
: /* Return vector of last 100 events, not counting those from keyboard macros. */)
9956 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
9959 if (total_keys
< NUM_RECENT_KEYS
)
9960 return Fvector (total_keys
, keys
);
9963 val
= Fvector (NUM_RECENT_KEYS
, keys
);
9964 bcopy (keys
+ recent_keys_index
,
9965 XVECTOR (val
)->contents
,
9966 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
9968 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
9969 recent_keys_index
* sizeof (Lisp_Object
));
9974 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
9975 doc
: /* Return the key sequence that invoked this command.
9976 However, if the command has called `read-key-sequence', it returns
9977 the last key sequence that has been read.
9978 The value is a string or a vector. */)
9981 return make_event_array (this_command_key_count
,
9982 XVECTOR (this_command_keys
)->contents
);
9985 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
9986 doc
: /* Return the key sequence that invoked this command, as a vector.
9987 However, if the command has called `read-key-sequence', it returns
9988 the last key sequence that has been read. */)
9991 return Fvector (this_command_key_count
,
9992 XVECTOR (this_command_keys
)->contents
);
9995 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
9996 Sthis_single_command_keys
, 0, 0, 0,
9997 doc
: /* Return the key sequence that invoked this command.
9998 More generally, it returns the last key sequence read, either by
9999 the command loop or by `read-key-sequence'.
10000 Unlike `this-command-keys', this function's value
10001 does not include prefix arguments.
10002 The value is always a vector. */)
10005 return Fvector (this_command_key_count
10006 - this_single_command_key_start
,
10007 (XVECTOR (this_command_keys
)->contents
10008 + this_single_command_key_start
));
10011 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10012 Sthis_single_command_raw_keys
, 0, 0, 0,
10013 doc
: /* Return the raw events that were read for this command.
10014 More generally, it returns the last key sequence read, either by
10015 the command loop or by `read-key-sequence'.
10016 Unlike `this-single-command-keys', this function's value
10017 shows the events before all translations (except for input methods).
10018 The value is always a vector. */)
10021 return Fvector (raw_keybuf_count
,
10022 (XVECTOR (raw_keybuf
)->contents
));
10025 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10026 Sreset_this_command_lengths
, 0, 0, 0,
10027 doc
: /* Make the unread events replace the last command and echo.
10028 Used in `universal-argument-other-key'.
10030 `universal-argument-other-key' rereads the event just typed.
10031 It then gets translated through `function-key-map'.
10032 The translated event has to replace the real events,
10033 both in the value of (this-command-keys) and in echoing.
10034 To achieve this, `universal-argument-other-key' calls
10035 `reset-this-command-lengths', which discards the record of reading
10036 these events the first time. */)
10039 this_command_key_count
= before_command_key_count
;
10040 if (this_command_key_count
< this_single_command_key_start
)
10041 this_single_command_key_start
= this_command_key_count
;
10043 echo_truncate (before_command_echo_length
);
10045 /* Cause whatever we put into unread-command-events
10046 to echo as if it were being freshly read from the keyboard. */
10047 this_command_key_count_reset
= 1;
10052 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10053 Sclear_this_command_keys
, 0, 1, 0,
10054 doc
: /* Clear out the vector that `this-command-keys' returns.
10055 Also clear the record of the last 100 events, unless optional arg
10056 KEEP-RECORD is non-nil. */)
10058 Lisp_Object keep_record
;
10062 this_command_key_count
= 0;
10063 this_command_key_count_reset
= 0;
10065 if (NILP (keep_record
))
10067 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10068 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10070 recent_keys_index
= 0;
10075 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10076 doc
: /* Return the current depth in recursive edits. */)
10080 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10084 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10085 "FOpen dribble file: ",
10086 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10087 If FILE is nil, close any open dribble file. */)
10098 file
= Fexpand_file_name (file
, Qnil
);
10099 dribble
= fopen (SDATA (file
), "w");
10101 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10106 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10107 doc
: /* Discard the contents of the terminal input buffer.
10108 Also end any kbd macro being defined. */)
10111 if (!NILP (current_kboard
->defining_kbd_macro
))
10113 /* Discard the last command from the macro. */
10114 Fcancel_kbd_macro_events ();
10118 update_mode_lines
++;
10120 Vunread_command_events
= Qnil
;
10121 unread_command_char
= -1;
10123 discard_tty_input ();
10125 kbd_fetch_ptr
= kbd_store_ptr
;
10126 Ffillarray (kbd_buffer_gcpro
, Qnil
);
10132 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10133 doc
: /* Stop Emacs and return to superior process. You can resume later.
10134 If `cannot-suspend' is non-nil, or if the system doesn't support job
10135 control, run a subshell instead.
10137 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10138 to be read as terminal input by Emacs's parent, after suspension.
10140 Before suspending, run the normal hook `suspend-hook'.
10141 After resumption run the normal hook `suspend-resume-hook'.
10143 Some operating systems cannot stop the Emacs process and resume it later.
10144 On such systems, Emacs starts a subshell instead of suspending. */)
10146 Lisp_Object stuffstring
;
10148 int count
= SPECPDL_INDEX ();
10149 int old_height
, old_width
;
10151 struct gcpro gcpro1
;
10153 if (tty_list
&& tty_list
->next
)
10154 error ("Suspend is not supported with multiple ttys");
10156 if (!NILP (stuffstring
))
10157 CHECK_STRING (stuffstring
);
10159 /* Run the functions in suspend-hook. */
10160 if (!NILP (Vrun_hooks
))
10161 call1 (Vrun_hooks
, intern ("suspend-hook"));
10163 GCPRO1 (stuffstring
);
10164 get_tty_size (fileno (TTY_INPUT (CURTTY ())), &old_width
, &old_height
);
10165 reset_all_sys_modes ();
10166 /* sys_suspend can get an error if it tries to fork a subshell
10167 and the system resources aren't available for that. */
10168 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_sys_modes
,
10169 (Lisp_Object
)CURTTY()); /* XXX */
10170 stuff_buffered_input (stuffstring
);
10171 if (cannot_suspend
)
10175 unbind_to (count
, Qnil
);
10177 /* Check if terminal/window size has changed.
10178 Note that this is not useful when we are running directly
10179 with a window system; but suspend should be disabled in that case. */
10180 get_tty_size (fileno (TTY_INPUT (CURTTY ())), &width
, &height
);
10181 if (width
!= old_width
|| height
!= old_height
)
10182 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10184 /* Run suspend-resume-hook. */
10185 if (!NILP (Vrun_hooks
))
10186 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10192 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10193 Then in any case stuff anything Emacs has read ahead and not used. */
10196 stuff_buffered_input (stuffstring
)
10197 Lisp_Object stuffstring
;
10199 /* stuff_char works only in BSD, versions 4.2 and up. */
10202 register unsigned char *p
;
10204 if (STRINGP (stuffstring
))
10206 register int count
;
10208 p
= SDATA (stuffstring
);
10209 count
= SBYTES (stuffstring
);
10210 while (count
-- > 0)
10215 /* Anything we have read ahead, put back for the shell to read. */
10216 /* ?? What should this do when we have multiple keyboards??
10217 Should we ignore anything that was typed in at the "wrong" kboard? */
10218 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10222 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10223 kbd_fetch_ptr
= kbd_buffer
;
10224 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10225 stuff_char (kbd_fetch_ptr
->code
);
10227 kbd_fetch_ptr
->kind
= NO_EVENT
;
10228 idx
= 2 * (kbd_fetch_ptr
- kbd_buffer
);
10229 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
10230 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
10235 #endif /* BSD_SYSTEM and not BSD4_1 */
10239 set_waiting_for_input (time_to_clear
)
10240 EMACS_TIME
*time_to_clear
;
10242 input_available_clear_time
= time_to_clear
;
10244 /* Tell handle_interrupt to throw back to read_char, */
10245 waiting_for_input
= 1;
10247 /* If handle_interrupt was called before and buffered a C-g,
10248 make it run again now, to avoid timing error. */
10249 if (!NILP (Vquit_flag
))
10250 quit_throw_to_read_char ();
10254 clear_waiting_for_input ()
10256 /* Tell handle_interrupt not to throw back to read_char, */
10257 waiting_for_input
= 0;
10258 input_available_clear_time
= 0;
10261 /* This routine is called at interrupt level in response to C-g.
10263 If interrupt_input, this is the handler for SIGINT. Otherwise, it
10264 is called from kbd_buffer_store_event, in handling SIGIO or
10267 If `waiting_for_input' is non zero, then unless `echoing' is
10268 nonzero, immediately throw back to read_char.
10270 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10271 eval to throw, when it gets a chance. If quit-flag is already
10272 non-nil, it stops the job right away.
10274 XXX This comment needs to be updated. */
10277 interrupt_signal (signalnum
) /* If we don't have an argument, */
10278 int signalnum
; /* some compilers complain in signal calls. */
10280 /* Must preserve main program's value of errno. */
10281 int old_errno
= errno
;
10283 #if defined (USG) && !defined (POSIX_SIGNALS)
10284 /* USG systems forget handlers when they are used;
10285 must reestablish each time */
10286 signal (SIGINT
, interrupt_signal
);
10287 signal (SIGQUIT
, interrupt_signal
);
10292 /* If there are no tty frames, exit Emacs.
10294 Emacs should exit on SIGINT if and only if there are no
10295 frames on its controlling tty and the signal came from there.
10296 We can check for the first condition, but (alas) not for the
10297 second. The best we can do is that we only exit if we are
10298 sure that the SIGINT was from the controlling tty, i.e., if
10299 there are no termcap frames.
10301 Fkill_emacs (Qnil
);
10307 handle_interrupt ();
10312 /* C-g processing, signal independent code.
10314 XXX Expand this comment. */
10316 handle_interrupt ()
10319 struct frame
*sf
= SELECTED_FRAME ();
10323 /* XXX This code needs to be revised for multi-tty support. */
10324 if (!NILP (Vquit_flag
)
10325 && (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
)))
10327 /* If SIGINT isn't blocked, don't let us be interrupted by
10328 another SIGINT, it might be harmful due to non-reentrancy
10329 in I/O functions. */
10330 sigblock (sigmask (SIGINT
));
10333 reset_all_sys_modes ();
10335 #ifdef SIGTSTP /* Support possible in later USG versions */
10337 * On systems which can suspend the current process and return to the original
10338 * shell, this command causes the user to end up back at the shell.
10339 * The "Auto-save" and "Abort" questions are not asked until
10340 * the user elects to return to emacs, at which point he can save the current
10341 * job and either dump core or continue.
10346 if (sys_suspend () == -1)
10348 printf ("Not running as a subprocess;\n");
10349 printf ("you can continue or abort.\n");
10351 #else /* not VMS */
10352 /* Perhaps should really fork an inferior shell?
10353 But that would not provide any way to get back
10354 to the original shell, ever. */
10355 printf ("No support for stopping a process on this operating system;\n");
10356 printf ("you can continue or abort.\n");
10357 #endif /* not VMS */
10358 #endif /* not SIGTSTP */
10360 /* We must remain inside the screen area when the internal terminal
10361 is used. Note that [Enter] is not echoed by dos. */
10364 /* It doesn't work to autosave while GC is in progress;
10365 the code used for auto-saving doesn't cope with the mark bit. */
10366 if (!gc_in_progress
)
10368 printf ("Auto-save? (y or n) ");
10370 if (((c
= getchar ()) & ~040) == 'Y')
10372 Fdo_auto_save (Qt
, Qnil
);
10374 printf ("\r\nAuto-save done");
10375 #else /* not MSDOS */
10376 printf ("Auto-save done\n");
10377 #endif /* not MSDOS */
10379 while (c
!= '\n') c
= getchar ();
10383 /* During GC, it must be safe to reenable quitting again. */
10384 Vinhibit_quit
= Qnil
;
10387 #endif /* not MSDOS */
10388 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10389 printf ("but will instead do a real quit after garbage collection ends\r\n");
10394 printf ("\r\nAbort? (y or n) ");
10395 #else /* not MSDOS */
10397 printf ("Abort (and enter debugger)? (y or n) ");
10398 #else /* not VMS */
10399 printf ("Abort (and dump core)? (y or n) ");
10400 #endif /* not VMS */
10401 #endif /* not MSDOS */
10403 if (((c
= getchar ()) & ~040) == 'Y')
10405 while (c
!= '\n') c
= getchar ();
10407 printf ("\r\nContinuing...\r\n");
10408 #else /* not MSDOS */
10409 printf ("Continuing...\n");
10410 #endif /* not MSDOS */
10412 init_all_sys_modes ();
10417 /* If executing a function that wants to be interrupted out of
10418 and the user has not deferred quitting by binding `inhibit-quit'
10419 then quit right away. */
10420 if (immediate_quit
&& NILP (Vinhibit_quit
))
10422 struct gl_state_s saved
;
10423 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10425 immediate_quit
= 0;
10428 GCPRO4 (saved
.object
, saved
.global_code
,
10429 saved
.current_syntax_table
, saved
.old_prop
);
10430 Fsignal (Qquit
, Qnil
);
10435 /* Else request quit when it's safe */
10439 if (waiting_for_input
&& !echoing
)
10440 quit_throw_to_read_char ();
10443 /* Handle a C-g by making read_char return C-g. */
10446 quit_throw_to_read_char ()
10449 /* Prevent another signal from doing this before we finish. */
10450 clear_waiting_for_input ();
10453 Vunread_command_events
= Qnil
;
10454 unread_command_char
= -1;
10456 #if 0 /* Currently, sit_for is called from read_char without turning
10457 off polling. And that can call set_waiting_for_input.
10458 It seems to be harmless. */
10459 #ifdef POLL_FOR_INPUT
10460 /* May be > 1 if in recursive minibuffer. */
10461 if (poll_suppress_count
== 0)
10465 if (FRAMEP (internal_last_event_frame
)
10466 && !EQ (internal_last_event_frame
, selected_frame
))
10467 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10470 _longjmp (getcjmp
, 1);
10473 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
10474 doc
: /* Set mode of reading keyboard input.
10475 First arg INTERRUPT non-nil means use input interrupts;
10476 nil means use CBREAK mode.
10477 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10478 (no effect except in CBREAK mode).
10479 Third arg META t means accept 8-bit input (for a Meta key).
10480 META nil means ignore the top bit, on the assumption it is parity.
10481 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10482 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10483 See also `current-input-mode'. */)
10484 (interrupt
, flow
, meta
, quit
)
10485 Lisp_Object interrupt
, flow
, meta
, quit
;
10487 /* XXX This function needs to be revised for multi-device support.
10488 Currently it compiles fine, but its semantics are wrong. It sets
10489 global parameters (e.g. interrupt_input) based on only the
10490 current frame's device. */
10493 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
10494 error ("set-input-mode: QUIT must be an ASCII character");
10496 #ifdef POLL_FOR_INPUT
10501 /* this causes startup screen to be restored and messes with the mouse */
10502 if (FRAME_TERMCAP_P (SELECTED_FRAME ()))
10503 reset_sys_modes (CURTTY ());
10507 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10508 if (FRAME_DISPLAY (SELECTED_FRAME ())->read_socket_hook
)
10510 /* When using X, don't give the user a real choice,
10511 because we haven't implemented the mechanisms to support it. */
10512 #ifdef NO_SOCK_SIGIO
10513 interrupt_input
= 0;
10514 #else /* not NO_SOCK_SIGIO */
10515 interrupt_input
= 1;
10516 #endif /* NO_SOCK_SIGIO */
10519 interrupt_input
= !NILP (interrupt
);
10520 #else /* not SIGIO */
10521 interrupt_input
= 0;
10522 #endif /* not SIGIO */
10524 /* Our VMS input only works by interrupts, as of now. */
10526 interrupt_input
= 1;
10529 if (FRAME_TERMCAP_P (XFRAME (selected_frame
)))
10531 struct tty_display_info
*tty
= CURTTY ();
10532 tty
->flow_control
= !NILP (flow
);
10535 else if (EQ (meta
, Qt
))
10541 if (FRAME_TERMCAP_P (XFRAME (selected_frame
)) && !NILP (quit
))
10542 /* Don't let this value be out of range. */
10543 quit_char
= XINT (quit
) & (CURTTY ()->meta_key
? 0377 : 0177);
10546 if (FRAME_TERMCAP_P (XFRAME (selected_frame
)) && CURTTY ()->type
)
10547 init_sys_modes (CURTTY ());
10550 #ifdef POLL_FOR_INPUT
10551 poll_suppress_count
= 1;
10557 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
10558 doc
: /* Return information about the way Emacs currently reads keyboard input.
10559 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10560 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10561 nil, Emacs is using CBREAK mode.
10562 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10563 terminal; this does not apply if Emacs uses interrupt-driven input.
10564 META is t if accepting 8-bit input with 8th bit as Meta flag.
10565 META nil means ignoring the top bit, on the assumption it is parity.
10566 META is neither t nor nil if accepting 8-bit input and using
10567 all 8 bits as the character code.
10568 QUIT is the character Emacs currently uses to quit.
10569 The elements of this list correspond to the arguments of
10570 `set-input-mode'. */)
10573 Lisp_Object val
[4];
10574 struct frame
*sf
= XFRAME (selected_frame
);
10576 val
[0] = interrupt_input
? Qt
: Qnil
;
10577 if (FRAME_TERMCAP_P (sf
))
10579 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
10580 val
[2] = FRAME_TTY (sf
)->meta_key
== 2
10582 : CURTTY ()->meta_key
== 1 ? Qt
: Qnil
;
10589 XSETFASTINT (val
[3], quit_char
);
10591 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
10596 * Set up a new kboard object with reasonable initial values.
10602 kb
->Voverriding_terminal_local_map
= Qnil
;
10603 kb
->Vlast_command
= Qnil
;
10604 kb
->Vreal_last_command
= Qnil
;
10605 kb
->Vprefix_arg
= Qnil
;
10606 kb
->Vlast_prefix_arg
= Qnil
;
10607 kb
->kbd_queue
= Qnil
;
10608 kb
->kbd_queue_has_data
= 0;
10609 kb
->immediate_echo
= 0;
10610 kb
->echo_string
= Qnil
;
10611 kb
->echo_after_prompt
= -1;
10612 kb
->kbd_macro_buffer
= 0;
10613 kb
->kbd_macro_bufsize
= 0;
10614 kb
->defining_kbd_macro
= Qnil
;
10615 kb
->Vlast_kbd_macro
= Qnil
;
10616 kb
->reference_count
= 0;
10617 kb
->Vsystem_key_alist
= Qnil
;
10618 kb
->system_key_syms
= Qnil
;
10619 kb
->Vdefault_minibuffer_frame
= Qnil
;
10623 * Destroy the contents of a kboard object, but not the object itself.
10624 * We use this just before deleting it, or if we're going to initialize
10625 * it a second time.
10631 if (kb
->kbd_macro_buffer
)
10632 xfree (kb
->kbd_macro_buffer
);
10635 #ifdef MULTI_KBOARD
10637 /* Free KB and memory referenced from it. */
10645 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
10648 *kbp
= kb
->next_kboard
;
10650 /* Prevent a dangling reference to KB. */
10651 if (kb
== current_kboard
10652 && FRAMEP (selected_frame
)
10653 && FRAME_LIVE_P (XFRAME (selected_frame
)))
10655 current_kboard
= XFRAME (selected_frame
)->kboard
;
10656 if (current_kboard
== kb
)
10664 #endif /* MULTI_KBOARD */
10669 /* This is correct before outermost invocation of the editor loop */
10670 command_loop_level
= -1;
10671 immediate_quit
= 0;
10672 quit_char
= Ctl ('g');
10673 Vunread_command_events
= Qnil
;
10674 unread_command_char
= -1;
10675 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
10677 recent_keys_index
= 0;
10678 kbd_fetch_ptr
= kbd_buffer
;
10679 kbd_store_ptr
= kbd_buffer
;
10680 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10682 do_mouse_tracking
= Qnil
;
10686 /* This means that command_loop_1 won't try to select anything the first
10688 internal_last_event_frame
= Qnil
;
10689 Vlast_event_frame
= internal_last_event_frame
;
10691 #ifdef MULTI_KBOARD
10692 current_kboard
= initial_kboard
;
10694 wipe_kboard (current_kboard
);
10695 init_kboard (current_kboard
);
10697 if (!noninteractive
)
10699 /* Before multi-tty support, these handlers used to be installed
10700 only if the current session was a tty session. Now an Emacs
10701 session may have multiple display types, so we always handle
10702 SIGINT. There is special code in interrupt_signal to exit
10703 Emacs on SIGINT when there are no termcap frames. */
10704 signal (SIGINT
, interrupt_signal
);
10705 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
10706 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10707 SIGQUIT and we can't tell which one it will give us. */
10708 signal (SIGQUIT
, interrupt_signal
);
10709 #endif /* HAVE_TERMIO */
10711 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10713 if (!noninteractive
)
10714 signal (SIGIO
, input_available_signal
);
10717 /* Use interrupt input by default, if it works and noninterrupt input
10718 has deficiencies. */
10720 #ifdef INTERRUPT_INPUT
10721 interrupt_input
= 1;
10723 interrupt_input
= 0;
10726 /* Our VMS input only works by interrupts, as of now. */
10728 interrupt_input
= 1;
10734 if (keyboard_init_hook
)
10735 (*keyboard_init_hook
) ();
10737 #ifdef POLL_FOR_INPUT
10738 poll_suppress_count
= 1;
10743 /* At least provide an escape route since C-g doesn't work. */
10744 signal (SIGINT
, interrupt_signal
);
10748 /* This type's only use is in syms_of_keyboard, to initialize the
10749 event header symbols and put properties on them. */
10750 struct event_head
{
10756 struct event_head head_table
[] = {
10757 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
10758 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
10759 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
10760 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
10761 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
10762 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
10763 /* `select-window' should be handled just like `switch-frame'
10764 in read_key_sequence. */
10765 {&Qselect_window
, "select-window", &Qswitch_frame
}
10769 syms_of_keyboard ()
10771 Vpre_help_message
= Qnil
;
10772 staticpro (&Vpre_help_message
);
10774 Vlispy_mouse_stem
= build_string ("mouse");
10775 staticpro (&Vlispy_mouse_stem
);
10778 QCimage
= intern (":image");
10779 staticpro (&QCimage
);
10781 staticpro (&Qhelp_echo
);
10782 Qhelp_echo
= intern ("help-echo");
10784 staticpro (&item_properties
);
10785 item_properties
= Qnil
;
10787 staticpro (&tool_bar_item_properties
);
10788 tool_bar_item_properties
= Qnil
;
10789 staticpro (&tool_bar_items_vector
);
10790 tool_bar_items_vector
= Qnil
;
10792 staticpro (&real_this_command
);
10793 real_this_command
= Qnil
;
10795 Qtimer_event_handler
= intern ("timer-event-handler");
10796 staticpro (&Qtimer_event_handler
);
10798 Qdisabled_command_hook
= intern ("disabled-command-hook");
10799 staticpro (&Qdisabled_command_hook
);
10801 Qself_insert_command
= intern ("self-insert-command");
10802 staticpro (&Qself_insert_command
);
10804 Qforward_char
= intern ("forward-char");
10805 staticpro (&Qforward_char
);
10807 Qbackward_char
= intern ("backward-char");
10808 staticpro (&Qbackward_char
);
10810 Qdisabled
= intern ("disabled");
10811 staticpro (&Qdisabled
);
10813 Qundefined
= intern ("undefined");
10814 staticpro (&Qundefined
);
10816 Qpre_command_hook
= intern ("pre-command-hook");
10817 staticpro (&Qpre_command_hook
);
10819 Qpost_command_hook
= intern ("post-command-hook");
10820 staticpro (&Qpost_command_hook
);
10822 Qpost_command_idle_hook
= intern ("post-command-idle-hook");
10823 staticpro (&Qpost_command_idle_hook
);
10825 Qdeferred_action_function
= intern ("deferred-action-function");
10826 staticpro (&Qdeferred_action_function
);
10828 Qcommand_hook_internal
= intern ("command-hook-internal");
10829 staticpro (&Qcommand_hook_internal
);
10831 Qfunction_key
= intern ("function-key");
10832 staticpro (&Qfunction_key
);
10833 Qmouse_click
= intern ("mouse-click");
10834 staticpro (&Qmouse_click
);
10836 Qlanguage_change
= intern ("language-change");
10837 staticpro (&Qlanguage_change
);
10839 Qdrag_n_drop
= intern ("drag-n-drop");
10840 staticpro (&Qdrag_n_drop
);
10842 Qsave_session
= intern ("save-session");
10843 staticpro(&Qsave_session
);
10845 Qusr1_signal
= intern ("usr1-signal");
10846 staticpro (&Qusr1_signal
);
10847 Qusr2_signal
= intern ("usr2-signal");
10848 staticpro (&Qusr2_signal
);
10850 Qmenu_enable
= intern ("menu-enable");
10851 staticpro (&Qmenu_enable
);
10852 Qmenu_alias
= intern ("menu-alias");
10853 staticpro (&Qmenu_alias
);
10854 QCenable
= intern (":enable");
10855 staticpro (&QCenable
);
10856 QCvisible
= intern (":visible");
10857 staticpro (&QCvisible
);
10858 QChelp
= intern (":help");
10859 staticpro (&QChelp
);
10860 QCfilter
= intern (":filter");
10861 staticpro (&QCfilter
);
10862 QCbutton
= intern (":button");
10863 staticpro (&QCbutton
);
10864 QCkeys
= intern (":keys");
10865 staticpro (&QCkeys
);
10866 QCkey_sequence
= intern (":key-sequence");
10867 staticpro (&QCkey_sequence
);
10868 QCtoggle
= intern (":toggle");
10869 staticpro (&QCtoggle
);
10870 QCradio
= intern (":radio");
10871 staticpro (&QCradio
);
10873 Qmode_line
= intern ("mode-line");
10874 staticpro (&Qmode_line
);
10875 Qvertical_line
= intern ("vertical-line");
10876 staticpro (&Qvertical_line
);
10877 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
10878 staticpro (&Qvertical_scroll_bar
);
10879 Qmenu_bar
= intern ("menu-bar");
10880 staticpro (&Qmenu_bar
);
10882 Qabove_handle
= intern ("above-handle");
10883 staticpro (&Qabove_handle
);
10884 Qhandle
= intern ("handle");
10885 staticpro (&Qhandle
);
10886 Qbelow_handle
= intern ("below-handle");
10887 staticpro (&Qbelow_handle
);
10888 Qup
= intern ("up");
10890 Qdown
= intern ("down");
10891 staticpro (&Qdown
);
10892 Qtop
= intern ("top");
10894 Qbottom
= intern ("bottom");
10895 staticpro (&Qbottom
);
10896 Qend_scroll
= intern ("end-scroll");
10897 staticpro (&Qend_scroll
);
10898 Qratio
= intern ("ratio");
10899 staticpro (&Qratio
);
10901 Qevent_kind
= intern ("event-kind");
10902 staticpro (&Qevent_kind
);
10903 Qevent_symbol_elements
= intern ("event-symbol-elements");
10904 staticpro (&Qevent_symbol_elements
);
10905 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
10906 staticpro (&Qevent_symbol_element_mask
);
10907 Qmodifier_cache
= intern ("modifier-cache");
10908 staticpro (&Qmodifier_cache
);
10910 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
10911 staticpro (&Qrecompute_lucid_menubar
);
10912 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
10913 staticpro (&Qactivate_menubar_hook
);
10915 Qpolling_period
= intern ("polling-period");
10916 staticpro (&Qpolling_period
);
10918 Qinput_method_function
= intern ("input-method-function");
10919 staticpro (&Qinput_method_function
);
10921 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
10922 staticpro (&Qinput_method_exit_on_first_char
);
10923 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
10924 staticpro (&Qinput_method_use_echo_area
);
10926 Fset (Qinput_method_exit_on_first_char
, Qnil
);
10927 Fset (Qinput_method_use_echo_area
, Qnil
);
10929 last_point_position_buffer
= Qnil
;
10932 struct event_head
*p
;
10934 for (p
= head_table
;
10935 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
10938 *p
->var
= intern (p
->name
);
10939 staticpro (p
->var
);
10940 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
10941 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
10945 button_down_location
= Fmake_vector (make_number (1), Qnil
);
10946 staticpro (&button_down_location
);
10947 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
10948 staticpro (&mouse_syms
);
10949 wheel_syms
= Fmake_vector (make_number (2), Qnil
);
10950 staticpro (&wheel_syms
);
10954 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
10956 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
10957 for (i
= 0; i
< len
; i
++)
10958 if (modifier_names
[i
])
10959 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
10960 staticpro (&modifier_symbols
);
10963 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
10964 staticpro (&recent_keys
);
10966 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
10967 staticpro (&this_command_keys
);
10969 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
10970 staticpro (&raw_keybuf
);
10972 Qextended_command_history
= intern ("extended-command-history");
10973 Fset (Qextended_command_history
, Qnil
);
10974 staticpro (&Qextended_command_history
);
10976 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10977 staticpro (&kbd_buffer_gcpro
);
10979 accent_key_syms
= Qnil
;
10980 staticpro (&accent_key_syms
);
10982 func_key_syms
= Qnil
;
10983 staticpro (&func_key_syms
);
10985 drag_n_drop_syms
= Qnil
;
10986 staticpro (&drag_n_drop_syms
);
10988 unread_switch_frame
= Qnil
;
10989 staticpro (&unread_switch_frame
);
10991 internal_last_event_frame
= Qnil
;
10992 staticpro (&internal_last_event_frame
);
10994 read_key_sequence_cmd
= Qnil
;
10995 staticpro (&read_key_sequence_cmd
);
10997 menu_bar_one_keymap_changed_items
= Qnil
;
10998 staticpro (&menu_bar_one_keymap_changed_items
);
11000 defsubr (&Sevent_convert_list
);
11001 defsubr (&Sread_key_sequence
);
11002 defsubr (&Sread_key_sequence_vector
);
11003 defsubr (&Srecursive_edit
);
11005 defsubr (&Strack_mouse
);
11007 defsubr (&Sinput_pending_p
);
11008 defsubr (&Scommand_execute
);
11009 defsubr (&Srecent_keys
);
11010 defsubr (&Sthis_command_keys
);
11011 defsubr (&Sthis_command_keys_vector
);
11012 defsubr (&Sthis_single_command_keys
);
11013 defsubr (&Sthis_single_command_raw_keys
);
11014 defsubr (&Sreset_this_command_lengths
);
11015 defsubr (&Sclear_this_command_keys
);
11016 defsubr (&Ssuspend_emacs
);
11017 defsubr (&Sabort_recursive_edit
);
11018 defsubr (&Sexit_recursive_edit
);
11019 defsubr (&Srecursion_depth
);
11020 defsubr (&Stop_level
);
11021 defsubr (&Sdiscard_input
);
11022 defsubr (&Sopen_dribble_file
);
11023 defsubr (&Sset_input_mode
);
11024 defsubr (&Scurrent_input_mode
);
11025 defsubr (&Sexecute_extended_command
);
11027 DEFVAR_LISP ("last-command-char", &last_command_char
,
11028 doc
: /* Last input event that was part of a command. */);
11030 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
11031 doc
: /* Last input event that was part of a command. */);
11033 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
11034 doc
: /* Last input event in a command, except for mouse menu events.
11035 Mouse menus give back keys that don't look like mouse events;
11036 this variable holds the actual mouse event that led to the menu,
11037 so that you can determine whether the command was run by mouse or not. */);
11039 DEFVAR_LISP ("last-input-char", &last_input_char
,
11040 doc
: /* Last input event. */);
11042 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
11043 doc
: /* Last input event. */);
11045 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
11046 doc
: /* List of events to be read as the command input.
11047 These events are processed first, before actual keyboard input. */);
11048 Vunread_command_events
= Qnil
;
11050 DEFVAR_INT ("unread-command-char", &unread_command_char
,
11051 doc
: /* If not -1, an object to be read as next command input event. */);
11053 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
11054 doc
: /* List of events to be processed as input by input methods.
11055 These events are processed after `unread-command-events', but
11056 before actual keyboard input. */);
11057 Vunread_post_input_method_events
= Qnil
;
11059 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
11060 doc
: /* List of events to be processed as input by input methods.
11061 These events are processed after `unread-command-events', but
11062 before actual keyboard input. */);
11063 Vunread_input_method_events
= Qnil
;
11065 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
11066 doc
: /* Meta-prefix character code.
11067 Meta-foo as command input turns into this character followed by foo. */);
11068 XSETINT (meta_prefix_char
, 033);
11070 DEFVAR_KBOARD ("last-command", Vlast_command
,
11071 doc
: /* The last command executed.
11072 Normally a symbol with a function definition, but can be whatever was found
11073 in the keymap, or whatever the variable `this-command' was set to by that
11076 The value `mode-exit' is special; it means that the previous command
11077 read an event that told it to exit, and it did so and unread that event.
11078 In other words, the present command is the event that made the previous
11081 The value `kill-region' is special; it means that the previous command
11082 was a kill command. */);
11084 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11085 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11087 DEFVAR_LISP ("this-command", &Vthis_command
,
11088 doc
: /* The command now being executed.
11089 The command can set this variable; whatever is put here
11090 will be in `last-command' during the following command. */);
11091 Vthis_command
= Qnil
;
11093 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
11094 doc
: /* The command bound to the current key sequence before remapping.
11095 It equals `this-command' if the original command was not remapped through
11096 any of the active keymaps. Otherwise, the value of `this-command' is the
11097 result of looking up the original command in the active keymaps. */);
11098 Vthis_original_command
= Qnil
;
11100 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
11101 doc
: /* *Number of input events between auto-saves.
11102 Zero means disable autosaving due to number of characters typed. */);
11103 auto_save_interval
= 300;
11105 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
11106 doc
: /* *Number of seconds idle time before auto-save.
11107 Zero or nil means disable auto-saving due to idleness.
11108 After auto-saving due to this many seconds of idle time,
11109 Emacs also does a garbage collection if that seems to be warranted. */);
11110 XSETFASTINT (Vauto_save_timeout
, 30);
11112 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11113 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11114 The value may be integer or floating point. */);
11115 Vecho_keystrokes
= make_number (1);
11117 DEFVAR_INT ("polling-period", &polling_period
,
11118 doc
: /* *Interval between polling for input during Lisp execution.
11119 The reason for polling is to make C-g work to stop a running program.
11120 Polling is needed only when using X windows and SIGIO does not work.
11121 Polling is automatically disabled in all other cases. */);
11122 polling_period
= 2;
11124 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
11125 doc
: /* *Maximum time between mouse clicks to make a double-click.
11126 Measured in milliseconds. nil means disable double-click recognition;
11127 t means double-clicks have no time limit and are detected
11128 by position only. */);
11129 Vdouble_click_time
= make_number (500);
11131 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
11132 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11133 On window-system frames, value is the number of pixels the mouse may have
11134 moved horizontally or vertically between two clicks to make a double-click.
11135 On non window-system frames, value is interpreted in units of 1/8 characters
11138 This variable is also the threshold for motion of the mouse
11139 to count as a drag. */);
11140 double_click_fuzz
= 3;
11142 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
11143 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11144 inhibit_local_menu_bar_menus
= 0;
11146 DEFVAR_INT ("num-input-keys", &num_input_keys
,
11147 doc
: /* Number of complete key sequences read as input so far.
11148 This includes key sequences read from keyboard macros.
11149 The number is effectively the number of interactive command invocations. */);
11150 num_input_keys
= 0;
11152 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
11153 doc
: /* Number of input events read from the keyboard so far.
11154 This does not include events generated by keyboard macros. */);
11155 num_nonmacro_input_events
= 0;
11157 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
11158 doc
: /* The frame in which the most recently read event occurred.
11159 If the last event came from a keyboard macro, this is set to `macro'. */);
11160 Vlast_event_frame
= Qnil
;
11162 /* This variable is set up in sysdep.c. */
11163 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
11164 doc
: /* The ERASE character as set by the user with stty. */);
11166 DEFVAR_LISP ("help-char", &Vhelp_char
,
11167 doc
: /* Character to recognize as meaning Help.
11168 When it is read, do `(eval help-form)', and display result if it's a string.
11169 If the value of `help-form' is nil, this char can be read normally. */);
11170 XSETINT (Vhelp_char
, Ctl ('H'));
11172 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
11173 doc
: /* List of input events to recognize as meaning Help.
11174 These work just like the value of `help-char' (see that). */);
11175 Vhelp_event_list
= Qnil
;
11177 DEFVAR_LISP ("help-form", &Vhelp_form
,
11178 doc
: /* Form to execute when character `help-char' is read.
11179 If the form returns a string, that string is displayed.
11180 If `help-form' is nil, the help char is not recognized. */);
11183 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
11184 doc
: /* Command to run when `help-char' character follows a prefix key.
11185 This command is used only when there is no actual binding
11186 for that character after that prefix key. */);
11187 Vprefix_help_command
= Qnil
;
11189 DEFVAR_LISP ("top-level", &Vtop_level
,
11190 doc
: /* Form to evaluate when Emacs starts up.
11191 Useful to set before you dump a modified Emacs. */);
11194 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
11195 doc
: /* Translate table for keyboard input, or nil.
11196 Each character is looked up in this string and the contents used instead.
11197 The value may be a string, a vector, or a char-table.
11198 If it is a string or vector of length N,
11199 character codes N and up are untranslated.
11200 In a vector or a char-table, an element which is nil means "no translation".
11202 This is applied to the characters supplied to input methods, not their
11203 output. See also `translation-table-for-input'. */);
11204 Vkeyboard_translate_table
= Qnil
;
11206 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
11207 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11208 \(Even if the operating system has support for stopping a process.\) */);
11209 cannot_suspend
= 0;
11211 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
11212 doc
: /* Non-nil means prompt with menus when appropriate.
11213 This is done when reading from a keymap that has a prompt string,
11214 for elements that have prompt strings.
11215 The menu is displayed on the screen
11216 if X menus were enabled at configuration
11217 time and the previous event was a mouse click prefix key.
11218 Otherwise, menu prompting uses the echo area. */);
11219 menu_prompting
= 1;
11221 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
11222 doc
: /* Character to see next line of menu prompt.
11223 Type this character while in a menu prompt to rotate around the lines of it. */);
11224 XSETINT (menu_prompt_more_char
, ' ');
11226 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
11227 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11228 Emacs applies the modifiers of the character stored here to each keyboard
11229 character it reads. For example, after evaluating the expression
11230 (setq extra-keyboard-modifiers ?\\C-x)
11231 all input characters will have the control modifier applied to them.
11233 Note that the character ?\\C-@, equivalent to the integer zero, does
11234 not count as a control character; rather, it counts as a character
11235 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11236 cancels any modification. */);
11237 extra_keyboard_modifiers
= 0;
11239 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
11240 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11241 The command loop sets this to nil before each command,
11242 and tests the value when the command returns.
11243 Buffer modification stores t in this variable. */);
11244 Vdeactivate_mark
= Qnil
;
11246 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
11247 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
11248 Vcommand_hook_internal
= Qnil
;
11250 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
11251 doc
: /* Normal hook run before each command is executed.
11252 If an unhandled error happens in running this hook,
11253 the hook value is set to nil, since otherwise the error
11254 might happen repeatedly and make Emacs nonfunctional. */);
11255 Vpre_command_hook
= Qnil
;
11257 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
11258 doc
: /* Normal hook run after each command is executed.
11259 If an unhandled error happens in running this hook,
11260 the hook value is set to nil, since otherwise the error
11261 might happen repeatedly and make Emacs nonfunctional. */);
11262 Vpost_command_hook
= Qnil
;
11264 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook
,
11265 doc
: /* Normal hook run after each command is executed, if idle.
11266 Errors running the hook are caught and ignored. */);
11267 Vpost_command_idle_hook
= Qnil
;
11269 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay
,
11270 doc
: /* Delay time before running `post-command-idle-hook'.
11271 This is measured in microseconds. */);
11272 post_command_idle_delay
= 100000;
11275 DEFVAR_LISP ("echo-area-clear-hook", ...,
11276 doc
: /* Normal hook run when clearing the echo area. */);
11278 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
11279 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
11281 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
11282 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11283 Vlucid_menu_bar_dirty_flag
= Qnil
;
11285 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
11286 doc
: /* List of menu bar items to move to the end of the menu bar.
11287 The elements of the list are event types that may have menu bar bindings. */);
11288 Vmenu_bar_final_items
= Qnil
;
11290 DEFVAR_KBOARD ("overriding-terminal-local-map",
11291 Voverriding_terminal_local_map
,
11292 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11293 If this variable is non-nil, it is used as a keymap instead of the
11294 buffer's local map, and the minor mode keymaps and text property keymaps.
11295 This variable is intended to let commands such as `universal-argument'
11296 set up a different keymap for reading the next command. */);
11298 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
11299 doc
: /* Keymap that overrides all other local keymaps.
11300 If this variable is non-nil, it is used as a keymap instead of the
11301 buffer's local map, and the minor mode keymaps and text property keymaps. */);
11302 Voverriding_local_map
= Qnil
;
11304 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
11305 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11306 Otherwise, the menu bar continues to reflect the buffer's local map
11307 and the minor mode maps regardless of `overriding-local-map'. */);
11308 Voverriding_local_map_menu_flag
= Qnil
;
11310 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
11311 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11312 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
11314 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
11315 doc
: /* *Non-nil means generate motion events for mouse motion. */);
11317 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11318 doc
: /* Alist of system-specific X windows key symbols.
11319 Each element should have the form (N . SYMBOL) where N is the
11320 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11321 and SYMBOL is its name. */);
11323 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
11324 doc
: /* List of deferred actions to be performed at a later time.
11325 The precise format isn't relevant here; we just check whether it is nil. */);
11326 Vdeferred_action_list
= Qnil
;
11328 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
11329 doc
: /* Function to call to handle deferred actions, after each command.
11330 This function is called with no arguments after each command
11331 whenever `deferred-action-list' is non-nil. */);
11332 Vdeferred_action_function
= Qnil
;
11334 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
11335 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
11336 The value can be a length of time to show the message for.
11337 If the value is non-nil and not a number, we wait 2 seconds. */);
11338 Vsuggest_key_bindings
= Qt
;
11340 DEFVAR_LISP ("timer-list", &Vtimer_list
,
11341 doc
: /* List of active absolute time timers in order of increasing time. */);
11342 Vtimer_list
= Qnil
;
11344 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
11345 doc
: /* List of active idle-time timers in order of increasing time. */);
11346 Vtimer_idle_list
= Qnil
;
11348 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
11349 doc
: /* If non-nil, the function that implements the current input method.
11350 It's called with one argument, a printing character that was just read.
11351 \(That means a character with code 040...0176.)
11352 Typically this function uses `read-event' to read additional events.
11353 When it does so, it should first bind `input-method-function' to nil
11354 so it will not be called recursively.
11356 The function should return a list of zero or more events
11357 to be used as input. If it wants to put back some events
11358 to be reconsidered, separately, by the input method,
11359 it can add them to the beginning of `unread-command-events'.
11361 The input method function can find in `input-method-previous-method'
11362 the previous echo area message.
11364 The input method function should refer to the variables
11365 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11366 for guidance on what to do. */);
11367 Vinput_method_function
= Qnil
;
11369 DEFVAR_LISP ("input-method-previous-message",
11370 &Vinput_method_previous_message
,
11371 doc
: /* When `input-method-function' is called, hold the previous echo area message.
11372 This variable exists because `read-event' clears the echo area
11373 before running the input method. It is nil if there was no message. */);
11374 Vinput_method_previous_message
= Qnil
;
11376 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
11377 doc
: /* If non-nil, the function that implements the display of help.
11378 It's called with one argument, the help string to display. */);
11379 Vshow_help_function
= Qnil
;
11381 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
11382 doc
: /* If non-nil, suppress point adjustment after executing a command.
11384 After a command is executed, if point is moved into a region that has
11385 special properties (e.g. composition, display), we adjust point to
11386 the boundary of the region. But, several special commands sets this
11387 variable to non-nil, then we suppress the point adjustment.
11389 This variable is set to nil before reading a command, and is checked
11390 just after executing the command. */);
11391 Vdisable_point_adjustment
= Qnil
;
11393 DEFVAR_LISP ("global-disable-point-adjustment",
11394 &Vglobal_disable_point_adjustment
,
11395 doc
: /* *If non-nil, always suppress point adjustment.
11397 The default value is nil, in which case, point adjustment are
11398 suppressed only after special commands that set
11399 `disable-point-adjustment' (which see) to non-nil. */);
11400 Vglobal_disable_point_adjustment
= Qnil
;
11402 DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings
,
11403 doc
: /* Non-nil means updating menu bindings is allowed.
11404 A value of nil means menu bindings should not be updated.
11405 Used during Emacs' startup. */);
11406 update_menu_bindings
= 1;
11408 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
11409 doc
: /* *How long to display an echo-area message when the minibuffer is active.
11410 If the value is not a number, such messages don't time out. */);
11411 Vminibuffer_message_timeout
= make_number (2);
11415 keys_of_keyboard ()
11417 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
11418 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
11419 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
11420 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
11421 initial_define_key (meta_map
, 'x', "execute-extended-command");
11423 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
11424 "handle-delete-frame");
11425 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
11427 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
11429 /* Handling it at such a low-level causes read_key_sequence to get
11430 * confused because it doesn't realize that the current_buffer was
11431 * changed by read_char.
11433 * initial_define_lispy_key (Vspecial_event_map, "select-window",
11434 * "handle-select-window"); */
11435 initial_define_lispy_key (Vspecial_event_map
, "save-session",
11436 "handle-save-session");
11439 /* Mark the pointers in the kboard objects.
11440 Called by the Fgarbage_collector. */
11446 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
11448 if (kb
->kbd_macro_buffer
)
11449 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
11451 mark_object (kb
->Voverriding_terminal_local_map
);
11452 mark_object (kb
->Vlast_command
);
11453 mark_object (kb
->Vreal_last_command
);
11454 mark_object (kb
->Vprefix_arg
);
11455 mark_object (kb
->Vlast_prefix_arg
);
11456 mark_object (kb
->kbd_queue
);
11457 mark_object (kb
->defining_kbd_macro
);
11458 mark_object (kb
->Vlast_kbd_macro
);
11459 mark_object (kb
->Vsystem_key_alist
);
11460 mark_object (kb
->system_key_syms
);
11461 mark_object (kb
->Vdefault_minibuffer_frame
);
11462 mark_object (kb
->echo_string
);
11465 struct input_event
*event
;
11466 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
11468 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
11469 event
= kbd_buffer
;
11470 mark_object (event
->x
);
11471 mark_object (event
->y
);
11472 mark_object (event
->frame_or_window
);
11473 mark_object (event
->arg
);
11478 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
11479 (do not change this comment) */