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. */
26 #include "systty.h" /* This must be included befor termchar.h. */
29 #include "termhooks.h"
38 #include "dispextern.h"
40 #include "intervals.h"
42 #include "blockinput.h"
54 #include <sys/ioctl.h>
56 #endif /* not MSDOS */
58 #include "syssignal.h"
60 #include <sys/types.h>
65 /* This is to get the definitions of the XK_ symbols. */
72 #endif /* HAVE_NTGUI */
82 /* Variables for blockinput.h: */
84 /* Non-zero if interrupt input is blocked right now. */
85 int interrupt_input_blocked
;
87 /* Nonzero means an input interrupt has arrived
88 during the current critical section. */
89 int interrupt_input_pending
;
92 #ifdef HAVE_WINDOW_SYSTEM
93 /* Make all keyboard buffers much bigger when using X windows. */
95 /* But not too big (local data > 32K error) if on Mac OS Classic. */
96 #define KBD_BUFFER_SIZE 512
98 #define KBD_BUFFER_SIZE 4096
100 #else /* No X-windows, character input */
101 #define KBD_BUFFER_SIZE 4096
102 #endif /* No X-windows */
104 #define abs(x) ((x) >= 0 ? (x) : -(x))
106 /* Following definition copied from eval.c */
110 struct backtrace
*next
;
111 Lisp_Object
*function
;
112 Lisp_Object
*args
; /* Points to vector of args. */
113 int nargs
; /* length of vector. If nargs is UNEVALLED,
114 args points to slot holding list of
120 KBOARD
*initial_kboard
;
121 KBOARD
*current_kboard
;
125 KBOARD the_only_kboard
;
128 /* Non-nil disable property on a command means
129 do not execute it; call disabled-command-hook's value instead. */
130 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
132 #define NUM_RECENT_KEYS (100)
133 int recent_keys_index
; /* Index for storing next element into recent_keys */
134 int total_keys
; /* Total number of elements stored into recent_keys */
135 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
137 /* Vector holding the key sequence that invoked the current command.
138 It is reused for each command, and it may be longer than the current
139 sequence; this_command_key_count indicates how many elements
140 actually mean something.
141 It's easier to staticpro a single Lisp_Object than an array. */
142 Lisp_Object this_command_keys
;
143 int this_command_key_count
;
145 /* 1 after calling Freset_this_command_lengths.
147 int this_command_key_count_reset
;
149 /* This vector is used as a buffer to record the events that were actually read
150 by read_key_sequence. */
151 Lisp_Object raw_keybuf
;
152 int raw_keybuf_count
;
154 #define GROW_RAW_KEYBUF \
155 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
157 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
159 new = Fmake_vector (make_number (newsize), Qnil); \
160 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
161 raw_keybuf_count * sizeof (Lisp_Object)); \
165 /* Number of elements of this_command_keys
166 that precede this key sequence. */
167 int this_single_command_key_start
;
169 /* Record values of this_command_key_count and echo_length ()
170 before this command was read. */
171 static int before_command_key_count
;
172 static int before_command_echo_length
;
174 extern int minbuf_level
;
176 extern int message_enable_multibyte
;
178 extern struct backtrace
*backtrace_list
;
180 /* If non-nil, the function that implements the display of help.
181 It's called with one argument, the help string to display. */
183 Lisp_Object Vshow_help_function
;
185 /* If a string, the message displayed before displaying a help-echo
188 Lisp_Object Vpre_help_message
;
190 /* Nonzero means do menu prompting. */
192 static int menu_prompting
;
194 /* Character to see next line of menu prompt. */
196 static Lisp_Object menu_prompt_more_char
;
198 /* For longjmp to where kbd input is being done. */
200 static jmp_buf getcjmp
;
202 /* True while doing kbd input. */
203 int waiting_for_input
;
205 /* True while displaying for echoing. Delays C-g throwing. */
209 /* Non-null means we can start echoing at the next input pause even
210 though there is something in the echo area. */
212 static struct kboard
*ok_to_echo_at_next_pause
;
214 /* The kboard last echoing, or null for none. Reset to 0 in
215 cancel_echoing. If non-null, and a current echo area message
216 exists, and echo_message_buffer is eq to the current message
217 buffer, we know that the message comes from echo_kboard. */
219 struct kboard
*echo_kboard
;
221 /* The buffer used for echoing. Set in echo_now, reset in
224 Lisp_Object echo_message_buffer
;
226 /* Nonzero means disregard local maps for the menu bar. */
227 static int inhibit_local_menu_bar_menus
;
229 /* Nonzero means C-g should cause immediate error-signal. */
232 /* The user's ERASE setting. */
233 Lisp_Object Vtty_erase_char
;
235 /* Character to recognize as the help char. */
236 Lisp_Object Vhelp_char
;
238 /* List of other event types to recognize as meaning "help". */
239 Lisp_Object Vhelp_event_list
;
241 /* Form to execute when help char is typed. */
242 Lisp_Object Vhelp_form
;
244 /* Command to run when the help character follows a prefix key. */
245 Lisp_Object Vprefix_help_command
;
247 /* List of items that should move to the end of the menu bar. */
248 Lisp_Object Vmenu_bar_final_items
;
250 /* Non-nil means show the equivalent key-binding for
251 any M-x command that has one.
252 The value can be a length of time to show the message for.
253 If the value is non-nil and not a number, we wait 2 seconds. */
254 Lisp_Object Vsuggest_key_bindings
;
256 /* How long to display an echo-area message when the minibuffer is active.
257 If the value is not a number, such messages don't time out. */
258 Lisp_Object Vminibuffer_message_timeout
;
260 /* Character that causes a quit. Normally C-g.
262 If we are running on an ordinary terminal, this must be an ordinary
263 ASCII char, since we want to make it our interrupt character.
265 If we are not running on an ordinary terminal, it still needs to be
266 an ordinary ASCII char. This character needs to be recognized in
267 the input interrupt handler. At this point, the keystroke is
268 represented as a struct input_event, while the desired quit
269 character is specified as a lispy event. The mapping from struct
270 input_events to lispy events cannot run in an interrupt handler,
271 and the reverse mapping is difficult for anything but ASCII
274 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
278 extern Lisp_Object current_global_map
;
279 extern int minibuf_level
;
281 /* If non-nil, this is a map that overrides all other local maps. */
282 Lisp_Object Voverriding_local_map
;
284 /* If non-nil, Voverriding_local_map applies to the menu bar. */
285 Lisp_Object Voverriding_local_map_menu_flag
;
287 /* Keymap that defines special misc events that should
288 be processed immediately at a low level. */
289 Lisp_Object Vspecial_event_map
;
291 /* Current depth in recursive edits. */
292 int command_loop_level
;
294 /* Total number of times command_loop has read a key sequence. */
295 EMACS_INT num_input_keys
;
297 /* Last input character read as a command. */
298 Lisp_Object last_command_char
;
300 /* Last input character read as a command, not counting menus
301 reached by the mouse. */
302 Lisp_Object last_nonmenu_event
;
304 /* Last input character read for any purpose. */
305 Lisp_Object last_input_char
;
307 /* If not Qnil, a list of objects to be read as subsequent command input. */
308 Lisp_Object Vunread_command_events
;
310 /* If not Qnil, a list of objects to be read as subsequent command input
311 including input method processing. */
312 Lisp_Object Vunread_input_method_events
;
314 /* If not Qnil, a list of objects to be read as subsequent command input
315 but NOT including input method processing. */
316 Lisp_Object Vunread_post_input_method_events
;
318 /* If not -1, an event to be read as subsequent command input. */
319 EMACS_INT unread_command_char
;
321 /* If not Qnil, this is a switch-frame event which we decided to put
322 off until the end of a key sequence. This should be read as the
323 next command input, after any unread_command_events.
325 read_key_sequence uses this to delay switch-frame events until the
326 end of the key sequence; Fread_char uses it to put off switch-frame
327 events until a non-ASCII event is acceptable as input. */
328 Lisp_Object unread_switch_frame
;
330 /* A mask of extra modifier bits to put into every keyboard char. */
331 EMACS_INT extra_keyboard_modifiers
;
333 /* Char to use as prefix when a meta character is typed in.
334 This is bound on entry to minibuffer in case ESC is changed there. */
336 Lisp_Object meta_prefix_char
;
338 /* Last size recorded for a current buffer which is not a minibuffer. */
339 static int last_non_minibuf_size
;
341 /* Number of idle seconds before an auto-save and garbage collection. */
342 static Lisp_Object Vauto_save_timeout
;
344 /* Total number of times read_char has returned. */
345 int num_input_events
;
347 /* Total number of times read_char has returned, outside of macros. */
348 EMACS_INT num_nonmacro_input_events
;
350 /* Auto-save automatically when this many characters have been typed
351 since the last time. */
353 static EMACS_INT auto_save_interval
;
355 /* Value of num_nonmacro_input_events as of last auto save. */
359 /* The command being executed by the command loop.
360 Commands may set this, and the value set will be copied into
361 current_kboard->Vlast_command instead of the actual command. */
362 Lisp_Object Vthis_command
;
364 /* This is like Vthis_command, except that commands never set it. */
365 Lisp_Object real_this_command
;
367 /* If the lookup of the command returns a binding, the original
368 command is stored in this-original-command. It is nil otherwise. */
369 Lisp_Object Vthis_original_command
;
371 /* The value of point when the last command was executed. */
372 int last_point_position
;
374 /* The buffer that was current when the last command was started. */
375 Lisp_Object last_point_position_buffer
;
377 /* The frame in which the last input event occurred, or Qmacro if the
378 last event came from a macro. We use this to determine when to
379 generate switch-frame events. This may be cleared by functions
380 like Fselect_frame, to make sure that a switch-frame event is
381 generated by the next character. */
382 Lisp_Object internal_last_event_frame
;
384 /* A user-visible version of the above, intended to allow users to
385 figure out where the last event came from, if the event doesn't
386 carry that information itself (i.e. if it was a character). */
387 Lisp_Object Vlast_event_frame
;
389 /* The timestamp of the last input event we received from the X server.
390 X Windows wants this for selection ownership. */
391 unsigned long last_event_timestamp
;
393 Lisp_Object Qself_insert_command
;
394 Lisp_Object Qforward_char
;
395 Lisp_Object Qbackward_char
;
396 Lisp_Object Qundefined
;
397 Lisp_Object Qtimer_event_handler
;
399 /* read_key_sequence stores here the command definition of the
400 key sequence that it reads. */
401 Lisp_Object read_key_sequence_cmd
;
403 /* Echo unfinished commands after this many seconds of pause. */
404 Lisp_Object Vecho_keystrokes
;
406 /* Form to evaluate (if non-nil) when Emacs is started. */
407 Lisp_Object Vtop_level
;
409 /* User-supplied table to translate input characters. */
410 Lisp_Object Vkeyboard_translate_table
;
412 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
413 extern Lisp_Object Vfunction_key_map
;
415 /* Another keymap that maps key sequences into key sequences.
416 This one takes precedence over ordinary definitions. */
417 extern Lisp_Object Vkey_translation_map
;
419 /* If non-nil, this implements the current input method. */
420 Lisp_Object Vinput_method_function
;
421 Lisp_Object Qinput_method_function
;
423 /* When we call Vinput_method_function,
424 this holds the echo area message that was just erased. */
425 Lisp_Object Vinput_method_previous_message
;
427 /* Non-nil means deactivate the mark at end of this command. */
428 Lisp_Object Vdeactivate_mark
;
430 /* Menu bar specified in Lucid Emacs fashion. */
432 Lisp_Object Vlucid_menu_bar_dirty_flag
;
433 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
435 Lisp_Object Qecho_area_clear_hook
;
437 /* Hooks to run before and after each command. */
438 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
439 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
440 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
441 /* Hook run after a command if there's no more input soon. */
442 Lisp_Object Qpost_command_idle_hook
, Vpost_command_idle_hook
;
444 /* Delay time in microseconds before running post-command-idle-hook. */
445 EMACS_INT post_command_idle_delay
;
447 /* List of deferred actions to be performed at a later time.
448 The precise format isn't relevant here; we just check whether it is nil. */
449 Lisp_Object Vdeferred_action_list
;
451 /* Function to call to handle deferred actions, when there are any. */
452 Lisp_Object Vdeferred_action_function
;
453 Lisp_Object Qdeferred_action_function
;
455 Lisp_Object Qinput_method_exit_on_first_char
;
456 Lisp_Object Qinput_method_use_echo_area
;
458 /* File in which we write all commands we read. */
461 /* Nonzero if input is available. */
464 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
465 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
469 /* Non-zero means force key bindings update in parse_menu_item. */
471 int update_menu_bindings
;
473 extern char *pending_malloc_warning
;
475 /* Circular buffer for pre-read keyboard input. */
477 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
479 /* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
481 The interrupt-level event handlers will never enqueue an event on a
482 frame which is not in Vframe_list, and once an event is dequeued,
483 internal_last_event_frame or the event itself points to the frame.
486 But while the event is sitting in the queue, it's completely
487 unprotected. Suppose the user types one command which will run for
488 a while and then delete a frame, and then types another event at
489 the frame that will be deleted, before the command gets around to
490 it. Suppose there are no references to this frame elsewhere in
491 Emacs, and a GC occurs before the second event is dequeued. Now we
492 have an event referring to a freed frame, which will crash Emacs
495 Similar things happen when an event on a scroll bar is enqueued; the
496 window may be deleted while the event is in the queue.
498 So, we use this vector to protect the Lisp_Objects in the event
499 queue. That way, they'll be dequeued as dead frames or windows,
500 but still valid Lisp objects.
502 If kbd_buffer[i].kind != NO_EVENT, then
504 AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
505 AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
507 static Lisp_Object kbd_buffer_gcpro
;
509 /* Pointer to next available character in kbd_buffer.
510 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
511 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
512 next available char is in kbd_buffer[0]. */
513 static struct input_event
*kbd_fetch_ptr
;
515 /* Pointer to next place to store character in kbd_buffer. This
516 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
517 character should go in kbd_buffer[0]. */
518 static struct input_event
* volatile kbd_store_ptr
;
520 /* The above pair of variables forms a "queue empty" flag. When we
521 enqueue a non-hook event, we increment kbd_store_ptr. When we
522 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
523 there is input available iff the two pointers are not equal.
525 Why not just have a flag set and cleared by the enqueuing and
526 dequeuing functions? Such a flag could be screwed up by interrupts
527 at inopportune times. */
529 /* If this flag is non-nil, we check mouse_moved to see when the
530 mouse moves, and motion events will appear in the input stream.
531 Otherwise, mouse motion is ignored. */
532 Lisp_Object do_mouse_tracking
;
534 /* Symbols to head events. */
535 Lisp_Object Qmouse_movement
;
536 Lisp_Object Qscroll_bar_movement
;
537 Lisp_Object Qswitch_frame
;
538 Lisp_Object Qdelete_frame
;
539 Lisp_Object Qiconify_frame
;
540 Lisp_Object Qmake_frame_visible
;
541 Lisp_Object Qselect_window
;
542 Lisp_Object Qhelp_echo
;
544 /* Symbols to denote kinds of events. */
545 Lisp_Object Qfunction_key
;
546 Lisp_Object Qmouse_click
;
548 Lisp_Object Qlanguage_change
;
550 Lisp_Object Qdrag_n_drop
;
551 Lisp_Object Qsave_session
;
553 /* Lisp_Object Qmouse_movement; - also an event header */
555 /* Properties of event headers. */
556 Lisp_Object Qevent_kind
;
557 Lisp_Object Qevent_symbol_elements
;
559 /* menu item parts */
560 Lisp_Object Qmenu_alias
;
561 Lisp_Object Qmenu_enable
;
562 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
563 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
564 extern Lisp_Object Vdefine_key_rebound_commands
;
565 extern Lisp_Object Qmenu_item
;
567 /* An event header symbol HEAD may have a property named
568 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
569 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
570 mask of modifiers applied to it. If present, this is used to help
571 speed up parse_modifiers. */
572 Lisp_Object Qevent_symbol_element_mask
;
574 /* An unmodified event header BASE may have a property named
575 Qmodifier_cache, which is an alist mapping modifier masks onto
576 modified versions of BASE. If present, this helps speed up
578 Lisp_Object Qmodifier_cache
;
580 /* Symbols to use for parts of windows. */
581 Lisp_Object Qmode_line
;
582 Lisp_Object Qvertical_line
;
583 Lisp_Object Qvertical_scroll_bar
;
584 Lisp_Object Qmenu_bar
;
585 extern Lisp_Object Qleft_margin
, Qright_margin
;
586 extern Lisp_Object Qleft_fringe
, Qright_fringe
;
587 extern Lisp_Object Qimage
;
589 Lisp_Object
recursive_edit_unwind (), command_loop ();
590 Lisp_Object
Fthis_command_keys ();
591 Lisp_Object Qextended_command_history
;
592 EMACS_TIME
timer_check ();
594 extern Lisp_Object Vhistory_length
, Vtranslation_table_for_input
;
596 extern char *x_get_keysym_name ();
598 static void record_menu_key ();
599 static int echo_length ();
601 Lisp_Object Qpolling_period
;
603 /* List of absolute timers. Appears in order of next scheduled event. */
604 Lisp_Object Vtimer_list
;
606 /* List of idle time timers. Appears in order of next scheduled event. */
607 Lisp_Object Vtimer_idle_list
;
609 /* Incremented whenever a timer is run. */
612 extern Lisp_Object Vprint_level
, Vprint_length
;
614 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
616 EMACS_TIME
*input_available_clear_time
;
618 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
619 Default is 1 if INTERRUPT_INPUT is defined. */
622 /* Nonzero while interrupts are temporarily deferred during redisplay. */
623 int interrupts_deferred
;
625 /* Nonzero means use ^S/^Q for flow control. */
628 /* Allow m- file to inhibit use of FIONREAD. */
629 #ifdef BROKEN_FIONREAD
633 /* We are unable to use interrupts if FIONREAD is not available,
634 so flush SIGIO so we won't try. */
641 /* If we support a window system, turn on the code to poll periodically
642 to detect C-g. It isn't actually used when doing interrupt input. */
643 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
644 #define POLL_FOR_INPUT
647 /* After a command is executed, if point is moved into a region that
648 has specific properties (e.g. composition, display), we adjust
649 point to the boundary of the region. But, if a command sets this
650 variable to non-nil, we suppress this point adjustment. This
651 variable is set to nil before reading a command. */
653 Lisp_Object Vdisable_point_adjustment
;
655 /* If non-nil, always disable point adjustment. */
657 Lisp_Object Vglobal_disable_point_adjustment
;
659 /* The time when Emacs started being idle. */
661 static EMACS_TIME timer_idleness_start_time
;
663 /* After Emacs stops being idle, this saves the last value
664 of timer_idleness_start_time from when it was idle. */
666 static EMACS_TIME timer_last_idleness_start_time
;
669 /* Global variable declarations. */
671 /* Function for init_keyboard to call with no args (if nonzero). */
672 void (*keyboard_init_hook
) ();
674 static int read_avail_input
P_ ((int));
675 static void get_input_pending
P_ ((int *, int));
676 static void get_filtered_input_pending
P_ ((int *, int, int));
677 static int readable_events
P_ ((int));
678 static int readable_filtered_events
P_ ((int, int));
679 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
680 Lisp_Object
, int *));
681 static Lisp_Object
read_char_x_menu_prompt ();
682 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
684 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
686 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
687 enum scroll_bar_part
,
688 Lisp_Object
, Lisp_Object
,
691 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
692 Lisp_Object
, char **,
693 Lisp_Object
*, unsigned));
694 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
695 static int parse_solitary_modifier
P_ ((Lisp_Object
));
696 static int parse_solitary_modifier ();
697 static void save_getcjmp
P_ ((jmp_buf));
698 static void save_getcjmp ();
699 static void restore_getcjmp
P_ ((jmp_buf));
700 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
701 static void clear_event
P_ ((struct input_event
*));
702 static void any_kboard_state
P_ ((void));
703 static SIGTYPE interrupt_signal
P_ ((int signalnum
));
705 /* Nonzero means don't try to suspend even if the operating system seems
707 static int cannot_suspend
;
709 /* Install the string STR as the beginning of the string of echoing,
710 so that it serves as a prompt for the next character.
711 Also start echoing. */
717 current_kboard
->echo_string
= str
;
718 current_kboard
->echo_after_prompt
= SCHARS (str
);
722 /* Add C to the echo string, if echoing is going on.
723 C can be a character, which is printed prettily ("M-C-x" and all that
724 jazz), or a symbol, whose name is printed. */
730 if (current_kboard
->immediate_echo
)
732 int size
= KEY_DESCRIPTION_SIZE
+ 100;
733 char *buffer
= (char *) alloca (size
);
735 Lisp_Object echo_string
;
737 echo_string
= current_kboard
->echo_string
;
739 /* If someone has passed us a composite event, use its head symbol. */
744 ptr
= push_key_description (XINT (c
), ptr
, 1);
746 else if (SYMBOLP (c
))
748 Lisp_Object name
= SYMBOL_NAME (c
);
749 int nbytes
= SBYTES (name
);
751 if (size
- (ptr
- buffer
) < nbytes
)
753 int offset
= ptr
- buffer
;
754 size
= max (2 * size
, size
+ nbytes
);
755 buffer
= (char *) alloca (size
);
756 ptr
= buffer
+ offset
;
759 ptr
+= copy_text (SDATA (name
), ptr
, nbytes
,
760 STRING_MULTIBYTE (name
), 1);
763 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
766 const char *text
= " (Type ? for further options)";
767 int len
= strlen (text
);
769 if (size
- (ptr
- buffer
) < len
)
771 int offset
= ptr
- buffer
;
773 buffer
= (char *) alloca (size
);
774 ptr
= buffer
+ offset
;
777 bcopy (text
, ptr
, len
);
781 /* Replace a dash from echo_dash with a space, otherwise
782 add a space at the end as a separator between keys. */
783 if (STRINGP (echo_string
)
784 && SCHARS (echo_string
) > 1)
786 Lisp_Object last_char
, prev_char
, idx
;
788 idx
= make_number (SCHARS (echo_string
) - 2);
789 prev_char
= Faref (echo_string
, idx
);
791 idx
= make_number (SCHARS (echo_string
) - 1);
792 last_char
= Faref (echo_string
, idx
);
794 /* We test PREV_CHAR to make sure this isn't the echoing
796 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
797 Faset (echo_string
, idx
, make_number (' '));
799 echo_string
= concat2 (echo_string
, build_string (" "));
802 current_kboard
->echo_string
803 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
809 /* Temporarily add a dash to the end of the echo string if it's not
810 empty, so that it serves as a mini-prompt for the very next character. */
815 /* Do nothing if not echoing at all. */
816 if (NILP (current_kboard
->echo_string
))
819 if (!current_kboard
->immediate_echo
820 && SCHARS (current_kboard
->echo_string
) == 0)
823 /* Do nothing if we just printed a prompt. */
824 if (current_kboard
->echo_after_prompt
825 == SCHARS (current_kboard
->echo_string
))
828 /* Put a dash at the end of the buffer temporarily,
829 but make it go away when the next character is added. */
830 current_kboard
->echo_string
= concat2 (current_kboard
->echo_string
,
835 /* Display the current echo string, and begin echoing if not already
841 if (!current_kboard
->immediate_echo
)
844 current_kboard
->immediate_echo
= 1;
846 for (i
= 0; i
< this_command_key_count
; i
++)
850 /* Set before_command_echo_length to the value that would
851 have been saved before the start of this subcommand in
852 command_loop_1, if we had already been echoing then. */
853 if (i
== this_single_command_key_start
)
854 before_command_echo_length
= echo_length ();
856 c
= XVECTOR (this_command_keys
)->contents
[i
];
857 if (! (EVENT_HAS_PARAMETERS (c
)
858 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
862 /* Set before_command_echo_length to the value that would
863 have been saved before the start of this subcommand in
864 command_loop_1, if we had already been echoing then. */
865 if (this_command_key_count
== this_single_command_key_start
)
866 before_command_echo_length
= echo_length ();
868 /* Put a dash at the end to invite the user to type more. */
873 message3_nolog (current_kboard
->echo_string
,
874 SBYTES (current_kboard
->echo_string
),
875 STRING_MULTIBYTE (current_kboard
->echo_string
));
878 /* Record in what buffer we echoed, and from which kboard. */
879 echo_message_buffer
= echo_area_buffer
[0];
880 echo_kboard
= current_kboard
;
882 if (waiting_for_input
&& !NILP (Vquit_flag
))
883 quit_throw_to_read_char ();
886 /* Turn off echoing, for the start of a new command. */
891 current_kboard
->immediate_echo
= 0;
892 current_kboard
->echo_after_prompt
= -1;
893 current_kboard
->echo_string
= Qnil
;
894 ok_to_echo_at_next_pause
= NULL
;
896 echo_message_buffer
= Qnil
;
899 /* Return the length of the current echo string. */
904 return (STRINGP (current_kboard
->echo_string
)
905 ? SCHARS (current_kboard
->echo_string
)
909 /* Truncate the current echo message to its first LEN chars.
910 This and echo_char get used by read_key_sequence when the user
911 switches frames while entering a key sequence. */
914 echo_truncate (nchars
)
917 if (STRINGP (current_kboard
->echo_string
))
918 current_kboard
->echo_string
919 = Fsubstring (current_kboard
->echo_string
,
920 make_number (0), make_number (nchars
));
921 truncate_echo_area (nchars
);
925 /* Functions for manipulating this_command_keys. */
927 add_command_key (key
)
930 #if 0 /* Not needed after we made Freset_this_command_lengths
931 do the job immediately. */
932 /* If reset-this-command-length was called recently, obey it now.
933 See the doc string of that function for an explanation of why. */
934 if (before_command_restore_flag
)
936 this_command_key_count
= before_command_key_count_1
;
937 if (this_command_key_count
< this_single_command_key_start
)
938 this_single_command_key_start
= this_command_key_count
;
939 echo_truncate (before_command_echo_length_1
);
940 before_command_restore_flag
= 0;
944 if (this_command_key_count
>= ASIZE (this_command_keys
))
945 this_command_keys
= larger_vector (this_command_keys
,
946 2 * ASIZE (this_command_keys
),
949 AREF (this_command_keys
, this_command_key_count
) = key
;
950 ++this_command_key_count
;
957 int count
= SPECPDL_INDEX ();
960 if (command_loop_level
> 0)
962 specbind (Qstandard_output
, Qt
);
963 specbind (Qstandard_input
, Qt
);
966 #ifdef HAVE_X_WINDOWS
967 /* The command loop has started an hourglass timer, so we have to
968 cancel it here, otherwise it will fire because the recursive edit
969 can take some time. Do not check for display_hourglass_p here,
970 because it could already be nil. */
974 /* This function may have been called from a debugger called from
975 within redisplay, for instance by Edebugging a function called
976 from fontification-functions. We want to allow redisplay in
977 the debugging session.
979 The recursive edit is left with a `(throw exit ...)'. The `exit'
980 tag is not caught anywhere in redisplay, i.e. when we leave the
981 recursive edit, the original redisplay leading to the recursive
982 edit will be unwound. The outcome should therefore be safe. */
983 specbind (Qinhibit_redisplay
, Qnil
);
986 val
= command_loop ();
988 Fsignal (Qquit
, Qnil
);
989 /* Handle throw from read_minibuf when using minibuffer
990 while it's active but we're in another window. */
992 Fsignal (Qerror
, Fcons (val
, Qnil
));
994 return unbind_to (count
, Qnil
);
997 /* When an auto-save happens, record the "time", and don't do again soon. */
1002 last_auto_save
= num_nonmacro_input_events
;
1005 /* Make an auto save happen as soon as possible at command level. */
1008 force_auto_save_soon ()
1010 last_auto_save
= - auto_save_interval
- 1;
1012 record_asynch_buffer_change ();
1015 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
1016 doc
: /* Invoke the editor command loop recursively.
1017 To get out of the recursive edit, a command can do `(throw 'exit nil)';
1018 that tells this function to return.
1019 Alternately, `(throw 'exit t)' makes this function signal an error.
1020 This function is called by the editor initialization to begin editing. */)
1023 int count
= SPECPDL_INDEX ();
1026 command_loop_level
++;
1027 update_mode_lines
= 1;
1029 if (command_loop_level
1030 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
1031 buffer
= Fcurrent_buffer ();
1035 /* If we leave recursive_edit_1 below with a `throw' for instance,
1036 like it is done in the splash screen display, we have to
1037 make sure that we restore single_kboard as command_loop_1
1038 would have done if it were left normally. */
1039 record_unwind_protect (recursive_edit_unwind
,
1040 Fcons (buffer
, single_kboard
? Qt
: Qnil
));
1042 recursive_edit_1 ();
1043 return unbind_to (count
, Qnil
);
1047 recursive_edit_unwind (info
)
1050 if (BUFFERP (XCAR (info
)))
1051 Fset_buffer (XCAR (info
));
1053 if (NILP (XCDR (info
)))
1054 any_kboard_state ();
1056 single_kboard_state ();
1058 command_loop_level
--;
1059 update_mode_lines
= 1;
1068 #if 0 /* Theory: if there's anything in Vunread_command_events,
1069 it will right away be read by read_key_sequence,
1070 and then if we do switch KBOARDS, it will go into the side
1071 queue then. So we don't need to do anything special here -- rms. */
1072 if (CONSP (Vunread_command_events
))
1074 current_kboard
->kbd_queue
1075 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1076 current_kboard
->kbd_queue_has_data
= 1;
1078 Vunread_command_events
= Qnil
;
1084 /* Switch to the single-kboard state, making current_kboard
1085 the only KBOARD from which further input is accepted. */
1088 single_kboard_state ()
1095 /* Maintain a stack of kboards, so other parts of Emacs
1096 can switch temporarily to the kboard of a given frame
1097 and then revert to the previous status. */
1102 struct kboard_stack
*next
;
1105 static struct kboard_stack
*kboard_stack
;
1108 push_frame_kboard (f
)
1112 struct kboard_stack
*p
1113 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1115 p
->next
= kboard_stack
;
1116 p
->kboard
= current_kboard
;
1119 current_kboard
= FRAME_KBOARD (f
);
1127 struct kboard_stack
*p
= kboard_stack
;
1128 current_kboard
= p
->kboard
;
1129 kboard_stack
= p
->next
;
1134 /* Handle errors that are not handled at inner levels
1135 by printing an error message and returning to the editor command loop. */
1141 Lisp_Object old_level
, old_length
;
1142 char macroerror
[50];
1144 #ifdef HAVE_X_WINDOWS
1145 if (display_hourglass_p
)
1146 cancel_hourglass ();
1149 if (!NILP (executing_macro
))
1151 if (executing_macro_iterations
== 1)
1152 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1154 sprintf (macroerror
, "After %d kbd macro iterations: ",
1155 executing_macro_iterations
);
1160 Vstandard_output
= Qt
;
1161 Vstandard_input
= Qt
;
1162 Vexecuting_macro
= Qnil
;
1163 executing_macro
= Qnil
;
1164 current_kboard
->Vprefix_arg
= Qnil
;
1165 current_kboard
->Vlast_prefix_arg
= Qnil
;
1168 /* Avoid unquittable loop if data contains a circular list. */
1169 old_level
= Vprint_level
;
1170 old_length
= Vprint_length
;
1171 XSETFASTINT (Vprint_level
, 10);
1172 XSETFASTINT (Vprint_length
, 10);
1173 cmd_error_internal (data
, macroerror
);
1174 Vprint_level
= old_level
;
1175 Vprint_length
= old_length
;
1179 Vinhibit_quit
= Qnil
;
1181 any_kboard_state ();
1184 return make_number (0);
1187 /* Take actions on handling an error. DATA is the data that describes
1190 CONTEXT is a C-string containing ASCII characters only which
1191 describes the context in which the error happened. If we need to
1192 generalize CONTEXT to allow multibyte characters, make it a Lisp
1196 cmd_error_internal (data
, context
)
1201 int kill_emacs_p
= 0;
1202 struct frame
*sf
= SELECTED_FRAME ();
1206 clear_message (1, 0);
1208 /* If the window system or terminal frame hasn't been initialized
1209 yet, or we're not interactive, it's best to dump this message out
1210 to stderr and exit. */
1211 if (!sf
->glyphs_initialized_p
1212 /* This is the case of the frame dumped with Emacs, when we're
1213 running under a window system. */
1214 || (!NILP (Vwindow_system
)
1215 && !inhibit_window_system
1216 && FRAME_TERMCAP_P (sf
))
1219 stream
= Qexternal_debugging_output
;
1225 message_log_maybe_newline ();
1230 /* The immediate context is not interesting for Quits,
1231 since they are asyncronous. */
1232 if (EQ (XCAR (data
), Qquit
))
1233 Vsignaling_function
= Qnil
;
1235 print_error_message (data
, stream
, context
, Vsignaling_function
);
1237 Vsignaling_function
= Qnil
;
1239 /* If the window system or terminal frame hasn't been initialized
1240 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1244 Fkill_emacs (make_number (-1));
1248 Lisp_Object
command_loop_1 ();
1249 Lisp_Object
command_loop_2 ();
1250 Lisp_Object
top_level_1 ();
1252 /* Entry to editor-command-loop.
1253 This level has the catches for exiting/returning to editor command loop.
1254 It returns nil to exit recursive edit, t to abort it. */
1259 if (command_loop_level
> 0 || minibuf_level
> 0)
1262 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1263 executing_macro
= Qnil
;
1269 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1270 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1271 executing_macro
= Qnil
;
1273 /* End of file in -batch run causes exit here. */
1279 /* Here we catch errors in execution of commands within the
1280 editing loop, and reenter the editing loop.
1281 When there is an error, cmd_error runs and returns a non-nil
1282 value to us. A value of nil means that command_loop_1 itself
1283 returned due to end of file (or end of kbd macro). */
1288 register Lisp_Object val
;
1291 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1292 while (!NILP (val
));
1300 return Feval (Vtop_level
);
1306 /* On entry to the outer level, run the startup file */
1307 if (!NILP (Vtop_level
))
1308 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1309 else if (!NILP (Vpurify_flag
))
1310 message ("Bare impure Emacs (standard Lisp code not loaded)");
1312 message ("Bare Emacs (standard Lisp code not loaded)");
1316 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1317 doc
: /* Exit all recursive editing levels. */)
1320 #ifdef HAVE_X_WINDOWS
1321 if (display_hourglass_p
)
1322 cancel_hourglass ();
1324 return Fthrow (Qtop_level
, Qnil
);
1327 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1328 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1331 if (command_loop_level
> 0 || minibuf_level
> 0)
1332 Fthrow (Qexit
, Qnil
);
1334 error ("No recursive edit is in progress");
1338 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1339 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1342 if (command_loop_level
> 0 || minibuf_level
> 0)
1345 error ("No recursive edit is in progress");
1349 /* This is the actual command reading loop,
1350 sans error-handling encapsulation. */
1352 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1354 void safe_run_hooks
P_ ((Lisp_Object
));
1355 static void adjust_point_for_property
P_ ((int, int));
1357 /* Cancel hourglass from protect_unwind.
1359 #ifdef HAVE_X_WINDOWS
1361 cancel_hourglass_unwind (arg
)
1364 cancel_hourglass ();
1374 Lisp_Object keybuf
[30];
1378 struct buffer
*prev_buffer
= NULL
;
1380 int was_locked
= single_kboard
;
1382 int already_adjusted
;
1384 current_kboard
->Vprefix_arg
= Qnil
;
1385 current_kboard
->Vlast_prefix_arg
= Qnil
;
1386 Vdeactivate_mark
= Qnil
;
1387 waiting_for_input
= 0;
1391 this_command_key_count
= 0;
1392 this_command_key_count_reset
= 0;
1393 this_single_command_key_start
= 0;
1395 if (NILP (Vmemory_full
))
1397 /* Make sure this hook runs after commands that get errors and
1398 throw to top level. */
1399 /* Note that the value cell will never directly contain nil
1400 if the symbol is a local variable. */
1401 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1402 safe_run_hooks (Qpost_command_hook
);
1404 /* If displaying a message, resize the echo area window to fit
1405 that message's size exactly. */
1406 if (!NILP (echo_area_buffer
[0]))
1407 resize_echo_area_exactly ();
1409 if (!NILP (Vdeferred_action_list
))
1410 call0 (Vdeferred_action_function
);
1412 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1414 if (NILP (Vunread_command_events
)
1415 && NILP (Vunread_input_method_events
)
1416 && NILP (Vunread_post_input_method_events
)
1417 && NILP (Vexecuting_macro
)
1418 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1419 safe_run_hooks (Qpost_command_idle_hook
);
1423 Vmemory_full
= Qnil
;
1425 /* Do this after running Vpost_command_hook, for consistency. */
1426 current_kboard
->Vlast_command
= Vthis_command
;
1427 current_kboard
->Vreal_last_command
= real_this_command
;
1431 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1434 /* Make sure the current window's buffer is selected. */
1435 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1436 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1438 /* Display any malloc warning that just came out. Use while because
1439 displaying one warning can cause another. */
1441 while (pending_malloc_warning
)
1442 display_malloc_warning ();
1446 Vdeactivate_mark
= Qnil
;
1448 /* If minibuffer on and echo area in use,
1449 wait a short time and redraw minibuffer. */
1452 && !NILP (echo_area_buffer
[0])
1453 && EQ (minibuf_window
, echo_area_window
)
1454 && NUMBERP (Vminibuffer_message_timeout
))
1456 /* Bind inhibit-quit to t so that C-g gets read in
1457 rather than quitting back to the minibuffer. */
1458 int count
= SPECPDL_INDEX ();
1459 specbind (Qinhibit_quit
, Qt
);
1461 Fsit_for (Vminibuffer_message_timeout
, Qnil
, Qnil
);
1462 /* Clear the echo area. */
1464 safe_run_hooks (Qecho_area_clear_hook
);
1466 unbind_to (count
, Qnil
);
1468 /* If a C-g came in before, treat it as input now. */
1469 if (!NILP (Vquit_flag
))
1472 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1477 alloca (0); /* Cause a garbage collection now */
1478 /* Since we can free the most stuff here. */
1479 #endif /* C_ALLOCA */
1482 /* Select the frame that the last event came from. Usually,
1483 switch-frame events will take care of this, but if some lisp
1484 code swallows a switch-frame event, we'll fix things up here.
1485 Is this a good idea? */
1486 if (FRAMEP (internal_last_event_frame
)
1487 && !EQ (internal_last_event_frame
, selected_frame
))
1488 Fselect_frame (internal_last_event_frame
, Qnil
);
1490 /* If it has changed current-menubar from previous value,
1491 really recompute the menubar from the value. */
1492 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1493 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1494 call0 (Qrecompute_lucid_menubar
);
1496 before_command_key_count
= this_command_key_count
;
1497 before_command_echo_length
= echo_length ();
1499 Vthis_command
= Qnil
;
1500 real_this_command
= Qnil
;
1502 /* Read next key sequence; i gets its length. */
1503 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1506 /* A filter may have run while we were reading the input. */
1507 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1509 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1510 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1514 /* Now we have read a key sequence of length I,
1515 or else I is 0 and we found end of file. */
1517 if (i
== 0) /* End of file -- happens only in */
1518 return Qnil
; /* a kbd macro, at the end. */
1519 /* -1 means read_key_sequence got a menu that was rejected.
1520 Just loop around and read another command. */
1524 this_command_key_count
= 0;
1525 this_command_key_count_reset
= 0;
1526 this_single_command_key_start
= 0;
1530 last_command_char
= keybuf
[i
- 1];
1532 /* If the previous command tried to force a specific window-start,
1533 forget about that, in case this command moves point far away
1534 from that position. But also throw away beg_unchanged and
1535 end_unchanged information in that case, so that redisplay will
1536 update the whole window properly. */
1537 if (!NILP (XWINDOW (selected_window
)->force_start
))
1540 XWINDOW (selected_window
)->force_start
= Qnil
;
1541 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1542 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1545 cmd
= read_key_sequence_cmd
;
1546 if (!NILP (Vexecuting_macro
))
1548 if (!NILP (Vquit_flag
))
1550 Vexecuting_macro
= Qt
;
1551 QUIT
; /* Make some noise. */
1552 /* Will return since macro now empty. */
1556 /* Do redisplay processing after this command except in special
1557 cases identified below. */
1558 prev_buffer
= current_buffer
;
1559 prev_modiff
= MODIFF
;
1560 last_point_position
= PT
;
1561 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1563 /* By default, we adjust point to a boundary of a region that
1564 has such a property that should be treated intangible
1565 (e.g. composition, display). But, some commands will set
1566 this variable differently. */
1567 Vdisable_point_adjustment
= Qnil
;
1569 /* Process filters and timers may have messed with deactivate-mark.
1570 reset it before we execute the command. */
1571 Vdeactivate_mark
= Qnil
;
1573 /* Remap command through active keymaps */
1574 Vthis_original_command
= cmd
;
1578 if (cmd1
= Fcommand_remapping (cmd
), !NILP (cmd1
))
1582 /* Execute the command. */
1584 Vthis_command
= cmd
;
1585 real_this_command
= cmd
;
1586 /* Note that the value cell will never directly contain nil
1587 if the symbol is a local variable. */
1588 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1589 safe_run_hooks (Qpre_command_hook
);
1591 already_adjusted
= 0;
1593 if (NILP (Vthis_command
))
1595 /* nil means key is undefined. */
1597 current_kboard
->defining_kbd_macro
= Qnil
;
1598 update_mode_lines
= 1;
1599 current_kboard
->Vprefix_arg
= Qnil
;
1603 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1605 /* In case we jump to directly_done. */
1606 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1608 /* Recognize some common commands in common situations and
1609 do them directly. */
1610 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1612 struct Lisp_Char_Table
*dp
1613 = window_display_table (XWINDOW (selected_window
));
1614 lose
= FETCH_CHAR (PT_BYTE
);
1616 if (! NILP (Vpost_command_hook
))
1617 /* Put this before calling adjust_point_for_property
1618 so it will only get called once in any case. */
1620 if (current_buffer
== prev_buffer
1621 && last_point_position
!= PT
1622 && NILP (Vdisable_point_adjustment
)
1623 && NILP (Vglobal_disable_point_adjustment
))
1624 adjust_point_for_property (last_point_position
, 0);
1625 already_adjusted
= 1;
1626 if (PT
== last_point_position
+ 1
1628 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1629 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1630 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1631 && (lose
>= 0x20 && lose
< 0x7f)))
1632 : (lose
>= 0x20 && lose
< 0x7f))
1633 /* To extract the case of continuation on
1634 wide-column characters. */
1635 && (WIDTH_BY_CHAR_HEAD (FETCH_BYTE (PT_BYTE
)) == 1)
1636 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1638 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1640 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1642 && !windows_or_buffers_changed
1643 && EQ (current_buffer
->selective_display
, Qnil
)
1644 && !detect_input_pending ()
1645 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1646 && NILP (Vexecuting_macro
))
1647 direct_output_forward_char (1);
1650 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1652 struct Lisp_Char_Table
*dp
1653 = window_display_table (XWINDOW (selected_window
));
1655 lose
= FETCH_CHAR (PT_BYTE
);
1656 if (! NILP (Vpost_command_hook
))
1658 if (current_buffer
== prev_buffer
1659 && last_point_position
!= PT
1660 && NILP (Vdisable_point_adjustment
)
1661 && NILP (Vglobal_disable_point_adjustment
))
1662 adjust_point_for_property (last_point_position
, 0);
1663 already_adjusted
= 1;
1664 if (PT
== last_point_position
- 1
1666 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1667 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1668 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1669 && (lose
>= 0x20 && lose
< 0x7f)))
1670 : (lose
>= 0x20 && lose
< 0x7f))
1671 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1673 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1675 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1677 && !windows_or_buffers_changed
1678 && EQ (current_buffer
->selective_display
, Qnil
)
1679 && !detect_input_pending ()
1680 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1681 && NILP (Vexecuting_macro
))
1682 direct_output_forward_char (-1);
1685 else if (EQ (Vthis_command
, Qself_insert_command
)
1686 /* Try this optimization only on char keystrokes. */
1687 && NATNUMP (last_command_char
)
1688 && CHAR_VALID_P (XFASTINT (last_command_char
), 0))
1691 = translate_char (Vtranslation_table_for_input
,
1692 XFASTINT (last_command_char
), 0, 0, 0);
1694 if (NILP (Vexecuting_macro
)
1695 && !EQ (minibuf_window
, selected_window
))
1697 if (!nonundocount
|| nonundocount
>= 20)
1705 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1707 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1709 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1711 || MODIFF
<= SAVE_MODIFF
1712 || windows_or_buffers_changed
1713 || !EQ (current_buffer
->selective_display
, Qnil
)
1714 || detect_input_pending ()
1715 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1716 || !NILP (Vexecuting_macro
));
1718 value
= internal_self_insert (c
, 0);
1723 if (! NILP (Vpost_command_hook
))
1724 /* Put this before calling adjust_point_for_property
1725 so it will only get called once in any case. */
1728 /* VALUE == 1 when AFTER-CHANGE functions are
1729 installed which is the case most of the time
1730 because FONT-LOCK installs one. */
1731 if (!lose
&& !value
)
1732 direct_output_for_insert (c
);
1737 /* Here for a command that isn't executed directly */
1740 #ifdef HAVE_X_WINDOWS
1741 int scount
= SPECPDL_INDEX ();
1743 if (display_hourglass_p
1744 && NILP (Vexecuting_macro
))
1746 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1752 if (NILP (current_kboard
->Vprefix_arg
))
1754 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1756 #ifdef HAVE_X_WINDOWS
1757 /* Do not check display_hourglass_p here, because
1758 Fcommand_execute could change it, but we should cancel
1759 hourglass cursor anyway.
1760 But don't cancel the hourglass within a macro
1761 just because a command in the macro finishes. */
1762 if (NILP (Vexecuting_macro
))
1763 unbind_to (scount
, Qnil
);
1768 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1770 /* Note that the value cell will never directly contain nil
1771 if the symbol is a local variable. */
1772 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1773 safe_run_hooks (Qpost_command_hook
);
1775 /* If displaying a message, resize the echo area window to fit
1776 that message's size exactly. */
1777 if (!NILP (echo_area_buffer
[0]))
1778 resize_echo_area_exactly ();
1780 if (!NILP (Vdeferred_action_list
))
1781 safe_run_hooks (Qdeferred_action_function
);
1783 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1785 if (NILP (Vunread_command_events
)
1786 && NILP (Vunread_input_method_events
)
1787 && NILP (Vunread_post_input_method_events
)
1788 && NILP (Vexecuting_macro
)
1789 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1790 safe_run_hooks (Qpost_command_idle_hook
);
1793 /* If there is a prefix argument,
1794 1) We don't want Vlast_command to be ``universal-argument''
1795 (that would be dumb), so don't set Vlast_command,
1796 2) we want to leave echoing on so that the prefix will be
1797 echoed as part of this key sequence, so don't call
1799 3) we want to leave this_command_key_count non-zero, so that
1800 read_char will realize that it is re-reading a character, and
1801 not echo it a second time.
1803 If the command didn't actually create a prefix arg,
1804 but is merely a frame event that is transparent to prefix args,
1805 then the above doesn't apply. */
1806 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1808 current_kboard
->Vlast_command
= Vthis_command
;
1809 current_kboard
->Vreal_last_command
= real_this_command
;
1811 this_command_key_count
= 0;
1812 this_command_key_count_reset
= 0;
1813 this_single_command_key_start
= 0;
1816 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1818 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1820 /* We could also call `deactivate'mark'. */
1821 if (EQ (Vtransient_mark_mode
, Qlambda
))
1822 Vtransient_mark_mode
= Qnil
;
1825 current_buffer
->mark_active
= Qnil
;
1826 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1829 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1830 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1835 if (current_buffer
== prev_buffer
1836 && last_point_position
!= PT
1837 && NILP (Vdisable_point_adjustment
)
1838 && NILP (Vglobal_disable_point_adjustment
)
1839 && !already_adjusted
)
1840 adjust_point_for_property (last_point_position
, MODIFF
!= prev_modiff
);
1842 /* Install chars successfully executed in kbd macro. */
1844 if (!NILP (current_kboard
->defining_kbd_macro
)
1845 && NILP (current_kboard
->Vprefix_arg
))
1846 finalize_kbd_macro_chars ();
1850 any_kboard_state ();
1855 extern Lisp_Object Qcomposition
, Qdisplay
;
1857 /* Adjust point to a boundary of a region that has such a property
1858 that should be treated intangible. For the moment, we check
1859 `composition', `display' and `invisible' properties.
1860 LAST_PT is the last position of point. */
1862 extern Lisp_Object Qafter_string
, Qbefore_string
;
1863 extern Lisp_Object get_pos_property
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
));
1866 adjust_point_for_property (last_pt
, modified
)
1871 Lisp_Object val
, overlay
, tmp
;
1872 int check_composition
= 1, check_display
= 1, check_invisible
= 1;
1875 /* FIXME: cycling is probably not necessary because these properties
1876 can't be usefully combined anyway. */
1877 while (check_composition
|| check_display
|| check_invisible
)
1879 if (check_composition
1880 && PT
> BEGV
&& PT
< ZV
1881 && get_property_and_range (PT
, Qcomposition
, &val
, &beg
, &end
, Qnil
)
1882 && COMPOSITION_VALID_P (beg
, end
, val
)
1883 && beg
< PT
/* && end > PT <- It's always the case. */
1884 && (last_pt
<= beg
|| last_pt
>= end
))
1887 SET_PT (PT
< last_pt
? beg
: end
);
1888 check_display
= check_invisible
= 1;
1890 check_composition
= 0;
1892 && PT
> BEGV
&& PT
< ZV
1893 && !NILP (val
= get_char_property_and_overlay
1894 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1895 && display_prop_intangible_p (val
)
1896 && (!OVERLAYP (overlay
)
1897 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1898 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1899 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1900 && beg
< PT
) /* && end > PT <- It's always the case. */
1903 SET_PT (PT
< last_pt
? beg
: end
);
1904 check_composition
= check_invisible
= 1;
1907 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1909 int inv
, ellipsis
= 0;
1912 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1914 && !NILP (val
= get_char_property_and_overlay
1915 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1916 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1918 ellipsis
= ellipsis
|| inv
> 1
1919 || (OVERLAYP (overlay
)
1920 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1921 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1922 tmp
= Fnext_single_char_property_change
1923 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1924 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1927 && !NILP (val
= get_char_property_and_overlay
1928 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1929 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1931 ellipsis
= ellipsis
|| inv
> 1
1932 || (OVERLAYP (overlay
)
1933 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1934 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1935 tmp
= Fprevious_single_char_property_change
1936 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1937 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1940 /* Move away from the inside area. */
1941 if (beg
< PT
&& end
> PT
)
1943 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1944 /* We haven't moved yet (so we don't need to fear
1945 infinite-looping) and we were outside the range
1946 before (so either end of the range still corresponds
1947 to a move in the right direction): pretend we moved
1948 less than we actually did, so that we still have
1949 more freedom below in choosing which end of the range
1951 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1952 /* We either have moved already or the last point
1953 was already in the range: we don't get to choose
1954 which end of the range we have to go to. */
1955 : (PT
< last_pt
? beg
: end
));
1956 check_composition
= check_display
= 1;
1958 xassert (PT
== beg
|| PT
== end
);
1959 /* Pretend the area doesn't exist if the buffer is not
1961 if (!modified
&& !ellipsis
&& beg
< end
)
1963 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1964 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1965 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1966 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1967 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1968 /* We've already moved as far as we can. Trying to go
1969 to the other end would mean moving backwards and thus
1970 could lead to an infinite loop. */
1972 else if (val
= get_pos_property (make_number (PT
),
1974 TEXT_PROP_MEANS_INVISIBLE (val
)
1975 && (val
= get_pos_property
1976 (make_number (PT
== beg
? end
: beg
),
1978 !TEXT_PROP_MEANS_INVISIBLE (val
)))
1979 (check_composition
= check_display
= 1,
1980 SET_PT (PT
== beg
? end
: beg
));
1983 check_invisible
= 0;
1987 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1990 safe_run_hooks_1 (hook
)
1993 return call1 (Vrun_hooks
, Vinhibit_quit
);
1996 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1999 safe_run_hooks_error (data
)
2002 Lisp_Object args
[3];
2003 args
[0] = build_string ("Error in %s: %s");
2004 args
[1] = Vinhibit_quit
;
2007 return Fset (Vinhibit_quit
, Qnil
);
2010 /* If we get an error while running the hook, cause the hook variable
2011 to be nil. Also inhibit quits, so that C-g won't cause the hook
2012 to mysteriously evaporate. */
2015 safe_run_hooks (hook
)
2018 int count
= SPECPDL_INDEX ();
2019 specbind (Qinhibit_quit
, hook
);
2021 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
2023 unbind_to (count
, Qnil
);
2027 /* Number of seconds between polling for input. This is a Lisp
2028 variable that can be bound. */
2030 EMACS_INT polling_period
;
2032 /* Nonzero means polling for input is temporarily suppressed. */
2034 int poll_suppress_count
;
2036 /* Asynchronous timer for polling. */
2038 struct atimer
*poll_timer
;
2041 #ifdef POLL_FOR_INPUT
2043 /* Poll for input, so what we catch a C-g if it comes in. This
2044 function is called from x_make_frame_visible, see comment
2050 if (interrupt_input_blocked
== 0
2051 && !waiting_for_input
)
2052 read_avail_input (0);
2055 /* Timer callback function for poll_timer. TIMER is equal to
2059 poll_for_input (timer
)
2060 struct atimer
*timer
;
2062 if (poll_suppress_count
== 0)
2063 poll_for_input_1 ();
2066 #endif /* POLL_FOR_INPUT */
2068 /* Begin signals to poll for input, if they are appropriate.
2069 This function is called unconditionally from various places. */
2074 #ifdef POLL_FOR_INPUT
2075 if (read_socket_hook
&& !interrupt_input
)
2077 /* Turn alarm handling on unconditionally. It might have
2078 been turned off in process.c. */
2079 turn_on_atimers (1);
2081 /* If poll timer doesn't exist, are we need one with
2082 a different interval, start a new one. */
2083 if (poll_timer
== NULL
2084 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
2086 EMACS_TIME interval
;
2089 cancel_atimer (poll_timer
);
2091 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
2092 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
2093 poll_for_input
, NULL
);
2096 /* Let the timer's callback function poll for input
2097 if this becomes zero. */
2098 --poll_suppress_count
;
2103 /* Nonzero if we are using polling to handle input asynchronously. */
2106 input_polling_used ()
2108 #ifdef POLL_FOR_INPUT
2109 return read_socket_hook
&& !interrupt_input
;
2115 /* Turn off polling. */
2120 #ifdef POLL_FOR_INPUT
2121 if (read_socket_hook
&& !interrupt_input
)
2122 ++poll_suppress_count
;
2126 /* Set the value of poll_suppress_count to COUNT
2127 and start or stop polling accordingly. */
2130 set_poll_suppress_count (count
)
2133 #ifdef POLL_FOR_INPUT
2134 if (count
== 0 && poll_suppress_count
!= 0)
2136 poll_suppress_count
= 1;
2139 else if (count
!= 0 && poll_suppress_count
== 0)
2143 poll_suppress_count
= count
;
2147 /* Bind polling_period to a value at least N.
2148 But don't decrease it. */
2151 bind_polling_period (n
)
2154 #ifdef POLL_FOR_INPUT
2155 int new = polling_period
;
2160 stop_other_atimers (poll_timer
);
2162 specbind (Qpolling_period
, make_number (new));
2163 /* Start a new alarm with the new period. */
2168 /* Apply the control modifier to CHARACTER. */
2174 /* Save the upper bits here. */
2175 int upper
= c
& ~0177;
2179 /* Everything in the columns containing the upper-case letters
2180 denotes a control character. */
2181 if (c
>= 0100 && c
< 0140)
2185 /* Set the shift modifier for a control char
2186 made from a shifted letter. But only for letters! */
2187 if (oc
>= 'A' && oc
<= 'Z')
2188 c
|= shift_modifier
;
2191 /* The lower-case letters denote control characters too. */
2192 else if (c
>= 'a' && c
<= 'z')
2195 /* Include the bits for control and shift
2196 only if the basic ASCII code can't indicate them. */
2200 /* Replace the high bits. */
2201 c
|= (upper
& ~ctrl_modifier
);
2206 /* Display help echo in the echo area.
2208 HELP a string means display that string, HELP nil means clear the
2209 help echo. If HELP is a function, call it with OBJECT and POS as
2210 arguments; the function should return a help string or nil for
2211 none. For all other types of HELP evaluate it to obtain a string.
2213 WINDOW is the window in which the help was generated, if any.
2214 It is nil if not in a window.
2216 If OBJECT is a buffer, POS is the position in the buffer where the
2217 `help-echo' text property was found.
2219 If OBJECT is an overlay, that overlay has a `help-echo' property,
2220 and POS is the position in the overlay's buffer under the mouse.
2222 If OBJECT is a string (an overlay string or a string displayed with
2223 the `display' property). POS is the position in that string under
2226 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2227 echo overwrites a keystroke echo currently displayed in the echo
2230 Note: this function may only be called with HELP nil or a string
2231 from X code running asynchronously. */
2234 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2235 Lisp_Object help
, window
, object
, pos
;
2236 int ok_to_overwrite_keystroke_echo
;
2238 if (!NILP (help
) && !STRINGP (help
))
2240 if (FUNCTIONP (help
))
2242 Lisp_Object args
[4];
2247 help
= safe_call (4, args
);
2250 help
= safe_eval (help
);
2252 if (!STRINGP (help
))
2256 if (STRINGP (help
) || NILP (help
))
2258 if (!NILP (Vshow_help_function
))
2259 call1 (Vshow_help_function
, help
);
2260 else if (/* Don't overwrite minibuffer contents. */
2261 !MINI_WINDOW_P (XWINDOW (selected_window
))
2262 /* Don't overwrite a keystroke echo. */
2263 && (NILP (echo_message_buffer
)
2264 || ok_to_overwrite_keystroke_echo
)
2265 /* Don't overwrite a prompt. */
2266 && !cursor_in_echo_area
)
2270 int count
= SPECPDL_INDEX ();
2272 if (!help_echo_showing_p
)
2273 Vpre_help_message
= current_message ();
2275 specbind (Qmessage_truncate_lines
, Qt
);
2276 message3_nolog (help
, SBYTES (help
),
2277 STRING_MULTIBYTE (help
));
2278 unbind_to (count
, Qnil
);
2280 else if (STRINGP (Vpre_help_message
))
2282 message3_nolog (Vpre_help_message
,
2283 SBYTES (Vpre_help_message
),
2284 STRING_MULTIBYTE (Vpre_help_message
));
2285 Vpre_help_message
= Qnil
;
2291 help_echo_showing_p
= STRINGP (help
);
2297 /* Input of single characters from keyboard */
2299 Lisp_Object
print_help ();
2300 static Lisp_Object
kbd_buffer_get_event ();
2301 static void record_char ();
2304 static jmp_buf wrong_kboard_jmpbuf
;
2307 #define STOP_POLLING \
2308 do { if (! polling_stopped_here) stop_polling (); \
2309 polling_stopped_here = 1; } while (0)
2311 #define RESUME_POLLING \
2312 do { if (polling_stopped_here) start_polling (); \
2313 polling_stopped_here = 0; } while (0)
2315 /* read a character from the keyboard; call the redisplay if needed */
2316 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2317 -1 means do not do redisplay, but do do autosaving.
2320 /* The arguments MAPS and NMAPS are for menu prompting.
2321 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2323 PREV_EVENT is the previous input event, or nil if we are reading
2324 the first event of a key sequence (or not reading a key sequence).
2325 If PREV_EVENT is t, that is a "magic" value that says
2326 not to run input methods, but in other respects to act as if
2327 not reading a key sequence.
2329 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2330 if we used a mouse menu to read the input, or zero otherwise. If
2331 USED_MOUSE_MENU is null, we don't dereference it.
2333 Value is t if we showed a menu and the user rejected it. */
2336 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
2340 Lisp_Object prev_event
;
2341 int *used_mouse_menu
;
2343 volatile Lisp_Object c
;
2345 jmp_buf local_getcjmp
;
2347 volatile int key_already_recorded
= 0;
2348 Lisp_Object tem
, save
;
2349 volatile Lisp_Object previous_echo_area_message
;
2350 volatile Lisp_Object also_record
;
2351 volatile int reread
;
2352 struct gcpro gcpro1
, gcpro2
;
2353 EMACS_TIME last_idle_start
;
2354 int polling_stopped_here
= 0;
2358 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2359 before_command_key_count
= this_command_key_count
;
2360 before_command_echo_length
= echo_length ();
2363 previous_echo_area_message
= Qnil
;
2365 GCPRO2 (c
, previous_echo_area_message
);
2370 if (CONSP (Vunread_post_input_method_events
))
2372 c
= XCAR (Vunread_post_input_method_events
);
2373 Vunread_post_input_method_events
2374 = XCDR (Vunread_post_input_method_events
);
2376 /* Undo what read_char_x_menu_prompt did when it unread
2377 additional keys returned by Fx_popup_menu. */
2379 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2387 if (unread_command_char
!= -1)
2389 XSETINT (c
, unread_command_char
);
2390 unread_command_char
= -1;
2396 if (CONSP (Vunread_command_events
))
2398 c
= XCAR (Vunread_command_events
);
2399 Vunread_command_events
= XCDR (Vunread_command_events
);
2401 /* Undo what read_char_x_menu_prompt did when it unread
2402 additional keys returned by Fx_popup_menu. */
2404 && EQ (XCDR (c
), Qdisabled
)
2405 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2408 /* If the queued event is something that used the mouse,
2409 set used_mouse_menu accordingly. */
2411 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2412 *used_mouse_menu
= 1;
2415 goto reread_for_input_method
;
2418 if (CONSP (Vunread_input_method_events
))
2420 c
= XCAR (Vunread_input_method_events
);
2421 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2423 /* Undo what read_char_x_menu_prompt did when it unread
2424 additional keys returned by Fx_popup_menu. */
2426 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2430 goto reread_for_input_method
;
2433 this_command_key_count_reset
= 0;
2435 if (!NILP (Vexecuting_macro
))
2437 /* We set this to Qmacro; since that's not a frame, nobody will
2438 try to switch frames on us, and the selected window will
2441 Since this event came from a macro, it would be misleading to
2442 leave internal_last_event_frame set to wherever the last
2443 real event came from. Normally, a switch-frame event selects
2444 internal_last_event_frame after each command is read, but
2445 events read from a macro should never cause a new frame to be
2447 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2449 /* Exit the macro if we are at the end.
2450 Also, some things replace the macro with t
2451 to force an early exit. */
2452 if (EQ (Vexecuting_macro
, Qt
)
2453 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
2459 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
2460 if (STRINGP (Vexecuting_macro
)
2461 && (XINT (c
) & 0x80))
2462 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2464 executing_macro_index
++;
2469 if (!NILP (unread_switch_frame
))
2471 c
= unread_switch_frame
;
2472 unread_switch_frame
= Qnil
;
2474 /* This event should make it into this_command_keys, and get echoed
2475 again, so we do not set `reread'. */
2479 /* if redisplay was requested */
2480 if (commandflag
>= 0)
2482 /* If there is pending input, process any events which are not
2483 user-visible, such as X selection_request events. */
2485 || detect_input_pending_run_timers (0))
2486 swallow_events (0); /* may clear input_pending */
2488 /* Redisplay if no pending input. */
2489 while (!input_pending
)
2491 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2492 redisplay_preserve_echo_area (5);
2497 /* Normal case: no input arrived during redisplay. */
2500 /* Input arrived and pre-empted redisplay.
2501 Process any events which are not user-visible. */
2503 /* If that cleared input_pending, try again to redisplay. */
2507 /* Message turns off echoing unless more keystrokes turn it on again.
2509 The code in 20.x for the condition was
2511 1. echo_area_glyphs && *echo_area_glyphs
2512 2. && echo_area_glyphs != current_kboard->echobuf
2513 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2515 (1) means there's a current message displayed
2517 (2) means it's not the message from echoing from the current
2520 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2521 is set to a non-null value. This is done in read_char and it is
2522 set to echo_area_glyphs after a call to echo_char. That means
2523 ok_to_echo_at_next_pause is either null or
2524 current_kboard->echobuf with the appropriate current_kboard at
2527 So, condition (3) means in clear text ok_to_echo_at_next_pause
2528 must be either null, or the current message isn't from echoing at
2529 all, or it's from echoing from a different kboard than the
2532 if (/* There currently is something in the echo area. */
2533 !NILP (echo_area_buffer
[0])
2534 && (/* And it's either not from echoing. */
2535 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2536 /* Or it's an echo from a different kboard. */
2537 || echo_kboard
!= current_kboard
2538 /* Or we explicitly allow overwriting whatever there is. */
2539 || ok_to_echo_at_next_pause
== NULL
))
2544 /* Try reading a character via menu prompting in the minibuf.
2545 Try this before the sit-for, because the sit-for
2546 would do the wrong thing if we are supposed to do
2547 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2548 after a mouse event so don't try a minibuf menu. */
2550 if (nmaps
> 0 && INTERACTIVE
2551 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2552 /* Don't bring up a menu if we already have another event. */
2553 && NILP (Vunread_command_events
)
2554 && unread_command_char
< 0
2555 && !detect_input_pending_run_timers (0))
2557 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2560 key_already_recorded
= 1;
2565 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2566 We will do that below, temporarily for short sections of code,
2567 when appropriate. local_getcjmp must be in effect
2568 around any call to sit_for or kbd_buffer_get_event;
2569 it *must not* be in effect when we call redisplay. */
2571 if (_setjmp (local_getcjmp
))
2573 XSETINT (c
, quit_char
);
2574 internal_last_event_frame
= selected_frame
;
2575 Vlast_event_frame
= internal_last_event_frame
;
2576 /* If we report the quit char as an event,
2577 don't do so more than once. */
2578 if (!NILP (Vinhibit_quit
))
2583 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2584 if (kb
!= current_kboard
)
2586 Lisp_Object link
= kb
->kbd_queue
;
2587 /* We shouldn't get here if we were in single-kboard mode! */
2592 while (CONSP (XCDR (link
)))
2594 if (!NILP (XCDR (link
)))
2598 kb
->kbd_queue
= Fcons (c
, Qnil
);
2600 XSETCDR (link
, Fcons (c
, Qnil
));
2601 kb
->kbd_queue_has_data
= 1;
2602 current_kboard
= kb
;
2603 /* This is going to exit from read_char
2604 so we had better get rid of this frame's stuff. */
2606 longjmp (wrong_kboard_jmpbuf
, 1);
2613 timer_start_idle ();
2615 /* If in middle of key sequence and minibuffer not active,
2616 start echoing if enough time elapses. */
2618 if (minibuf_level
== 0
2619 && !current_kboard
->immediate_echo
2620 && this_command_key_count
> 0
2622 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2623 && NILP (Fzerop (Vecho_keystrokes
))
2624 && (/* No message. */
2625 NILP (echo_area_buffer
[0])
2626 /* Or empty message. */
2627 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2628 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2629 /* Or already echoing from same kboard. */
2630 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2631 /* Or not echoing before and echoing allowed. */
2632 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2636 /* After a mouse event, start echoing right away.
2637 This is because we are probably about to display a menu,
2638 and we don't want to delay before doing so. */
2639 if (EVENT_HAS_PARAMETERS (prev_event
))
2644 double duration
= extract_float (Vecho_keystrokes
);
2645 sec
= (int) duration
;
2646 usec
= (duration
- sec
) * 1000000;
2647 save_getcjmp (save_jump
);
2648 restore_getcjmp (local_getcjmp
);
2649 tem0
= sit_for (sec
, usec
, 1, 1, 0);
2650 restore_getcjmp (save_jump
);
2652 && ! CONSP (Vunread_command_events
))
2657 /* Maybe auto save due to number of keystrokes. */
2659 if (commandflag
!= 0
2660 && auto_save_interval
> 0
2661 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2662 && !detect_input_pending_run_timers (0))
2664 Fdo_auto_save (Qnil
, Qnil
);
2665 /* Hooks can actually change some buffers in auto save. */
2669 /* Try reading using an X menu.
2670 This is never confused with reading using the minibuf
2671 because the recursive call of read_char in read_char_minibuf_menu_prompt
2672 does not pass on any keymaps. */
2674 if (nmaps
> 0 && INTERACTIVE
2675 && !NILP (prev_event
)
2676 && EVENT_HAS_PARAMETERS (prev_event
)
2677 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2678 && !EQ (XCAR (prev_event
), Qtool_bar
)
2679 /* Don't bring up a menu if we already have another event. */
2680 && NILP (Vunread_command_events
)
2681 && unread_command_char
< 0)
2683 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2685 /* Now that we have read an event, Emacs is not idle. */
2691 /* Maybe autosave and/or garbage collect due to idleness. */
2693 if (INTERACTIVE
&& NILP (c
))
2695 int delay_level
, buffer_size
;
2697 /* Slow down auto saves logarithmically in size of current buffer,
2698 and garbage collect while we're at it. */
2699 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2700 last_non_minibuf_size
= Z
- BEG
;
2701 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2703 while (buffer_size
> 64)
2704 delay_level
++, buffer_size
-= buffer_size
>> 2;
2705 if (delay_level
< 4) delay_level
= 4;
2706 /* delay_level is 4 for files under around 50k, 7 at 100k,
2707 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2709 /* Auto save if enough time goes by without input. */
2710 if (commandflag
!= 0
2711 && num_nonmacro_input_events
> last_auto_save
2712 && INTEGERP (Vauto_save_timeout
)
2713 && XINT (Vauto_save_timeout
) > 0)
2717 save_getcjmp (save_jump
);
2718 restore_getcjmp (local_getcjmp
);
2719 tem0
= sit_for (delay_level
* XFASTINT (Vauto_save_timeout
) / 4,
2721 restore_getcjmp (save_jump
);
2724 && ! CONSP (Vunread_command_events
))
2726 Fdo_auto_save (Qnil
, Qnil
);
2728 /* If we have auto-saved and there is still no input
2729 available, garbage collect if there has been enough
2730 consing going on to make it worthwhile. */
2731 if (!detect_input_pending_run_timers (0)
2732 && consing_since_gc
> gc_cons_threshold
/ 2)
2733 Fgarbage_collect ();
2740 /* If this has become non-nil here, it has been set by a timer
2741 or sentinel or filter. */
2742 if (CONSP (Vunread_command_events
))
2744 c
= XCAR (Vunread_command_events
);
2745 Vunread_command_events
= XCDR (Vunread_command_events
);
2748 /* Read something from current KBOARD's side queue, if possible. */
2752 if (current_kboard
->kbd_queue_has_data
)
2754 if (!CONSP (current_kboard
->kbd_queue
))
2756 c
= XCAR (current_kboard
->kbd_queue
);
2757 current_kboard
->kbd_queue
2758 = XCDR (current_kboard
->kbd_queue
);
2759 if (NILP (current_kboard
->kbd_queue
))
2760 current_kboard
->kbd_queue_has_data
= 0;
2761 input_pending
= readable_events (0);
2762 if (EVENT_HAS_PARAMETERS (c
)
2763 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2764 internal_last_event_frame
= XCAR (XCDR (c
));
2765 Vlast_event_frame
= internal_last_event_frame
;
2770 /* If current_kboard's side queue is empty check the other kboards.
2771 If one of them has data that we have not yet seen here,
2772 switch to it and process the data waiting for it.
2774 Note: if the events queued up for another kboard
2775 have already been seen here, and therefore are not a complete command,
2776 the kbd_queue_has_data field is 0, so we skip that kboard here.
2777 That's to avoid an infinite loop switching between kboards here. */
2778 if (NILP (c
) && !single_kboard
)
2781 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2782 if (kb
->kbd_queue_has_data
)
2784 current_kboard
= kb
;
2785 /* This is going to exit from read_char
2786 so we had better get rid of this frame's stuff. */
2788 longjmp (wrong_kboard_jmpbuf
, 1);
2797 /* Finally, we read from the main queue,
2798 and if that gives us something we can't use yet, we put it on the
2799 appropriate side queue and try again. */
2805 /* Actually read a character, waiting if necessary. */
2806 save_getcjmp (save_jump
);
2807 restore_getcjmp (local_getcjmp
);
2808 timer_start_idle ();
2809 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
);
2810 restore_getcjmp (save_jump
);
2813 if (! NILP (c
) && (kb
!= current_kboard
))
2815 Lisp_Object link
= kb
->kbd_queue
;
2818 while (CONSP (XCDR (link
)))
2820 if (!NILP (XCDR (link
)))
2824 kb
->kbd_queue
= Fcons (c
, Qnil
);
2826 XSETCDR (link
, Fcons (c
, Qnil
));
2827 kb
->kbd_queue_has_data
= 1;
2831 current_kboard
= kb
;
2832 /* This is going to exit from read_char
2833 so we had better get rid of this frame's stuff. */
2835 longjmp (wrong_kboard_jmpbuf
, 1);
2840 /* Terminate Emacs in batch mode if at eof. */
2841 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2842 Fkill_emacs (make_number (1));
2846 /* Add in any extra modifiers, where appropriate. */
2847 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2848 || ((extra_keyboard_modifiers
& 0177) < ' '
2849 && (extra_keyboard_modifiers
& 0177) != 0))
2850 XSETINT (c
, make_ctrl_char (XINT (c
)));
2852 /* Transfer any other modifier bits directly from
2853 extra_keyboard_modifiers to c. Ignore the actual character code
2854 in the low 16 bits of extra_keyboard_modifiers. */
2855 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2860 /* Record the last idle start time so that we can reset it
2861 should the next event read be a help-echo. */
2862 last_idle_start
= timer_idleness_start_time
;
2868 if (commandflag
>= 0
2869 && !input_pending
&& !detect_input_pending_run_timers (0))
2877 /* Buffer switch events are only for internal wakeups
2878 so don't show them to the user.
2879 Also, don't record a key if we already did. */
2880 if (BUFFERP (c
) || key_already_recorded
)
2883 /* Process special events within read_char
2884 and loop around to read another event. */
2887 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2892 int was_locked
= single_kboard
;
2894 last_input_char
= c
;
2895 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
2897 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
))
2898 /* We stopped being idle for this event; undo that. This
2899 prevents automatic window selection (under
2900 mouse_autoselect_window from acting as a real input event, for
2901 example banishing the mouse under mouse-avoidance-mode. */
2902 timer_idleness_start_time
= last_idle_start
;
2904 /* Resume allowing input from any kboard, if that was true before. */
2906 any_kboard_state ();
2911 /* Handle things that only apply to characters. */
2914 /* If kbd_buffer_get_event gave us an EOF, return that. */
2918 if ((STRINGP (Vkeyboard_translate_table
)
2919 && SCHARS (Vkeyboard_translate_table
) > (unsigned) XFASTINT (c
))
2920 || (VECTORP (Vkeyboard_translate_table
)
2921 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2922 || (CHAR_TABLE_P (Vkeyboard_translate_table
)
2923 && CHAR_VALID_P (XINT (c
), 0)))
2926 d
= Faref (Vkeyboard_translate_table
, c
);
2927 /* nil in keyboard-translate-table means no translation. */
2933 /* If this event is a mouse click in the menu bar,
2934 return just menu-bar for now. Modify the mouse click event
2935 so we won't do this twice, then queue it up. */
2936 if (EVENT_HAS_PARAMETERS (c
)
2938 && CONSP (EVENT_START (c
))
2939 && CONSP (XCDR (EVENT_START (c
))))
2943 posn
= POSN_BUFFER_POSN (EVENT_START (c
));
2944 /* Handle menu-bar events:
2945 insert the dummy prefix event `menu-bar'. */
2946 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2948 /* Change menu-bar to (menu-bar) as the event "position". */
2949 POSN_BUFFER_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2952 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2957 /* Store these characters into recent_keys, the dribble file if any,
2958 and the keyboard macro being defined, if any. */
2960 if (! NILP (also_record
))
2961 record_char (also_record
);
2963 /* Wipe the echo area.
2964 But first, if we are about to use an input method,
2965 save the echo area contents for it to refer to. */
2967 && ! NILP (Vinput_method_function
)
2968 && (unsigned) XINT (c
) >= ' '
2969 && (unsigned) XINT (c
) != 127
2970 && (unsigned) XINT (c
) < 256)
2972 previous_echo_area_message
= Fcurrent_message ();
2973 Vinput_method_previous_message
= previous_echo_area_message
;
2976 /* Now wipe the echo area, except for help events which do their
2977 own stuff with the echo area. */
2979 || (!(EQ (Qhelp_echo
, XCAR (c
)))
2980 && !(EQ (Qswitch_frame
, XCAR (c
)))))
2982 if (!NILP (echo_area_buffer
[0]))
2983 safe_run_hooks (Qecho_area_clear_hook
);
2984 clear_message (1, 0);
2987 reread_for_input_method
:
2989 /* Pass this to the input method, if appropriate. */
2991 && ! NILP (Vinput_method_function
)
2992 /* Don't run the input method within a key sequence,
2993 after the first event of the key sequence. */
2994 && NILP (prev_event
)
2995 && (unsigned) XINT (c
) >= ' '
2996 && (unsigned) XINT (c
) != 127
2997 && (unsigned) XINT (c
) < 256)
3000 int key_count
, key_count_reset
;
3001 struct gcpro gcpro1
;
3002 int count
= SPECPDL_INDEX ();
3004 /* Save the echo status. */
3005 int saved_immediate_echo
= current_kboard
->immediate_echo
;
3006 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
3007 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
3010 if (before_command_restore_flag
)
3012 this_command_key_count
= before_command_key_count_1
;
3013 if (this_command_key_count
< this_single_command_key_start
)
3014 this_single_command_key_start
= this_command_key_count
;
3015 echo_truncate (before_command_echo_length_1
);
3016 before_command_restore_flag
= 0;
3020 /* Save the this_command_keys status. */
3021 key_count
= this_command_key_count
;
3022 key_count_reset
= this_command_key_count_reset
;
3025 keys
= Fcopy_sequence (this_command_keys
);
3030 /* Clear out this_command_keys. */
3031 this_command_key_count
= 0;
3032 this_command_key_count_reset
= 0;
3034 /* Now wipe the echo area. */
3035 if (!NILP (echo_area_buffer
[0]))
3036 safe_run_hooks (Qecho_area_clear_hook
);
3037 clear_message (1, 0);
3040 /* If we are not reading a key sequence,
3041 never use the echo area. */
3044 specbind (Qinput_method_use_echo_area
, Qt
);
3047 /* Call the input method. */
3048 tem
= call1 (Vinput_method_function
, c
);
3050 tem
= unbind_to (count
, tem
);
3052 /* Restore the saved echoing state
3053 and this_command_keys state. */
3054 this_command_key_count
= key_count
;
3055 this_command_key_count_reset
= key_count_reset
;
3057 this_command_keys
= keys
;
3060 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
3061 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
3062 if (saved_immediate_echo
)
3067 /* The input method can return no events. */
3070 /* Bring back the previous message, if any. */
3071 if (! NILP (previous_echo_area_message
))
3072 message_with_string ("%s", previous_echo_area_message
, 0);
3075 /* It returned one event or more. */
3077 Vunread_post_input_method_events
3078 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
3083 /* Display help if not echoing. */
3084 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3086 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3087 Lisp_Object help
, object
, position
, window
, tem
;
3089 tem
= Fcdr (XCDR (c
));
3092 window
= Fcar (tem
);
3094 object
= Fcar (tem
);
3096 position
= Fcar (tem
);
3098 show_help_echo (help
, window
, object
, position
, 0);
3100 /* We stopped being idle for this event; undo that. */
3101 timer_idleness_start_time
= last_idle_start
;
3105 if (! reread
|| this_command_key_count
== 0
3106 || this_command_key_count_reset
)
3109 /* Don't echo mouse motion events. */
3110 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3111 && NILP (Fzerop (Vecho_keystrokes
))
3112 && ! (EVENT_HAS_PARAMETERS (c
)
3113 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3116 if (! NILP (also_record
))
3117 echo_char (also_record
);
3118 /* Once we reread a character, echoing can happen
3119 the next time we pause to read a new one. */
3120 ok_to_echo_at_next_pause
= current_kboard
;
3123 /* Record this character as part of the current key. */
3124 add_command_key (c
);
3125 if (! NILP (also_record
))
3126 add_command_key (also_record
);
3129 last_input_char
= c
;
3132 /* Process the help character specially if enabled */
3133 if (!NILP (Vhelp_form
) && help_char_p (c
))
3136 count
= SPECPDL_INDEX ();
3138 record_unwind_protect (Fset_window_configuration
,
3139 Fcurrent_window_configuration (Qnil
));
3141 tem0
= Feval (Vhelp_form
);
3143 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3147 c
= read_char (0, 0, 0, Qnil
, 0);
3148 while (BUFFERP (c
));
3149 /* Remove the help from the frame */
3150 unbind_to (count
, Qnil
);
3153 if (EQ (c
, make_number (040)))
3157 c
= read_char (0, 0, 0, Qnil
, 0);
3158 while (BUFFERP (c
));
3167 /* Record a key that came from a mouse menu.
3168 Record it for echoing, for this-command-keys, and so on. */
3174 /* Wipe the echo area. */
3175 clear_message (1, 0);
3180 before_command_key_count
= this_command_key_count
;
3181 before_command_echo_length
= echo_length ();
3184 /* Don't echo mouse motion events. */
3185 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3186 && NILP (Fzerop (Vecho_keystrokes
)))
3190 /* Once we reread a character, echoing can happen
3191 the next time we pause to read a new one. */
3192 ok_to_echo_at_next_pause
= 0;
3195 /* Record this character as part of the current key. */
3196 add_command_key (c
);
3198 /* Re-reading in the middle of a command */
3199 last_input_char
= c
;
3203 /* Return 1 if should recognize C as "the help character". */
3211 if (EQ (c
, Vhelp_char
))
3213 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3214 if (EQ (c
, XCAR (tail
)))
3219 /* Record the input event C in various ways. */
3227 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3229 /* To avoid filling recent_keys with help-echo and mouse-movement
3230 events, we filter out repeated help-echo events, only store the
3231 first and last in a series of mouse-movement events, and don't
3232 store repeated help-echo events which are only separated by
3233 mouse-movement events. */
3235 Lisp_Object ev1
, ev2
, ev3
;
3238 if ((ix1
= recent_keys_index
- 1) < 0)
3239 ix1
= NUM_RECENT_KEYS
- 1;
3240 ev1
= AREF (recent_keys
, ix1
);
3242 if ((ix2
= ix1
- 1) < 0)
3243 ix2
= NUM_RECENT_KEYS
- 1;
3244 ev2
= AREF (recent_keys
, ix2
);
3246 if ((ix3
= ix2
- 1) < 0)
3247 ix3
= NUM_RECENT_KEYS
- 1;
3248 ev3
= AREF (recent_keys
, ix3
);
3250 if (EQ (XCAR (c
), Qhelp_echo
))
3252 /* Don't record `help-echo' in recent_keys unless it shows some help
3253 message, and a different help than the previously recorded
3255 Lisp_Object help
, last_help
;
3257 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3258 if (!STRINGP (help
))
3260 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3261 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3263 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3264 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3265 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3267 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3268 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3269 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3270 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3273 else if (EQ (XCAR (c
), Qmouse_movement
))
3275 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3276 So additional mouse movement events replace the last element. */
3277 Lisp_Object last_window
, window
;
3279 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3280 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3281 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3282 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3283 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3285 ASET (recent_keys
, ix1
, c
);
3291 store_kbd_macro_char (c
);
3296 ASET (recent_keys
, recent_keys_index
, c
);
3297 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3298 recent_keys_index
= 0;
3300 else if (recorded
< 0)
3302 /* We need to remove one or two events from recent_keys.
3303 To do this, we simply put nil at those events and move the
3304 recent_keys_index backwards over those events. Usually,
3305 users will never see those nil events, as they will be
3306 overwritten by the command keys entered to see recent_keys
3309 while (recorded
++ < 0 && total_keys
> 0)
3311 if (total_keys
< NUM_RECENT_KEYS
)
3313 if (--recent_keys_index
< 0)
3314 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3315 ASET (recent_keys
, recent_keys_index
, Qnil
);
3319 num_nonmacro_input_events
++;
3321 /* Write c to the dribble file. If c is a lispy event, write
3322 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3323 If you, dear reader, have a better idea, you've got the source. :-) */
3328 if (XUINT (c
) < 0x100)
3329 putc (XINT (c
), dribble
);
3331 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3335 Lisp_Object dribblee
;
3337 /* If it's a structured event, take the event header. */
3338 dribblee
= EVENT_HEAD (c
);
3340 if (SYMBOLP (dribblee
))
3342 putc ('<', dribble
);
3343 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3344 SBYTES (SYMBOL_NAME (dribblee
)),
3346 putc ('>', dribble
);
3358 struct buffer
*old
= current_buffer
;
3359 Fprinc (object
, Qnil
);
3360 set_buffer_internal (XBUFFER (Vstandard_output
));
3361 call0 (intern ("help-mode"));
3362 set_buffer_internal (old
);
3366 /* Copy out or in the info on where C-g should throw to.
3367 This is used when running Lisp code from within get_char,
3368 in case get_char is called recursively.
3369 See read_process_output. */
3375 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3379 restore_getcjmp (temp
)
3382 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3387 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
3388 of this function. */
3391 tracking_off (old_value
)
3392 Lisp_Object old_value
;
3394 do_mouse_tracking
= old_value
;
3395 if (NILP (old_value
))
3397 /* Redisplay may have been preempted because there was input
3398 available, and it assumes it will be called again after the
3399 input has been processed. If the only input available was
3400 the sort that we have just disabled, then we need to call
3402 if (!readable_events (1))
3404 redisplay_preserve_echo_area (6);
3405 get_input_pending (&input_pending
, 1);
3411 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
3412 doc
: /* Evaluate BODY with mouse movement events enabled.
3413 Within a `track-mouse' form, mouse motion generates input events that
3414 you can read with `read-event'.
3415 Normally, mouse motion is ignored.
3416 usage: (track-mouse BODY ...) */)
3420 int count
= SPECPDL_INDEX ();
3423 record_unwind_protect (tracking_off
, do_mouse_tracking
);
3425 do_mouse_tracking
= Qt
;
3427 val
= Fprogn (args
);
3428 return unbind_to (count
, val
);
3431 /* If mouse has moved on some frame, return one of those frames.
3432 Return 0 otherwise. */
3437 Lisp_Object tail
, frame
;
3439 FOR_EACH_FRAME (tail
, frame
)
3441 if (XFRAME (frame
)->mouse_moved
)
3442 return XFRAME (frame
);
3448 #endif /* HAVE_MOUSE */
3450 /* Low level keyboard/mouse input.
3451 kbd_buffer_store_event places events in kbd_buffer, and
3452 kbd_buffer_get_event retrieves them. */
3454 /* Return true iff there are any events in the queue that read-char
3455 would return. If this returns false, a read-char would block. */
3457 readable_filtered_events (do_timers_now
, filter_events
)
3462 timer_check (do_timers_now
);
3464 /* If the buffer contains only FOCUS_IN_EVENT events,
3465 and FILTER_EVENTS is nonzero, report it as empty. */
3466 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3468 int have_live_event
= 1;
3472 struct input_event
*event
;
3474 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3478 while (have_live_event
&& event
->kind
== FOCUS_IN_EVENT
)
3481 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3483 if (event
== kbd_store_ptr
)
3484 have_live_event
= 0;
3487 if (have_live_event
) return 1;
3491 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3496 if (current_kboard
->kbd_queue_has_data
)
3502 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3503 if (kb
->kbd_queue_has_data
)
3509 /* Return true iff there are any events in the queue that read-char
3510 would return. If this returns false, a read-char would block. */
3512 readable_events (do_timers_now
)
3515 return readable_filtered_events (do_timers_now
, 0);
3518 /* Set this for debugging, to have a way to get out */
3523 event_to_kboard (event
)
3524 struct input_event
*event
;
3527 frame
= event
->frame_or_window
;
3529 frame
= XCAR (frame
);
3530 else if (WINDOWP (frame
))
3531 frame
= WINDOW_FRAME (XWINDOW (frame
));
3533 /* There are still some events that don't set this field.
3534 For now, just ignore the problem.
3535 Also ignore dead frames here. */
3536 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3539 return FRAME_KBOARD (XFRAME (frame
));
3543 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3546 kbd_buffer_store_event (event
)
3547 register struct input_event
*event
;
3549 if (event
->kind
== NO_EVENT
)
3552 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3554 register int c
= event
->code
& 0377;
3556 if (event
->modifiers
& ctrl_modifier
)
3557 c
= make_ctrl_char (c
);
3559 c
|= (event
->modifiers
3560 & (meta_modifier
| alt_modifier
3561 | hyper_modifier
| super_modifier
));
3567 struct input_event
*sp
;
3570 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
3571 kb
!= current_kboard
))
3574 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3575 Fcons (make_number (c
), Qnil
));
3576 kb
->kbd_queue_has_data
= 1;
3577 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3579 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3582 if (event_to_kboard (sp
) == kb
)
3584 sp
->kind
= NO_EVENT
;
3585 sp
->frame_or_window
= Qnil
;
3593 /* If this results in a quit_char being returned to Emacs as
3594 input, set Vlast_event_frame properly. If this doesn't
3595 get returned to Emacs as an event, the next event read
3596 will set Vlast_event_frame again, so this is safe to do. */
3600 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3602 focus
= event
->frame_or_window
;
3603 internal_last_event_frame
= focus
;
3604 Vlast_event_frame
= focus
;
3607 last_event_timestamp
= event
->timestamp
;
3608 interrupt_signal (0 /* dummy */);
3612 if (c
&& c
== stop_character
)
3618 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3619 Just ignore the second one. */
3620 else if (event
->kind
== BUFFER_SWITCH_EVENT
3621 && kbd_fetch_ptr
!= kbd_store_ptr
3622 && kbd_store_ptr
->kind
== BUFFER_SWITCH_EVENT
)
3625 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3626 kbd_store_ptr
= kbd_buffer
;
3628 /* Don't let the very last slot in the buffer become full,
3629 since that would make the two pointers equal,
3630 and that is indistinguishable from an empty buffer.
3631 Discard the event if it would fill the last slot. */
3632 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3636 #if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
3637 prone to assign individual members for other events, in case
3638 the input_event structure is changed. --2000-07-13, gerd. */
3639 struct input_event
*sp
= kbd_store_ptr
;
3640 sp
->kind
= event
->kind
;
3641 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3643 /* We must not use the ordinary copying code for this case,
3644 since `part' is an enum and copying it might not copy enough
3646 bcopy (event
, (char *) sp
, sizeof (*event
));
3651 sp
->code
= event
->code
;
3652 sp
->part
= event
->part
;
3653 sp
->frame_or_window
= event
->frame_or_window
;
3654 sp
->arg
= event
->arg
;
3655 sp
->modifiers
= event
->modifiers
;
3658 sp
->timestamp
= event
->timestamp
;
3661 *kbd_store_ptr
= *event
;
3664 idx
= 2 * (kbd_store_ptr
- kbd_buffer
);
3665 ASET (kbd_buffer_gcpro
, idx
, event
->frame_or_window
);
3666 ASET (kbd_buffer_gcpro
, idx
+ 1, event
->arg
);
3672 /* Generate HELP_EVENT input_events in BUFP which has room for
3673 SIZE events. If there's not enough room in BUFP, ignore this
3676 HELP is the help form.
3678 FRAME is the frame on which the help is generated. OBJECT is the
3679 Lisp object where the help was found (a buffer, a string, an
3680 overlay, or nil if neither from a string nor from a buffer. POS is
3681 the position within OBJECT where the help was found.
3683 Value is the number of input_events generated. */
3686 gen_help_event (bufp
, size
, help
, frame
, window
, object
, pos
)
3687 struct input_event
*bufp
;
3689 Lisp_Object help
, frame
, object
, window
;
3694 bufp
->kind
= HELP_EVENT
;
3695 bufp
->frame_or_window
= frame
;
3697 bufp
->x
= WINDOWP (window
) ? window
: frame
;
3706 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3709 kbd_buffer_store_help_event (frame
, help
)
3710 Lisp_Object frame
, help
;
3712 struct input_event event
;
3714 event
.kind
= HELP_EVENT
;
3715 event
.frame_or_window
= frame
;
3720 kbd_buffer_store_event (&event
);
3724 /* Discard any mouse events in the event buffer by setting them to
3727 discard_mouse_events ()
3729 struct input_event
*sp
;
3730 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3732 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3735 if (sp
->kind
== MOUSE_CLICK_EVENT
3736 || sp
->kind
== WHEEL_EVENT
3738 || sp
->kind
== W32_SCROLL_BAR_CLICK_EVENT
3740 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3742 sp
->kind
= NO_EVENT
;
3748 /* Return non-zero if there are any real events waiting in the event
3749 buffer, not counting `NO_EVENT's.
3751 If DISCARD is non-zero, discard NO_EVENT events at the front of
3752 the input queue, possibly leaving the input queue empty if there
3753 are no real input events. */
3756 kbd_buffer_events_waiting (discard
)
3759 struct input_event
*sp
;
3761 for (sp
= kbd_fetch_ptr
;
3762 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3765 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3772 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3776 /* Clear input event EVENT. */
3780 struct input_event
*event
;
3782 int idx
= 2 * (event
- kbd_buffer
);
3783 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
3784 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
3785 event
->kind
= NO_EVENT
;
3789 /* Read one event from the event buffer, waiting if necessary.
3790 The value is a Lisp object representing the event.
3791 The value is nil for an event that should be ignored,
3792 or that was handled here.
3793 We always read and discard one event. */
3796 kbd_buffer_get_event (kbp
, used_mouse_menu
)
3798 int *used_mouse_menu
;
3807 *kbp
= current_kboard
;
3811 /* Wait until there is input available. */
3814 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3817 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3821 /* If the quit flag is set, then read_char will return
3822 quit_char, so that counts as "available input." */
3823 if (!NILP (Vquit_flag
))
3824 quit_throw_to_read_char ();
3826 /* One way or another, wait until input is available; then, if
3827 interrupt handlers have not read it, read it now. */
3830 wait_for_kbd_input ();
3832 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3836 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3839 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3843 Lisp_Object minus_one
;
3845 XSETINT (minus_one
, -1);
3846 wait_reading_process_input (0, 0, minus_one
, 1);
3848 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3849 /* Pass 1 for EXPECT since we just waited to have input. */
3850 read_avail_input (1);
3852 #endif /* not VMS */
3855 if (CONSP (Vunread_command_events
))
3858 first
= XCAR (Vunread_command_events
);
3859 Vunread_command_events
= XCDR (Vunread_command_events
);
3860 *kbp
= current_kboard
;
3864 /* At this point, we know that there is a readable event available
3865 somewhere. If the event queue is empty, then there must be a
3866 mouse movement enabled and available. */
3867 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3869 struct input_event
*event
;
3871 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3875 last_event_timestamp
= event
->timestamp
;
3878 *kbp
= event_to_kboard (event
);
3880 *kbp
= current_kboard
; /* Better than returning null ptr? */
3882 *kbp
= &the_only_kboard
;
3887 /* These two kinds of events get special handling
3888 and don't actually appear to the command loop.
3889 We return nil for them. */
3890 if (event
->kind
== SELECTION_REQUEST_EVENT
)
3893 struct input_event copy
;
3895 /* Remove it from the buffer before processing it,
3896 since otherwise swallow_events will see it
3897 and process it again. */
3899 kbd_fetch_ptr
= event
+ 1;
3900 input_pending
= readable_events (0);
3901 x_handle_selection_request (©
);
3903 /* We're getting selection request events, but we don't have
3909 else if (event
->kind
== SELECTION_CLEAR_EVENT
)
3912 struct input_event copy
;
3914 /* Remove it from the buffer before processing it. */
3916 kbd_fetch_ptr
= event
+ 1;
3917 input_pending
= readable_events (0);
3918 x_handle_selection_clear (©
);
3920 /* We're getting selection request events, but we don't have
3925 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (MAC_OS)
3926 else if (event
->kind
== DELETE_WINDOW_EVENT
)
3928 /* Make an event (delete-frame (FRAME)). */
3929 obj
= Fcons (event
->frame_or_window
, Qnil
);
3930 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3931 kbd_fetch_ptr
= event
+ 1;
3934 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3935 else if (event
->kind
== ICONIFY_EVENT
)
3937 /* Make an event (iconify-frame (FRAME)). */
3938 obj
= Fcons (event
->frame_or_window
, Qnil
);
3939 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3940 kbd_fetch_ptr
= event
+ 1;
3942 else if (event
->kind
== DEICONIFY_EVENT
)
3944 /* Make an event (make-frame-visible (FRAME)). */
3945 obj
= Fcons (event
->frame_or_window
, Qnil
);
3946 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3947 kbd_fetch_ptr
= event
+ 1;
3950 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
3952 /* The value doesn't matter here; only the type is tested. */
3953 XSETBUFFER (obj
, current_buffer
);
3954 kbd_fetch_ptr
= event
+ 1;
3956 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
3957 || defined (USE_GTK)
3958 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
3960 kbd_fetch_ptr
= event
+ 1;
3961 input_pending
= readable_events (0);
3962 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
3963 x_activate_menubar (XFRAME (event
->frame_or_window
));
3967 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
3969 /* Make an event (language-change (FRAME CHARSET LCID)). */
3970 obj
= Fcons (event
->modifiers
, Qnil
);
3971 obj
= Fcons (event
->code
, obj
);
3972 obj
= Fcons (event
->frame_or_window
, obj
);
3973 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
3974 kbd_fetch_ptr
= event
+ 1;
3977 else if (event
->kind
== SAVE_SESSION_EVENT
)
3979 obj
= Fcons (Qsave_session
, Qnil
);
3980 kbd_fetch_ptr
= event
+ 1;
3982 /* Just discard these, by returning nil.
3983 With MULTI_KBOARD, these events are used as placeholders
3984 when we need to randomly delete events from the queue.
3985 (They shouldn't otherwise be found in the buffer,
3986 but on some machines it appears they do show up
3987 even without MULTI_KBOARD.) */
3988 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3989 mouse events during a popup-menu call. */
3990 else if (event
->kind
== NO_EVENT
)
3991 kbd_fetch_ptr
= event
+ 1;
3992 else if (event
->kind
== HELP_EVENT
)
3994 Lisp_Object object
, position
, help
, frame
, window
;
3996 frame
= event
->frame_or_window
;
3997 object
= event
->arg
;
3998 position
= make_number (event
->code
);
4001 clear_event (event
);
4003 kbd_fetch_ptr
= event
+ 1;
4004 if (!WINDOWP (window
))
4006 obj
= Fcons (Qhelp_echo
,
4007 list5 (frame
, help
, window
, object
, position
));
4009 else if (event
->kind
== FOCUS_IN_EVENT
)
4011 /* Notification of a FocusIn event. The frame receiving the
4012 focus is in event->frame_or_window. Generate a
4013 switch-frame event if necessary. */
4014 Lisp_Object frame
, focus
;
4016 frame
= event
->frame_or_window
;
4017 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4021 if (!EQ (frame
, internal_last_event_frame
)
4022 && !EQ (frame
, selected_frame
))
4023 obj
= make_lispy_switch_frame (frame
);
4024 internal_last_event_frame
= frame
;
4025 kbd_fetch_ptr
= event
+ 1;
4029 /* If this event is on a different frame, return a switch-frame this
4030 time, and leave the event in the queue for next time. */
4034 frame
= event
->frame_or_window
;
4036 frame
= XCAR (frame
);
4037 else if (WINDOWP (frame
))
4038 frame
= WINDOW_FRAME (XWINDOW (frame
));
4040 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
4044 if (! EQ (frame
, internal_last_event_frame
)
4045 && !EQ (frame
, selected_frame
))
4046 obj
= make_lispy_switch_frame (frame
);
4047 internal_last_event_frame
= frame
;
4049 /* If we didn't decide to make a switch-frame event, go ahead
4050 and build a real event from the queue entry. */
4054 obj
= make_lispy_event (event
);
4056 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined(MAC_OS) \
4057 || defined (USE_GTK)
4058 /* If this was a menu selection, then set the flag to inhibit
4059 writing to last_nonmenu_event. Don't do this if the event
4060 we're returning is (menu-bar), though; that indicates the
4061 beginning of the menu sequence, and we might as well leave
4062 that as the `event with parameters' for this selection. */
4064 && !EQ (event
->frame_or_window
, event
->arg
)
4065 && (event
->kind
== MENU_BAR_EVENT
4066 || event
->kind
== TOOL_BAR_EVENT
))
4067 *used_mouse_menu
= 1;
4070 /* Wipe out this event, to catch bugs. */
4071 clear_event (event
);
4072 kbd_fetch_ptr
= event
+ 1;
4077 /* Try generating a mouse motion event. */
4078 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4080 FRAME_PTR f
= some_mouse_moved ();
4081 Lisp_Object bar_window
;
4082 enum scroll_bar_part part
;
4086 *kbp
= current_kboard
;
4087 /* Note that this uses F to determine which display to look at.
4088 If there is no valid info, it does not store anything
4089 so x remains nil. */
4091 (*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 object
= Qnil
;
4983 int textpos
= -1, rx
= -1, ry
= -1;
4984 int dx
= -1, dy
= -1;
4986 /* Set event coordinates to window-relative coordinates
4987 for constructing the Lisp event below. */
4991 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
4993 /* Mode line or header line. Look for a string under
4994 the mouse that may have a `local-map' property. */
4998 posn
= part
== ON_MODE_LINE
? Qmode_line
: Qheader_line
;
5000 string
= mode_line_string (w
, &rx
, &ry
, &dx
, &dy
, part
, &charpos
);
5001 if (STRINGP (string
))
5002 object
= Fcons (string
, make_number (charpos
));
5003 if (w
== XWINDOW (selected_window
))
5006 textpos
= XMARKER (w
->pointm
)->charpos
;
5008 else if (part
== ON_VERTICAL_BORDER
)
5010 posn
= Qvertical_line
;
5014 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5019 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5021 string
= marginal_area_string (w
, &rx
, &ry
, &dx
, &dy
, part
, &charpos
);
5022 if (STRINGP (string
))
5023 object
= Fcons (string
, make_number (charpos
));
5025 else if (part
== ON_LEFT_FRINGE
|| part
== ON_RIGHT_FRINGE
)
5027 posn
= (part
== ON_LEFT_FRINGE
) ? Qleft_fringe
: Qright_fringe
;
5030 if (part
== ON_RIGHT_FRINGE
)
5031 dx
-= (window_box_width (w
, LEFT_MARGIN_AREA
)
5032 + window_box_width (w
, TEXT_AREA
)
5033 + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5034 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5036 else if (!WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
))
5037 dx
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5043 struct display_pos p
;
5045 wx
= max (WINDOW_LEFT_MARGIN_WIDTH (w
), wx
);
5046 buffer_posn_from_coords (w
, &wx
, &wy
, &dx2
, &dy2
, &string
, &p
);
5047 textpos
= CHARPOS (p
.pos
);
5048 if (rx
< 0) rx
= wx
;
5049 if (ry
< 0) ry
= wy
;
5050 if (dx
< 0) dx
= dx2
;
5051 if (dy
< 0) dy
= dy2
;
5055 posn
= make_number (textpos
);
5056 if (STRINGP (string
))
5057 object
= Fcons (string
,
5058 make_number (CHARPOS (p
.string_pos
)));
5059 else if (CONSP (string
) && EQ (XCAR (string
), Qimage
))
5064 extra_info
= Fcons (object
,
5065 Fcons (make_number (textpos
),
5066 Fcons (Fcons (make_number (rx
),
5068 Fcons (Fcons (make_number (dx
),
5074 XSETFRAME (window
, f
);
5079 XSETFASTINT (*x
, 0);
5080 XSETFASTINT (*y
, 0);
5083 return Fcons (window
,
5085 Fcons (Fcons (*x
, *y
),
5086 Fcons (make_number (time
),
5090 /* Given a struct input_event, build the lisp event which represents
5091 it. If EVENT is 0, build a mouse movement event from the mouse
5092 movement buffer, which should have a movement event in it.
5094 Note that events must be passed to this function in the order they
5095 are received; this function stores the location of button presses
5096 in order to build drag events when the button is released. */
5099 make_lispy_event (event
)
5100 struct input_event
*event
;
5104 switch (SWITCH_ENUM_CAST (event
->kind
))
5106 /* A simple keystroke. */
5107 case ASCII_KEYSTROKE_EVENT
:
5109 Lisp_Object lispy_c
;
5110 int c
= event
->code
& 0377;
5111 /* Turn ASCII characters into control characters
5113 if (event
->modifiers
& ctrl_modifier
)
5114 c
= make_ctrl_char (c
);
5116 /* Add in the other modifier bits. We took care of ctrl_modifier
5117 just above, and the shift key was taken care of by the X code,
5118 and applied to control characters by make_ctrl_char. */
5119 c
|= (event
->modifiers
5120 & (meta_modifier
| alt_modifier
5121 | hyper_modifier
| super_modifier
));
5122 /* Distinguish Shift-SPC from SPC. */
5123 if ((event
->code
& 0377) == 040
5124 && event
->modifiers
& shift_modifier
)
5125 c
|= shift_modifier
;
5126 button_down_time
= 0;
5127 XSETFASTINT (lispy_c
, c
);
5131 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5133 Lisp_Object lispy_c
;
5134 int c
= event
->code
;
5136 /* Add in the other modifier bits. We took care of ctrl_modifier
5137 just above, and the shift key was taken care of by the X code,
5138 and applied to control characters by make_ctrl_char. */
5139 c
|= (event
->modifiers
5140 & (meta_modifier
| alt_modifier
5141 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5142 /* What about the `shift' modifier ? */
5143 button_down_time
= 0;
5144 XSETFASTINT (lispy_c
, c
);
5148 /* A function key. The symbol may need to have modifier prefixes
5150 case NON_ASCII_KEYSTROKE_EVENT
:
5151 button_down_time
= 0;
5153 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5154 if (event
->code
== lispy_accent_codes
[i
])
5155 return modify_event_symbol (i
,
5157 Qfunction_key
, Qnil
,
5158 lispy_accent_keys
, &accent_key_syms
,
5159 (sizeof (lispy_accent_keys
)
5160 / sizeof (lispy_accent_keys
[0])));
5164 if (event
->code
>= 0x400 && event
->code
< 0x500)
5165 return modify_event_symbol (event
->code
- 0x400,
5166 event
->modifiers
& ~shift_modifier
,
5167 Qfunction_key
, Qnil
,
5168 lispy_kana_keys
, &func_key_syms
,
5169 (sizeof (lispy_kana_keys
)
5170 / sizeof (lispy_kana_keys
[0])));
5171 #endif /* XK_kana_A */
5174 #ifdef ISO_FUNCTION_KEY_OFFSET
5175 if (event
->code
< FUNCTION_KEY_OFFSET
5176 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5177 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5179 Qfunction_key
, Qnil
,
5180 iso_lispy_function_keys
, &func_key_syms
,
5181 (sizeof (iso_lispy_function_keys
)
5182 / sizeof (iso_lispy_function_keys
[0])));
5185 /* Handle system-specific or unknown keysyms. */
5186 if (event
->code
& (1 << 28)
5187 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5188 || (event
->code
- FUNCTION_KEY_OFFSET
5189 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5190 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5192 /* We need to use an alist rather than a vector as the cache
5193 since we can't make a vector long enuf. */
5194 if (NILP (current_kboard
->system_key_syms
))
5195 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
5196 return modify_event_symbol (event
->code
,
5199 current_kboard
->Vsystem_key_alist
,
5200 0, ¤t_kboard
->system_key_syms
,
5204 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5206 Qfunction_key
, Qnil
,
5207 lispy_function_keys
, &func_key_syms
,
5208 (sizeof (lispy_function_keys
)
5209 / sizeof (lispy_function_keys
[0])));
5212 /* A mouse click. Figure out where it is, decide whether it's
5213 a press, click or drag, and build the appropriate structure. */
5214 case MOUSE_CLICK_EVENT
:
5215 #ifndef USE_TOOLKIT_SCROLL_BARS
5216 case SCROLL_BAR_CLICK_EVENT
:
5219 int button
= event
->code
;
5221 Lisp_Object position
;
5222 Lisp_Object
*start_pos_ptr
;
5223 Lisp_Object start_pos
;
5227 /* Build the position as appropriate for this mouse click. */
5228 if (event
->kind
== MOUSE_CLICK_EVENT
)
5230 struct frame
*f
= XFRAME (event
->frame_or_window
);
5231 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5235 /* Ignore mouse events that were made on frame that
5236 have been deleted. */
5237 if (! FRAME_LIVE_P (f
))
5240 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
5241 /* EVENT->x and EVENT->y are frame-relative pixel
5242 coordinates at this place. Under old redisplay, COLUMN
5243 and ROW are set to frame relative glyph coordinates
5244 which are then used to determine whether this click is
5245 in a menu (non-toolkit version). */
5246 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5247 &column
, &row
, NULL
, 1);
5249 /* In the non-toolkit version, clicks on the menu bar
5250 are ordinary button events in the event buffer.
5251 Distinguish them, and invoke the menu.
5253 (In the toolkit version, the toolkit handles the menu bar
5254 and Emacs doesn't know about it until after the user
5255 makes a selection.) */
5256 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5257 && (event
->modifiers
& down_modifier
))
5259 Lisp_Object items
, item
;
5264 /* Activate the menu bar on the down event. If the
5265 up event comes in before the menu code can deal with it,
5267 if (! (event
->modifiers
& down_modifier
))
5271 /* Find the menu bar item under `column'. */
5273 items
= FRAME_MENU_BAR_ITEMS (f
);
5274 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5276 Lisp_Object pos
, string
;
5277 string
= AREF (items
, i
+ 1);
5278 pos
= AREF (items
, i
+ 3);
5281 if (column
>= XINT (pos
)
5282 && column
< XINT (pos
) + SCHARS (string
))
5284 item
= AREF (items
, i
);
5289 /* ELisp manual 2.4b says (x y) are window relative but
5290 code says they are frame-relative. */
5292 = Fcons (event
->frame_or_window
,
5294 Fcons (Fcons (event
->x
, event
->y
),
5295 Fcons (make_number (event
->timestamp
),
5298 return Fcons (item
, Fcons (position
, Qnil
));
5300 #endif /* not USE_X_TOOLKIT && not USE_GTK */
5302 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5305 #ifndef USE_TOOLKIT_SCROLL_BARS
5308 /* It's a scrollbar click. */
5310 Lisp_Object portion_whole
;
5313 window
= event
->frame_or_window
;
5314 portion_whole
= Fcons (event
->x
, event
->y
);
5315 part
= *scroll_bar_parts
[(int) event
->part
];
5319 Fcons (Qvertical_scroll_bar
,
5320 Fcons (portion_whole
,
5321 Fcons (make_number (event
->timestamp
),
5322 Fcons (part
, Qnil
)))));
5324 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5326 if (button
>= ASIZE (button_down_location
))
5328 button_down_location
= larger_vector (button_down_location
,
5330 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5333 start_pos_ptr
= &AREF (button_down_location
, button
);
5334 start_pos
= *start_pos_ptr
;
5335 *start_pos_ptr
= Qnil
;
5338 /* On window-system frames, use the value of
5339 double-click-fuzz as is. On other frames, interpret it
5340 as a multiple of 1/8 characters. */
5344 if (WINDOWP (event
->frame_or_window
))
5345 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5346 else if (FRAMEP (event
->frame_or_window
))
5347 f
= XFRAME (event
->frame_or_window
);
5351 if (FRAME_WINDOW_P (f
))
5352 fuzz
= double_click_fuzz
;
5354 fuzz
= double_click_fuzz
/ 8;
5356 is_double
= (button
== last_mouse_button
5357 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5358 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5359 && button_down_time
!= 0
5360 && (EQ (Vdouble_click_time
, Qt
)
5361 || (INTEGERP (Vdouble_click_time
)
5362 && ((int)(event
->timestamp
- button_down_time
)
5363 < XINT (Vdouble_click_time
)))));
5366 last_mouse_button
= button
;
5367 last_mouse_x
= XINT (event
->x
);
5368 last_mouse_y
= XINT (event
->y
);
5370 /* If this is a button press, squirrel away the location, so
5371 we can decide later whether it was a click or a drag. */
5372 if (event
->modifiers
& down_modifier
)
5376 double_click_count
++;
5377 event
->modifiers
|= ((double_click_count
> 2)
5382 double_click_count
= 1;
5383 button_down_time
= event
->timestamp
;
5384 *start_pos_ptr
= Fcopy_alist (position
);
5387 /* Now we're releasing a button - check the co-ordinates to
5388 see if this was a click or a drag. */
5389 else if (event
->modifiers
& up_modifier
)
5391 /* If we did not see a down before this up, ignore the up.
5392 Probably this happened because the down event chose a
5393 menu item. It would be an annoyance to treat the
5394 release of the button that chose the menu item as a
5397 if (!CONSP (start_pos
))
5400 event
->modifiers
&= ~up_modifier
;
5401 #if 0 /* Formerly we treated an up with no down as a click event. */
5402 if (!CONSP (start_pos
))
5403 event
->modifiers
|= click_modifier
;
5408 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5410 /* The third element of every position
5411 should be the (x,y) pair. */
5412 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5414 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5416 xdiff
= XFASTINT (event
->x
) - XFASTINT (XCAR (down
));
5417 ydiff
= XFASTINT (event
->y
) - XFASTINT (XCDR (down
));
5420 if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5421 && ydiff
< double_click_fuzz
5422 && ydiff
> - double_click_fuzz
)
5423 /* Mouse hasn't moved (much). */
5424 event
->modifiers
|= click_modifier
;
5427 button_down_time
= 0;
5428 event
->modifiers
|= drag_modifier
;
5431 /* Don't check is_double; treat this as multiple
5432 if the down-event was multiple. */
5433 if (double_click_count
> 1)
5434 event
->modifiers
|= ((double_click_count
> 2)
5440 /* Every mouse event should either have the down_modifier or
5441 the up_modifier set. */
5445 /* Get the symbol we should use for the mouse click. */
5448 head
= modify_event_symbol (button
,
5450 Qmouse_click
, Vlispy_mouse_stem
,
5453 XVECTOR (mouse_syms
)->size
);
5454 if (event
->modifiers
& drag_modifier
)
5459 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5462 Fcons (make_number (double_click_count
),
5473 Lisp_Object position
;
5476 /* Build the position as appropriate for this mouse click. */
5477 struct frame
*f
= XFRAME (event
->frame_or_window
);
5479 /* Ignore wheel events that were made on frame that have been
5481 if (! FRAME_LIVE_P (f
))
5484 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5487 /* Set double or triple modifiers to indicate the wheel speed. */
5489 /* On window-system frames, use the value of
5490 double-click-fuzz as is. On other frames, interpret it
5491 as a multiple of 1/8 characters. */
5496 if (WINDOWP (event
->frame_or_window
))
5497 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5498 else if (FRAMEP (event
->frame_or_window
))
5499 f
= XFRAME (event
->frame_or_window
);
5503 if (FRAME_WINDOW_P (f
))
5504 fuzz
= double_click_fuzz
;
5506 fuzz
= double_click_fuzz
/ 8;
5508 is_double
= (last_mouse_button
< 0
5509 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5510 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5511 && button_down_time
!= 0
5512 && (EQ (Vdouble_click_time
, Qt
)
5513 || (INTEGERP (Vdouble_click_time
)
5514 && ((int)(event
->timestamp
- button_down_time
)
5515 < XINT (Vdouble_click_time
)))));
5518 double_click_count
++;
5519 event
->modifiers
|= ((double_click_count
> 2)
5525 double_click_count
= 1;
5526 event
->modifiers
|= click_modifier
;
5529 button_down_time
= event
->timestamp
;
5530 /* Use a negative value to distinguish wheel from mouse button. */
5531 last_mouse_button
= -1;
5532 last_mouse_x
= XINT (event
->x
);
5533 last_mouse_y
= XINT (event
->y
);
5539 if (event
->modifiers
& up_modifier
)
5541 /* Emit a wheel-up event. */
5542 event
->modifiers
&= ~up_modifier
;
5545 else if (event
->modifiers
& down_modifier
)
5547 /* Emit a wheel-down event. */
5548 event
->modifiers
&= ~down_modifier
;
5552 /* Every wheel event should either have the down_modifier or
5553 the up_modifier set. */
5556 /* Get the symbol we should use for the wheel event. */
5557 head
= modify_event_symbol (symbol_num
,
5563 ASIZE (wheel_syms
));
5566 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5569 Fcons (make_number (double_click_count
),
5578 #ifdef USE_TOOLKIT_SCROLL_BARS
5580 /* We don't have down and up events if using toolkit scroll bars,
5581 so make this always a click event. Store in the `part' of
5582 the Lisp event a symbol which maps to the following actions:
5584 `above_handle' page up
5585 `below_handle' page down
5589 `bottom' bottom of buffer
5590 `handle' thumb has been dragged.
5591 `end-scroll' end of interaction with scroll bar
5593 The incoming input_event contains in its `part' member an
5594 index of type `enum scroll_bar_part' which we can use as an
5595 index in scroll_bar_parts to get the appropriate symbol. */
5597 case SCROLL_BAR_CLICK_EVENT
:
5599 Lisp_Object position
, head
, window
, portion_whole
, part
;
5601 window
= event
->frame_or_window
;
5602 portion_whole
= Fcons (event
->x
, event
->y
);
5603 part
= *scroll_bar_parts
[(int) event
->part
];
5607 Fcons (Qvertical_scroll_bar
,
5608 Fcons (portion_whole
,
5609 Fcons (make_number (event
->timestamp
),
5610 Fcons (part
, Qnil
)))));
5612 /* Always treat scroll bar events as clicks. */
5613 event
->modifiers
|= click_modifier
;
5614 event
->modifiers
&= ~up_modifier
;
5616 if (event
->code
>= ASIZE (mouse_syms
))
5617 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5619 /* Get the symbol we should use for the mouse click. */
5620 head
= modify_event_symbol (event
->code
,
5625 XVECTOR (mouse_syms
)->size
);
5626 return Fcons (head
, Fcons (position
, Qnil
));
5629 #endif /* USE_TOOLKIT_SCROLL_BARS */
5632 case W32_SCROLL_BAR_CLICK_EVENT
:
5634 int button
= event
->code
;
5636 Lisp_Object position
;
5637 Lisp_Object
*start_pos_ptr
;
5638 Lisp_Object start_pos
;
5642 Lisp_Object portion_whole
;
5645 window
= event
->frame_or_window
;
5646 portion_whole
= Fcons (event
->x
, event
->y
);
5647 part
= *scroll_bar_parts
[(int) event
->part
];
5651 Fcons (Qvertical_scroll_bar
,
5652 Fcons (portion_whole
,
5653 Fcons (make_number (event
->timestamp
),
5654 Fcons (part
, Qnil
)))));
5657 /* Always treat W32 scroll bar events as clicks. */
5658 event
->modifiers
|= click_modifier
;
5661 /* Get the symbol we should use for the mouse click. */
5664 head
= modify_event_symbol (button
,
5669 XVECTOR (mouse_syms
)->size
);
5675 #endif /* WINDOWSNT */
5677 case DRAG_N_DROP_EVENT
:
5680 Lisp_Object head
, position
;
5683 /* The frame_or_window field should be a cons of the frame in
5684 which the event occurred and a list of the filenames
5686 if (! CONSP (event
->frame_or_window
))
5689 f
= XFRAME (XCAR (event
->frame_or_window
));
5690 files
= XCDR (event
->frame_or_window
);
5692 /* Ignore mouse events that were made on frames that
5693 have been deleted. */
5694 if (! FRAME_LIVE_P (f
))
5697 position
= make_lispy_position (f
, &event
->x
, &event
->y
,
5700 head
= modify_event_symbol (0, event
->modifiers
,
5702 lispy_drag_n_drop_names
,
5703 &drag_n_drop_syms
, 1);
5709 #endif /* HAVE_MOUSE */
5711 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (MAC_OS) \
5712 || defined (USE_GTK)
5713 case MENU_BAR_EVENT
:
5714 if (EQ (event
->arg
, event
->frame_or_window
))
5715 /* This is the prefix key. We translate this to
5716 `(menu_bar)' because the code in keyboard.c for menu
5717 events, which we use, relies on this. */
5718 return Fcons (Qmenu_bar
, Qnil
);
5722 case SELECT_WINDOW_EVENT
:
5723 /* Make an event (select-window (WINDOW)). */
5724 return Fcons (Qselect_window
,
5725 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5728 case TOOL_BAR_EVENT
:
5729 if (EQ (event
->arg
, event
->frame_or_window
))
5730 /* This is the prefix key. We translate this to
5731 `(tool_bar)' because the code in keyboard.c for tool bar
5732 events, which we use, relies on this. */
5733 return Fcons (Qtool_bar
, Qnil
);
5734 else if (SYMBOLP (event
->arg
))
5735 return apply_modifiers (event
->modifiers
, event
->arg
);
5738 case USER_SIGNAL_EVENT
:
5739 /* A user signal. */
5740 return *lispy_user_signals
[event
->code
];
5742 case SAVE_SESSION_EVENT
:
5743 return Qsave_session
;
5745 /* The 'kind' field of the event is something we don't recognize. */
5754 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
5756 Lisp_Object bar_window
;
5757 enum scroll_bar_part part
;
5761 /* Is it a scroll bar movement? */
5762 if (frame
&& ! NILP (bar_window
))
5764 Lisp_Object part_sym
;
5766 part_sym
= *scroll_bar_parts
[(int) part
];
5767 return Fcons (Qscroll_bar_movement
,
5768 (Fcons (Fcons (bar_window
,
5769 Fcons (Qvertical_scroll_bar
,
5770 Fcons (Fcons (x
, y
),
5771 Fcons (make_number (time
),
5777 /* Or is it an ordinary mouse movement? */
5780 Lisp_Object position
;
5782 position
= make_lispy_position (frame
, &x
, &y
, time
);
5784 return Fcons (Qmouse_movement
,
5790 #endif /* HAVE_MOUSE */
5792 /* Construct a switch frame event. */
5794 make_lispy_switch_frame (frame
)
5797 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
5800 /* Manipulating modifiers. */
5802 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5804 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5805 SYMBOL's name of the end of the modifiers; the string from this
5806 position is the unmodified symbol name.
5808 This doesn't use any caches. */
5811 parse_modifiers_uncached (symbol
, modifier_end
)
5819 CHECK_SYMBOL (symbol
);
5822 name
= SYMBOL_NAME (symbol
);
5824 for (i
= 0; i
+2 <= SBYTES (name
); )
5826 int this_mod_end
= 0;
5829 /* See if the name continues with a modifier word.
5830 Check that the word appears, but don't check what follows it.
5831 Set this_mod and this_mod_end to record what we find. */
5833 switch (SREF (name
, i
))
5835 #define SINGLE_LETTER_MOD(BIT) \
5836 (this_mod_end = i + 1, this_mod = BIT)
5839 SINGLE_LETTER_MOD (alt_modifier
);
5843 SINGLE_LETTER_MOD (ctrl_modifier
);
5847 SINGLE_LETTER_MOD (hyper_modifier
);
5851 SINGLE_LETTER_MOD (meta_modifier
);
5855 SINGLE_LETTER_MOD (shift_modifier
);
5859 SINGLE_LETTER_MOD (super_modifier
);
5862 #undef SINGLE_LETTER_MOD
5864 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
5865 if (i + LEN + 1 <= SBYTES (name) \
5866 && ! strncmp (SDATA (name) + i, NAME, LEN)) \
5868 this_mod_end = i + LEN; \
5873 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
5874 MULTI_LETTER_MOD (down_modifier
, "down", 4);
5875 MULTI_LETTER_MOD (double_modifier
, "double", 6);
5879 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
5881 #undef MULTI_LETTER_MOD
5885 /* If we found no modifier, stop looking for them. */
5886 if (this_mod_end
== 0)
5889 /* Check there is a dash after the modifier, so that it
5890 really is a modifier. */
5891 if (this_mod_end
>= SBYTES (name
)
5892 || SREF (name
, this_mod_end
) != '-')
5895 /* This modifier is real; look for another. */
5896 modifiers
|= this_mod
;
5897 i
= this_mod_end
+ 1;
5900 /* Should we include the `click' modifier? */
5901 if (! (modifiers
& (down_modifier
| drag_modifier
5902 | double_modifier
| triple_modifier
))
5903 && i
+ 7 == SBYTES (name
)
5904 && strncmp (SDATA (name
) + i
, "mouse-", 6) == 0
5905 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
5906 modifiers
|= click_modifier
;
5914 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5915 prepended to the string BASE[0..BASE_LEN-1].
5916 This doesn't use any caches. */
5918 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
5921 int base_len
, base_len_byte
;
5923 /* Since BASE could contain nulls, we can't use intern here; we have
5924 to use Fintern, which expects a genuine Lisp_String, and keeps a
5927 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
5933 /* Only the event queue may use the `up' modifier; it should always
5934 be turned into a click or drag event before presented to lisp code. */
5935 if (modifiers
& up_modifier
)
5938 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
5939 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
5940 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
5941 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
5942 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
5943 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
5944 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
5945 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
5946 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
5947 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
5948 /* The click modifier is denoted by the absence of other modifiers. */
5952 mod_len
= p
- new_mods
;
5956 Lisp_Object new_name
;
5958 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
5959 mod_len
+ base_len_byte
);
5960 bcopy (new_mods
, SDATA (new_name
), mod_len
);
5961 bcopy (base
, SDATA (new_name
) + mod_len
, base_len_byte
);
5963 return Fintern (new_name
, Qnil
);
5968 static char *modifier_names
[] =
5970 "up", "down", "drag", "click", "double", "triple", 0, 0,
5971 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5972 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
5974 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
5976 static Lisp_Object modifier_symbols
;
5978 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
5980 lispy_modifier_list (modifiers
)
5983 Lisp_Object modifier_list
;
5986 modifier_list
= Qnil
;
5987 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
5988 if (modifiers
& (1<<i
))
5989 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
5992 return modifier_list
;
5996 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
5997 where UNMODIFIED is the unmodified form of SYMBOL,
5998 MASK is the set of modifiers present in SYMBOL's name.
5999 This is similar to parse_modifiers_uncached, but uses the cache in
6000 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6001 Qevent_symbol_elements property. */
6004 parse_modifiers (symbol
)
6007 Lisp_Object elements
;
6009 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6010 if (CONSP (elements
))
6015 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6016 Lisp_Object unmodified
;
6019 unmodified
= Fintern (make_string (SDATA (SYMBOL_NAME (symbol
)) + end
,
6020 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6023 if (modifiers
& ~INTMASK
)
6025 XSETFASTINT (mask
, modifiers
);
6026 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6028 /* Cache the parsing results on SYMBOL. */
6029 Fput (symbol
, Qevent_symbol_element_mask
,
6031 Fput (symbol
, Qevent_symbol_elements
,
6032 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6034 /* Since we know that SYMBOL is modifiers applied to unmodified,
6035 it would be nice to put that in unmodified's cache.
6036 But we can't, since we're not sure that parse_modifiers is
6043 /* Apply the modifiers MODIFIERS to the symbol BASE.
6044 BASE must be unmodified.
6046 This is like apply_modifiers_uncached, but uses BASE's
6047 Qmodifier_cache property, if present. It also builds
6048 Qevent_symbol_elements properties, since it has that info anyway.
6050 apply_modifiers copies the value of BASE's Qevent_kind property to
6051 the modified symbol. */
6053 apply_modifiers (modifiers
, base
)
6057 Lisp_Object cache
, index
, entry
, new_symbol
;
6059 /* Mask out upper bits. We don't know where this value's been. */
6060 modifiers
&= INTMASK
;
6062 /* The click modifier never figures into cache indices. */
6063 cache
= Fget (base
, Qmodifier_cache
);
6064 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
6065 entry
= assq_no_quit (index
, cache
);
6068 new_symbol
= XCDR (entry
);
6071 /* We have to create the symbol ourselves. */
6072 new_symbol
= apply_modifiers_uncached (modifiers
,
6073 SDATA (SYMBOL_NAME (base
)),
6074 SCHARS (SYMBOL_NAME (base
)),
6075 SBYTES (SYMBOL_NAME (base
)));
6077 /* Add the new symbol to the base's cache. */
6078 entry
= Fcons (index
, new_symbol
);
6079 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6081 /* We have the parsing info now for free, so we could add it to
6083 XSETFASTINT (index, modifiers);
6084 Fput (new_symbol, Qevent_symbol_element_mask,
6085 Fcons (base, Fcons (index, Qnil)));
6086 Fput (new_symbol, Qevent_symbol_elements,
6087 Fcons (base, lispy_modifier_list (modifiers)));
6088 Sadly, this is only correct if `base' is indeed a base event,
6089 which is not necessarily the case. -stef */
6092 /* Make sure this symbol is of the same kind as BASE.
6094 You'd think we could just set this once and for all when we
6095 intern the symbol above, but reorder_modifiers may call us when
6096 BASE's property isn't set right; we can't assume that just
6097 because it has a Qmodifier_cache property it must have its
6098 Qevent_kind set right as well. */
6099 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6103 kind
= Fget (base
, Qevent_kind
);
6105 Fput (new_symbol
, Qevent_kind
, kind
);
6112 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6113 return a symbol with the modifiers placed in the canonical order.
6114 Canonical order is alphabetical, except for down and drag, which
6115 always come last. The 'click' modifier is never written out.
6117 Fdefine_key calls this to make sure that (for example) C-M-foo
6118 and M-C-foo end up being equivalent in the keymap. */
6121 reorder_modifiers (symbol
)
6124 /* It's hopefully okay to write the code this way, since everything
6125 will soon be in caches, and no consing will be done at all. */
6128 parsed
= parse_modifiers (symbol
);
6129 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6134 /* For handling events, we often want to produce a symbol whose name
6135 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6136 to some base, like the name of a function key or mouse button.
6137 modify_event_symbol produces symbols of this sort.
6139 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6140 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6143 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6144 into symbol names, or a string specifying a name stem used to
6145 construct a symbol name or the form `STEM-N', where N is the decimal
6146 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6147 non-nil; otherwise NAME_TABLE is used.
6149 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6150 persist between calls to modify_event_symbol that it can use to
6151 store a cache of the symbols it's generated for this NAME_TABLE
6152 before. The object stored there may be a vector or an alist.
6154 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6156 MODIFIERS is a set of modifier bits (as given in struct input_events)
6157 whose prefixes should be applied to the symbol name.
6159 SYMBOL_KIND is the value to be placed in the event_kind property of
6160 the returned symbol.
6162 The symbols we create are supposed to have an
6163 `event-symbol-elements' property, which lists the modifiers present
6164 in the symbol's name. */
6167 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
6168 name_table
, symbol_table
, table_size
)
6171 Lisp_Object symbol_kind
;
6172 Lisp_Object name_alist_or_stem
;
6174 Lisp_Object
*symbol_table
;
6175 unsigned int table_size
;
6178 Lisp_Object symbol_int
;
6180 /* Get rid of the "vendor-specific" bit here. */
6181 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6183 /* Is this a request for a valid symbol? */
6184 if (symbol_num
< 0 || symbol_num
>= table_size
)
6187 if (CONSP (*symbol_table
))
6188 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6190 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6191 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6192 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6193 we've never used that symbol before. */
6196 if (! VECTORP (*symbol_table
)
6197 || XVECTOR (*symbol_table
)->size
!= table_size
)
6201 XSETFASTINT (size
, table_size
);
6202 *symbol_table
= Fmake_vector (size
, Qnil
);
6205 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6208 /* Have we already used this symbol before? */
6211 /* No; let's create it. */
6212 if (CONSP (name_alist_or_stem
))
6213 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6214 else if (STRINGP (name_alist_or_stem
))
6216 int len
= SBYTES (name_alist_or_stem
);
6217 char *buf
= (char *) alloca (len
+ 50);
6218 if (sizeof (int) == sizeof (EMACS_INT
))
6219 sprintf (buf
, "%s-%d", SDATA (name_alist_or_stem
),
6220 XINT (symbol_int
) + 1);
6221 else if (sizeof (long) == sizeof (EMACS_INT
))
6222 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6223 XINT (symbol_int
) + 1);
6224 value
= intern (buf
);
6226 else if (name_table
!= 0 && name_table
[symbol_num
])
6227 value
= intern (name_table
[symbol_num
]);
6229 #ifdef HAVE_WINDOW_SYSTEM
6232 char *name
= x_get_keysym_name (symbol_num
);
6234 value
= intern (name
);
6241 sprintf (buf
, "key-%d", symbol_num
);
6242 value
= intern (buf
);
6245 if (CONSP (*symbol_table
))
6246 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6248 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6250 /* Fill in the cache entries for this symbol; this also
6251 builds the Qevent_symbol_elements property, which the user
6253 apply_modifiers (modifiers
& click_modifier
, value
);
6254 Fput (value
, Qevent_kind
, symbol_kind
);
6257 /* Apply modifiers to that symbol. */
6258 return apply_modifiers (modifiers
, value
);
6261 /* Convert a list that represents an event type,
6262 such as (ctrl meta backspace), into the usual representation of that
6263 event type as a number or a symbol. */
6265 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6266 doc
: /* Convert the event description list EVENT-DESC to an event type.
6267 EVENT-DESC should contain one base event type (a character or symbol)
6268 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6269 drag, down, double or triple). The base must be last.
6270 The return value is an event type (a character or symbol) which
6271 has the same base event type and all the specified modifiers. */)
6273 Lisp_Object event_desc
;
6281 while (CONSP (rest
))
6289 /* Given a symbol, see if it is a modifier name. */
6290 if (SYMBOLP (elt
) && CONSP (rest
))
6291 this = parse_solitary_modifier (elt
);
6295 else if (!NILP (base
))
6296 error ("Two bases given in one event");
6302 /* Let the symbol A refer to the character A. */
6303 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6304 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6306 if (INTEGERP (base
))
6308 /* Turn (shift a) into A. */
6309 if ((modifiers
& shift_modifier
) != 0
6310 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6312 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6313 modifiers
&= ~shift_modifier
;
6316 /* Turn (control a) into C-a. */
6317 if (modifiers
& ctrl_modifier
)
6318 return make_number ((modifiers
& ~ctrl_modifier
)
6319 | make_ctrl_char (XINT (base
)));
6321 return make_number (modifiers
| XINT (base
));
6323 else if (SYMBOLP (base
))
6324 return apply_modifiers (modifiers
, base
);
6327 error ("Invalid base event");
6332 /* Try to recognize SYMBOL as a modifier name.
6333 Return the modifier flag bit, or 0 if not recognized. */
6336 parse_solitary_modifier (symbol
)
6339 Lisp_Object name
= SYMBOL_NAME (symbol
);
6341 switch (SREF (name
, 0))
6343 #define SINGLE_LETTER_MOD(BIT) \
6344 if (SBYTES (name) == 1) \
6347 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6348 if (LEN == SBYTES (name) \
6349 && ! strncmp (SDATA (name), NAME, LEN)) \
6353 SINGLE_LETTER_MOD (alt_modifier
);
6357 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6361 SINGLE_LETTER_MOD (ctrl_modifier
);
6365 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6366 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6370 SINGLE_LETTER_MOD (hyper_modifier
);
6374 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6378 SINGLE_LETTER_MOD (meta_modifier
);
6382 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6386 SINGLE_LETTER_MOD (shift_modifier
);
6390 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6391 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6392 SINGLE_LETTER_MOD (super_modifier
);
6396 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6397 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6398 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6402 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6405 #undef SINGLE_LETTER_MOD
6406 #undef MULTI_LETTER_MOD
6412 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6413 Such a list is not valid as an event,
6414 but it can be a Lucid-style event type list. */
6417 lucid_event_type_list_p (object
)
6422 if (! CONSP (object
))
6425 if (EQ (XCAR (object
), Qhelp_echo
)
6426 || EQ (XCAR (object
), Qvertical_line
)
6427 || EQ (XCAR (object
), Qmode_line
)
6428 || EQ (XCAR (object
), Qheader_line
))
6431 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6435 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6442 /* Store into *addr a value nonzero if terminal input chars are available.
6443 Serves the purpose of ioctl (0, FIONREAD, addr)
6444 but works even if FIONREAD does not exist.
6445 (In fact, this may actually read some input.)
6447 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe.
6448 If FILTER_EVENTS is nonzero, ignore internal events (FOCUS_IN_EVENT). */
6451 get_filtered_input_pending (addr
, do_timers_now
, filter_events
)
6456 /* First of all, have we already counted some input? */
6457 *addr
= (!NILP (Vquit_flag
)
6458 || readable_filtered_events (do_timers_now
, filter_events
));
6460 /* If input is being read as it arrives, and we have none, there is none. */
6461 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6464 /* Try to read some input and see how much we get. */
6466 *addr
= (!NILP (Vquit_flag
)
6467 || readable_filtered_events (do_timers_now
, filter_events
));
6470 /* Store into *addr a value nonzero if terminal input chars are available.
6471 Serves the purpose of ioctl (0, FIONREAD, addr)
6472 but works even if FIONREAD does not exist.
6473 (In fact, this may actually read some input.)
6475 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
6478 get_input_pending (addr
, do_timers_now
)
6482 get_filtered_input_pending (addr
, do_timers_now
, 0);
6485 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6488 gobble_input (expected
)
6493 if (interrupt_input
)
6496 mask
= sigblock (sigmask (SIGIO
));
6497 read_avail_input (expected
);
6501 #ifdef POLL_FOR_INPUT
6502 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
6505 mask
= sigblock (sigmask (SIGALRM
));
6506 read_avail_input (expected
);
6512 read_avail_input (expected
);
6516 /* Put a BUFFER_SWITCH_EVENT in the buffer
6517 so that read_key_sequence will notice the new current buffer. */
6520 record_asynch_buffer_change ()
6522 struct input_event event
;
6526 event
.kind
= BUFFER_SWITCH_EVENT
;
6527 event
.frame_or_window
= Qnil
;
6531 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6532 The purpose of the event is to make read_key_sequence look up the
6533 keymaps again. If we aren't in read_key_sequence, we don't need one,
6534 and the event could cause trouble by messing up (input-pending-p). */
6535 tem
= Fwaiting_for_user_input_p ();
6539 /* We never need these events if we have no asynchronous subprocesses. */
6543 /* Make sure no interrupt happens while storing the event. */
6545 if (interrupt_input
)
6548 mask
= sigblock (sigmask (SIGIO
));
6549 kbd_buffer_store_event (&event
);
6556 kbd_buffer_store_event (&event
);
6563 /* Read any terminal input already buffered up by the system
6564 into the kbd_buffer, but do not wait.
6566 EXPECTED should be nonzero if the caller knows there is some input.
6568 Except on VMS, all input is read by this function.
6569 If interrupt_input is nonzero, this function MUST be called
6570 only when SIGIO is blocked.
6572 Returns the number of keyboard chars read, or -1 meaning
6573 this is a bad time to try to read input. */
6576 read_avail_input (expected
)
6579 struct input_event buf
[KBD_BUFFER_SIZE
];
6583 for (i
= 0; i
< KBD_BUFFER_SIZE
; i
++)
6584 EVENT_INIT (buf
[i
]);
6586 if (read_socket_hook
)
6587 /* No need for FIONREAD or fcntl; just say don't wait. */
6588 nread
= (*read_socket_hook
) (buf
, KBD_BUFFER_SIZE
, expected
);
6591 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6592 the kbd_buffer can really hold. That may prevent loss
6593 of characters on some systems when input is stuffed at us. */
6594 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6599 #else /* not WINDOWSNT */
6601 n_to_read
= dos_keysns ();
6605 cbuf
[0] = dos_keyread ();
6608 #else /* not MSDOS */
6610 struct tty_output
*tty
;
6613 /* Try to read from each available tty, until one succeeds. */
6614 for (tty
= tty_list
; tty
; tty
= tty
->next
) {
6616 /* Determine how many characters we should *try* to read. */
6618 /* Find out how much input is available. */
6619 if (ioctl (fileno (TTY_INPUT (tty
)), FIONREAD
, &n_to_read
) < 0)
6621 /* Formerly simply reported no input, but that sometimes led to
6622 a failure of Emacs to terminate.
6623 SIGHUP seems appropriate if we can't reach the terminal. */
6624 /* ??? Is it really right to send the signal just to this process
6625 rather than to the whole process group?
6626 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6627 /* It appears to be the case, see narrow_foreground_group. */
6628 if (! noninteractive
)
6630 if (! tty_list
->next
)
6631 kill (getpid (), SIGHUP
); /* This was the last terminal. */
6633 n_to_read
= 0; /* XXX tty should be closed here. */
6642 if (n_to_read
> sizeof cbuf
)
6643 n_to_read
= sizeof cbuf
;
6644 #else /* no FIONREAD */
6645 #if defined (USG) || defined (DGUX) || defined(CYGWIN)
6646 /* Read some input if available, but don't wait. */
6647 n_to_read
= sizeof cbuf
;
6648 fcntl (fileno (TTY_INPUT (tty
)), F_SETFL
, O_NDELAY
);
6654 /* Now read; for one reason or another, this will not block.
6655 NREAD is set to the number of chars read. */
6658 nread
= emacs_read (fileno (TTY_INPUT (tty
)), cbuf
, n_to_read
);
6659 /* POSIX infers that processes which are not in the session leader's
6660 process group won't get SIGHUP's at logout time. BSDI adheres to
6661 this part standard and returns -1 from read (0) with errno==EIO
6662 when the control tty is taken away.
6663 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6664 if (nread
== -1 && errno
== EIO
)
6666 if (! tty_list
->next
)
6667 kill (0, SIGHUP
); /* This was the last terminal. */
6669 ; /* XXX tty should be closed here. */
6671 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6672 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6673 This looks incorrect, but it isn't, because _BSD causes
6674 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6675 and that causes a value other than 0 when there is no input. */
6678 if (! tty_list
->next
)
6679 kill (0, SIGHUP
); /* This was the last terminal. */
6681 ; /* XXX tty should be closed here. */
6686 /* We used to retry the read if it was interrupted.
6687 But this does the wrong thing when O_NDELAY causes
6688 an EAGAIN error. Does anybody know of a situation
6689 where a retry is actually needed? */
6691 nread
< 0 && (errno
== EAGAIN
6705 #if defined (USG) || defined (DGUX) || defined (CYGWIN)
6706 fcntl (fileno (TTY_INPUT (tty
)), F_SETFL
, 0);
6707 #endif /* USG or DGUX or CYGWIN */
6708 #endif /* no FIONREAD */
6712 } /* for each tty */
6717 #endif /* not MSDOS */
6718 #endif /* not WINDOWSNT */
6720 /* Select frame corresponding to the active tty. Note that the
6721 value of selected_frame is not reliable here, redisplay tends
6722 to temporarily change it. But tty should always be non-NULL. */
6723 Lisp_Object frame
= (tty
? tty
->top_frame
: selected_frame
);
6725 for (i
= 0; i
< nread
; i
++)
6727 buf
[i
].kind
= ASCII_KEYSTROKE_EVENT
;
6728 buf
[i
].modifiers
= 0;
6729 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
6730 buf
[i
].modifiers
= meta_modifier
;
6734 buf
[i
].code
= cbuf
[i
];
6735 buf
[i
].frame_or_window
= frame
;
6740 /* Scan the chars for C-g and store them in kbd_buffer. */
6741 for (i
= 0; i
< nread
; i
++)
6743 kbd_buffer_store_event (&buf
[i
]);
6744 /* Don't look at input that follows a C-g too closely.
6745 This reduces lossage due to autorepeat on C-g. */
6746 if (buf
[i
].kind
== ASCII_KEYSTROKE_EVENT
6747 && buf
[i
].code
== quit_char
)
6753 #endif /* not VMS */
6755 #ifdef SIGIO /* for entire page */
6756 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6759 input_available_signal (signo
)
6762 /* Must preserve main program's value of errno. */
6763 int old_errno
= errno
;
6765 extern int select_alarmed
;
6768 #if defined (USG) && !defined (POSIX_SIGNALS)
6769 /* USG systems forget handlers when they are used;
6770 must reestablish each time */
6771 signal (signo
, input_available_signal
);
6778 if (input_available_clear_time
)
6779 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6784 nread
= read_avail_input (1);
6785 /* -1 means it's not ok to read the input now.
6786 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6787 0 means there was no keyboard input available. */
6792 select_alarmed
= 1; /* Force the select emulator back to life */
6803 /* Send ourselves a SIGIO.
6805 This function exists so that the UNBLOCK_INPUT macro in
6806 blockinput.h can have some way to take care of input we put off
6807 dealing with, without assuming that every file which uses
6808 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6810 reinvoke_input_signal ()
6813 kill (getpid (), SIGIO
);
6819 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
, Lisp_Object
, void*));
6820 static Lisp_Object menu_bar_one_keymap_changed_items
;
6822 /* These variables hold the vector under construction within
6823 menu_bar_items and its subroutines, and the current index
6824 for storing into that vector. */
6825 static Lisp_Object menu_bar_items_vector
;
6826 static int menu_bar_items_index
;
6828 /* Return a vector of menu items for a menu bar, appropriate
6829 to the current buffer. Each item has three elements in the vector:
6832 OLD is an old vector we can optionally reuse, or nil. */
6835 menu_bar_items (old
)
6838 /* The number of keymaps we're scanning right now, and the number of
6839 keymaps we have allocated space for. */
6842 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6843 in the current keymaps, or nil where it is not a prefix. */
6846 Lisp_Object def
, tail
;
6855 struct gcpro gcpro1
;
6857 /* In order to build the menus, we need to call the keymap
6858 accessors. They all call QUIT. But this function is called
6859 during redisplay, during which a quit is fatal. So inhibit
6860 quitting while building the menus.
6861 We do this instead of specbind because (1) errors will clear it anyway
6862 and (2) this avoids risk of specpdl overflow. */
6863 oquit
= Vinhibit_quit
;
6867 menu_bar_items_vector
= old
;
6869 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
6870 menu_bar_items_index
= 0;
6872 GCPRO1 (menu_bar_items_vector
);
6874 /* Build our list of keymaps.
6875 If we recognize a function key and replace its escape sequence in
6876 keybuf with its symbol, or if the sequence starts with a mouse
6877 click and we need to switch buffers, we jump back here to rebuild
6878 the initial keymaps from the current buffer. */
6882 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6883 if (!NILP (Voverriding_local_map_menu_flag
))
6885 /* Yes, use them (if non-nil) as well as the global map. */
6886 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
6888 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
6889 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
6890 if (!NILP (Voverriding_local_map
))
6891 maps
[nmaps
++] = Voverriding_local_map
;
6895 /* No, so use major and minor mode keymaps and keymap property.
6896 Note that menu-bar bindings in the local-map and keymap
6897 properties may not work reliable, as they are only
6898 recognized when the menu-bar (or mode-line) is updated,
6899 which does not normally happen after every command. */
6902 nminor
= current_minor_maps (NULL
, &tmaps
);
6903 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
6905 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
6906 maps
[nmaps
++] = tem
;
6907 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
6909 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
6911 maps
[nmaps
++] = current_global_map
;
6914 /* Look up in each map the dummy prefix key `menu-bar'. */
6918 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
6919 if (!NILP (maps
[mapno
]))
6921 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
6925 menu_bar_one_keymap_changed_items
= Qnil
;
6926 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
6930 /* Move to the end those items that should be at the end. */
6932 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
6935 int end
= menu_bar_items_index
;
6937 for (i
= 0; i
< end
; i
+= 4)
6938 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6940 Lisp_Object tem0
, tem1
, tem2
, tem3
;
6941 /* Move the item at index I to the end,
6942 shifting all the others forward. */
6943 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
6944 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
6945 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
6946 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
6948 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
6949 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
6950 (end
- i
- 4) * sizeof (Lisp_Object
));
6951 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
6952 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
6953 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
6954 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
6959 /* Add nil, nil, nil, nil at the end. */
6960 i
= menu_bar_items_index
;
6961 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
6964 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
6965 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
6966 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
6967 menu_bar_items_vector
= tem
;
6969 /* Add this item. */
6970 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6971 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6972 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6973 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6974 menu_bar_items_index
= i
;
6976 Vinhibit_quit
= oquit
;
6978 return menu_bar_items_vector
;
6981 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
6982 If there's already an item for KEY, add this DEF to it. */
6984 Lisp_Object item_properties
;
6987 menu_bar_item (key
, item
, dummy1
, dummy2
)
6988 Lisp_Object key
, item
, dummy1
;
6991 struct gcpro gcpro1
;
6995 if (EQ (item
, Qundefined
))
6997 /* If a map has an explicit `undefined' as definition,
6998 discard any previously made menu bar item. */
7000 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7001 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7003 if (menu_bar_items_index
> i
+ 4)
7004 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7005 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
7006 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7007 menu_bar_items_index
-= 4;
7011 /* If this keymap has already contributed to this KEY,
7012 don't contribute to it a second time. */
7013 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7014 if (!NILP (tem
) || NILP (item
))
7017 menu_bar_one_keymap_changed_items
7018 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7020 /* We add to menu_bar_one_keymap_changed_items before doing the
7021 parse_menu_item, so that if it turns out it wasn't a menu item,
7022 it still correctly hides any further menu item. */
7024 i
= parse_menu_item (item
, 0, 1);
7029 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7031 /* Find any existing item for this KEY. */
7032 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7033 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7036 /* If we did not find this KEY, add it at the end. */
7037 if (i
== menu_bar_items_index
)
7039 /* If vector is too small, get a bigger one. */
7040 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7043 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
7044 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
7045 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
7046 menu_bar_items_vector
= tem
;
7049 /* Add this item. */
7050 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7051 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7052 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7053 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7054 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7055 menu_bar_items_index
= i
;
7057 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7061 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7062 /* If the new and the old items are not both keymaps,
7063 the lookup will only find `item'. */
7064 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7065 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7069 /* This is used as the handler when calling menu_item_eval_property. */
7071 menu_item_eval_property_1 (arg
)
7074 /* If we got a quit from within the menu computation,
7075 quit all the way out of it. This takes care of C-] in the debugger. */
7076 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7077 Fsignal (Qquit
, Qnil
);
7082 /* Evaluate an expression and return the result (or nil if something
7083 went wrong). Used to evaluate dynamic parts of menu items. */
7085 menu_item_eval_property (sexpr
)
7088 int count
= SPECPDL_INDEX ();
7090 specbind (Qinhibit_redisplay
, Qt
);
7091 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7092 menu_item_eval_property_1
);
7093 return unbind_to (count
, val
);
7096 /* This function parses a menu item and leaves the result in the
7097 vector item_properties.
7098 ITEM is a key binding, a possible menu item.
7099 If NOTREAL is nonzero, only check for equivalent key bindings, don't
7100 evaluate dynamic expressions in the menu item.
7101 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7103 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7104 parse_menu_item returns true if the item is a menu item and false
7108 parse_menu_item (item
, notreal
, inmenubar
)
7110 int notreal
, inmenubar
;
7112 Lisp_Object def
, tem
, item_string
, start
;
7113 Lisp_Object cachelist
;
7115 Lisp_Object keyhint
;
7126 /* Create item_properties vector if necessary. */
7127 if (NILP (item_properties
))
7129 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7131 /* Initialize optional entries. */
7132 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7133 AREF (item_properties
, i
) = Qnil
;
7134 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
7136 /* Save the item here to protect it from GC. */
7137 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
7139 item_string
= XCAR (item
);
7143 if (STRINGP (item_string
))
7145 /* Old format menu item. */
7146 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7148 /* Maybe help string. */
7149 if (CONSP (item
) && STRINGP (XCAR (item
)))
7151 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7156 /* Maybe key binding cache. */
7157 if (CONSP (item
) && CONSP (XCAR (item
))
7158 && (NILP (XCAR (XCAR (item
)))
7159 || VECTORP (XCAR (XCAR (item
)))))
7161 cachelist
= XCAR (item
);
7165 /* This is the real definition--the function to run. */
7166 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
7168 /* Get enable property, if any. */
7171 tem
= Fget (item
, Qmenu_enable
);
7173 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7176 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7178 /* New format menu item. */
7179 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
7180 start
= XCDR (item
);
7183 /* We have a real binding. */
7184 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
7186 item
= XCDR (start
);
7187 /* Is there a cache list with key equivalences. */
7188 if (CONSP (item
) && CONSP (XCAR (item
)))
7190 cachelist
= XCAR (item
);
7194 /* Parse properties. */
7195 while (CONSP (item
) && CONSP (XCDR (item
)))
7200 if (EQ (tem
, QCenable
))
7201 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
7202 else if (EQ (tem
, QCvisible
) && !notreal
)
7204 /* If got a visible property and that evaluates to nil
7205 then ignore this item. */
7206 tem
= menu_item_eval_property (XCAR (item
));
7210 else if (EQ (tem
, QChelp
))
7211 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
7212 else if (EQ (tem
, QCfilter
))
7214 else if (EQ (tem
, QCkey_sequence
))
7217 if (NILP (cachelist
)
7218 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
7219 /* Be GC protected. Set keyhint to item instead of tem. */
7222 else if (EQ (tem
, QCkeys
))
7225 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
7226 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7228 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7233 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7235 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7237 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
7244 else if (inmenubar
|| !NILP (start
))
7248 return 0; /* not a menu item */
7250 /* If item string is not a string, evaluate it to get string.
7251 If we don't get a string, skip this item. */
7252 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7253 if (!(STRINGP (item_string
) || notreal
))
7255 item_string
= menu_item_eval_property (item_string
);
7256 if (!STRINGP (item_string
))
7258 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
7261 /* If got a filter apply it on definition. */
7262 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7265 def
= menu_item_eval_property (list2 (XCAR (filter
),
7266 list2 (Qquote
, def
)));
7268 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
7271 /* Enable or disable selection of item. */
7272 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7278 tem
= menu_item_eval_property (tem
);
7279 if (inmenubar
&& NILP (tem
))
7280 return 0; /* Ignore disabled items in menu bar. */
7281 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
7284 /* If we got no definition, this item is just unselectable text which
7285 is OK in a submenu but not in the menubar. */
7287 return (inmenubar
? 0 : 1);
7289 /* See if this is a separate pane or a submenu. */
7290 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7291 tem
= get_keymap (def
, 0, 1);
7292 /* For a subkeymap, just record its details and exit. */
7295 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
7296 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
7300 /* At the top level in the menu bar, do likewise for commands also.
7301 The menu bar does not display equivalent key bindings anyway.
7302 ITEM_PROPERTY_DEF is already set up properly. */
7306 /* This is a command. See if there is an equivalent key binding. */
7307 if (NILP (cachelist
))
7309 /* We have to create a cachelist. */
7310 CHECK_IMPURE (start
);
7311 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
7312 cachelist
= XCAR (XCDR (start
));
7314 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7315 if (!NILP (keyhint
))
7317 XSETCAR (cachelist
, XCAR (keyhint
));
7320 else if (STRINGP (tem
))
7322 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
7323 XSETCAR (cachelist
, Qt
);
7327 tem
= XCAR (cachelist
);
7334 tem
= Fkey_binding (tem
, Qnil
, Qnil
);
7336 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7339 def
= XCAR (prefix
);
7340 prefix
= XCDR (prefix
);
7343 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7345 if (!update_menu_bindings
)
7347 else if (NILP (XCAR (cachelist
))) /* Have no saved key. */
7349 if (newcache
/* Always check first time. */
7350 /* Should we check everything when precomputing key
7352 /* If something had no key binding before, don't recheck it
7353 because that is too slow--except if we have a list of
7354 rebound commands in Vdefine_key_rebound_commands, do
7355 recheck any command that appears in that list. */
7356 || (CONSP (Vdefine_key_rebound_commands
)
7357 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
7360 /* We had a saved key. Is it still bound to the command? */
7363 /* If the command is an alias for another
7364 (such as lmenu.el set it up), check if the
7365 original command matches the cached command. */
7366 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7367 chkcache
= 1; /* Need to recompute key binding. */
7371 /* Recompute equivalent key binding. If the command is an alias
7372 for another (such as lmenu.el set it up), see if the original
7373 command name has equivalent keys. Otherwise look up the
7374 specified command itself. We don't try both, because that
7375 makes lmenu menus slow. */
7377 && SYMBOLP (XSYMBOL (def
)->function
)
7378 && ! NILP (Fget (def
, Qmenu_alias
)))
7379 def
= XSYMBOL (def
)->function
;
7380 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
7381 XSETCAR (cachelist
, tem
);
7384 XSETCDR (cachelist
, Qnil
);
7388 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
7390 tem
= XCAR (cachelist
);
7394 newcache
= chkcache
;
7397 tem
= Fkey_description (tem
);
7400 if (STRINGP (XCAR (prefix
)))
7401 tem
= concat2 (XCAR (prefix
), tem
);
7402 if (STRINGP (XCDR (prefix
)))
7403 tem
= concat2 (tem
, XCDR (prefix
));
7405 XSETCDR (cachelist
, tem
);
7409 tem
= XCDR (cachelist
);
7410 if (newcache
&& !NILP (tem
))
7412 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
7413 XSETCDR (cachelist
, tem
);
7416 /* If we only want to precompute equivalent key bindings, stop here. */
7420 /* If we have an equivalent key binding, use that. */
7421 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7423 /* Include this when menu help is implemented.
7424 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7425 if (!(NILP (tem) || STRINGP (tem)))
7427 tem = menu_item_eval_property (tem);
7430 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7434 /* Handle radio buttons or toggle boxes. */
7435 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7437 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7438 = menu_item_eval_property (tem
);
7445 /***********************************************************************
7447 ***********************************************************************/
7449 /* A vector holding tool bar items while they are parsed in function
7450 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7453 static Lisp_Object tool_bar_items_vector
;
7455 /* A vector holding the result of parse_tool_bar_item. Layout is like
7456 the one for a single item in tool_bar_items_vector. */
7458 static Lisp_Object tool_bar_item_properties
;
7460 /* Next free index in tool_bar_items_vector. */
7462 static int ntool_bar_items
;
7464 /* The symbols `tool-bar', and `:image'. */
7466 extern Lisp_Object Qtool_bar
;
7467 Lisp_Object QCimage
;
7469 /* Function prototypes. */
7471 static void init_tool_bar_items
P_ ((Lisp_Object
));
7472 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7473 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7474 static void append_tool_bar_item
P_ ((void));
7477 /* Return a vector of tool bar items for keymaps currently in effect.
7478 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7479 tool bar items found. */
7482 tool_bar_items (reuse
, nitems
)
7493 /* In order to build the menus, we need to call the keymap
7494 accessors. They all call QUIT. But this function is called
7495 during redisplay, during which a quit is fatal. So inhibit
7496 quitting while building the menus. We do this instead of
7497 specbind because (1) errors will clear it anyway and (2) this
7498 avoids risk of specpdl overflow. */
7499 oquit
= Vinhibit_quit
;
7502 /* Initialize tool_bar_items_vector and protect it from GC. */
7503 init_tool_bar_items (reuse
);
7505 /* Build list of keymaps in maps. Set nmaps to the number of maps
7508 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7509 if (!NILP (Voverriding_local_map_menu_flag
))
7511 /* Yes, use them (if non-nil) as well as the global map. */
7512 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7514 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7515 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7516 if (!NILP (Voverriding_local_map
))
7517 maps
[nmaps
++] = Voverriding_local_map
;
7521 /* No, so use major and minor mode keymaps and keymap property.
7522 Note that tool-bar bindings in the local-map and keymap
7523 properties may not work reliable, as they are only
7524 recognized when the tool-bar (or mode-line) is updated,
7525 which does not normally happen after every command. */
7528 nminor
= current_minor_maps (NULL
, &tmaps
);
7529 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7531 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7532 maps
[nmaps
++] = tem
;
7533 bcopy (tmaps
, (void *) (maps
+ nmaps
), nminor
* sizeof (maps
[0]));
7535 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7538 /* Add global keymap at the end. */
7539 maps
[nmaps
++] = current_global_map
;
7541 /* Process maps in reverse order and look up in each map the prefix
7543 for (i
= nmaps
- 1; i
>= 0; --i
)
7544 if (!NILP (maps
[i
]))
7548 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7553 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
7554 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
7556 Lisp_Object keydef
= XCAR (tail
);
7558 process_tool_bar_item (XCAR (keydef
), XCDR (keydef
));
7563 Vinhibit_quit
= oquit
;
7564 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7565 return tool_bar_items_vector
;
7569 /* Process the definition of KEY which is DEF. */
7572 process_tool_bar_item (key
, def
)
7573 Lisp_Object key
, def
;
7576 extern Lisp_Object Qundefined
;
7577 struct gcpro gcpro1
, gcpro2
;
7579 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7583 if (EQ (def
, Qundefined
))
7585 /* If a map has an explicit `undefined' as definition,
7586 discard any previously made item. */
7587 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
7589 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
7591 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
7593 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
7594 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
7595 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
7596 * sizeof (Lisp_Object
)));
7597 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
7602 else if (parse_tool_bar_item (key
, def
))
7603 /* Append a new tool bar item to tool_bar_items_vector. Accept
7604 more than one definition for the same key. */
7605 append_tool_bar_item ();
7611 /* Parse a tool bar item specification ITEM for key KEY and return the
7612 result in tool_bar_item_properties. Value is zero if ITEM is
7615 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7617 CAPTION is the caption of the item, If it's not a string, it is
7618 evaluated to get a string.
7620 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7621 as binding are currently ignored.
7623 The following properties are recognized:
7627 FORM is evaluated and specifies whether the tool bar item is
7628 enabled or disabled.
7632 FORM is evaluated and specifies whether the tool bar item is visible.
7634 - `:filter FUNCTION'
7636 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
7637 result is stored as the new binding.
7639 - `:button (TYPE SELECTED)'
7641 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
7642 and specifies whether the button is selected (pressed) or not.
7646 IMAGES is either a single image specification or a vector of four
7647 image specifications. See enum tool_bar_item_images.
7649 - `:help HELP-STRING'.
7651 Gives a help string to display for the tool bar item. */
7654 parse_tool_bar_item (key
, item
)
7655 Lisp_Object key
, item
;
7657 /* Access slot with index IDX of vector tool_bar_item_properties. */
7658 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
7660 Lisp_Object filter
= Qnil
;
7661 Lisp_Object caption
;
7664 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
7665 Rule out items that aren't lists, don't start with
7666 `menu-item' or whose rest following `tool-bar-item' is not a
7669 || !EQ (XCAR (item
), Qmenu_item
)
7670 || (item
= XCDR (item
),
7674 /* Create tool_bar_item_properties vector if necessary. Reset it to
7676 if (VECTORP (tool_bar_item_properties
))
7678 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
7682 tool_bar_item_properties
7683 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
7686 PROP (TOOL_BAR_ITEM_KEY
) = key
;
7687 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
7689 /* Get the caption of the item. If the caption is not a string,
7690 evaluate it to get a string. If we don't get a string, skip this
7692 caption
= XCAR (item
);
7693 if (!STRINGP (caption
))
7695 caption
= menu_item_eval_property (caption
);
7696 if (!STRINGP (caption
))
7699 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
7701 /* Give up if rest following the caption is not a list. */
7706 /* Store the binding. */
7707 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
7710 /* Ignore cached key binding, if any. */
7711 if (CONSP (item
) && CONSP (XCAR (item
)))
7714 /* Process the rest of the properties. */
7715 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
7717 Lisp_Object key
, value
;
7720 value
= XCAR (XCDR (item
));
7722 if (EQ (key
, QCenable
))
7723 /* `:enable FORM'. */
7724 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
7725 else if (EQ (key
, QCvisible
))
7727 /* `:visible FORM'. If got a visible property and that
7728 evaluates to nil then ignore this item. */
7729 if (NILP (menu_item_eval_property (value
)))
7732 else if (EQ (key
, QChelp
))
7733 /* `:help HELP-STRING'. */
7734 PROP (TOOL_BAR_ITEM_HELP
) = value
;
7735 else if (EQ (key
, QCfilter
))
7736 /* ':filter FORM'. */
7738 else if (EQ (key
, QCbutton
) && CONSP (value
))
7740 /* `:button (TYPE . SELECTED)'. */
7741 Lisp_Object type
, selected
;
7743 type
= XCAR (value
);
7744 selected
= XCDR (value
);
7745 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7747 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
7748 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
7751 else if (EQ (key
, QCimage
)
7753 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
7754 /* Value is either a single image specification or a vector
7755 of 4 such specifications for the different button states. */
7756 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
7759 /* If got a filter apply it on binding. */
7761 PROP (TOOL_BAR_ITEM_BINDING
)
7762 = menu_item_eval_property (list2 (filter
,
7764 PROP (TOOL_BAR_ITEM_BINDING
))));
7766 /* See if the binding is a keymap. Give up if it is. */
7767 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
7770 /* Enable or disable selection of item. */
7771 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
7772 PROP (TOOL_BAR_ITEM_ENABLED_P
)
7773 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7775 /* Handle radio buttons or toggle boxes. */
7776 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
7777 PROP (TOOL_BAR_ITEM_SELECTED_P
)
7778 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7786 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7787 that can be reused. */
7790 init_tool_bar_items (reuse
)
7793 if (VECTORP (reuse
))
7794 tool_bar_items_vector
= reuse
;
7796 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
7797 ntool_bar_items
= 0;
7801 /* Append parsed tool bar item properties from
7802 tool_bar_item_properties */
7805 append_tool_bar_item ()
7807 Lisp_Object
*to
, *from
;
7809 /* Enlarge tool_bar_items_vector if necessary. */
7810 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
7811 >= XVECTOR (tool_bar_items_vector
)->size
)
7813 Lisp_Object new_vector
;
7814 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
7816 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
7817 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
7818 XVECTOR (new_vector
)->contents
,
7819 old_size
* sizeof (Lisp_Object
));
7820 tool_bar_items_vector
= new_vector
;
7823 /* Append entries from tool_bar_item_properties to the end of
7824 tool_bar_items_vector. */
7825 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
7826 from
= XVECTOR (tool_bar_item_properties
)->contents
;
7827 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
7828 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
7835 /* Read a character using menus based on maps in the array MAPS.
7836 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7837 Return t if we displayed a menu but the user rejected it.
7839 PREV_EVENT is the previous input event, or nil if we are reading
7840 the first event of a key sequence.
7842 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7843 if we used a mouse menu to read the input, or zero otherwise. If
7844 USED_MOUSE_MENU is null, we don't dereference it.
7846 The prompting is done based on the prompt-string of the map
7847 and the strings associated with various map elements.
7849 This can be done with X menus or with menus put in the minibuf.
7850 These are done in different ways, depending on how the input will be read.
7851 Menus using X are done after auto-saving in read-char, getting the input
7852 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7853 and do auto-saving in the inner call of read_char. */
7856 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
7859 Lisp_Object prev_event
;
7860 int *used_mouse_menu
;
7863 register Lisp_Object name
= Qnil
;
7865 if (used_mouse_menu
)
7866 *used_mouse_menu
= 0;
7868 /* Use local over global Menu maps */
7870 if (! menu_prompting
)
7873 /* Optionally disregard all but the global map. */
7874 if (inhibit_local_menu_bar_menus
)
7876 maps
+= (nmaps
- 1);
7880 /* Get the menu name from the first map that has one (a prompt string). */
7881 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7883 name
= Fkeymap_prompt (maps
[mapno
]);
7888 /* If we don't have any menus, just read a character normally. */
7889 if (!STRINGP (name
))
7893 /* If we got to this point via a mouse click,
7894 use a real menu for mouse selection. */
7895 if (EVENT_HAS_PARAMETERS (prev_event
)
7896 && !EQ (XCAR (prev_event
), Qmenu_bar
)
7897 && !EQ (XCAR (prev_event
), Qtool_bar
))
7899 /* Display the menu and get the selection. */
7900 Lisp_Object
*realmaps
7901 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
7905 /* Use the maps that are not nil. */
7906 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7907 if (!NILP (maps
[mapno
]))
7908 realmaps
[nmaps1
++] = maps
[mapno
];
7910 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
7915 record_menu_key (XCAR (value
));
7917 /* If we got multiple events, unread all but
7919 There is no way to prevent those unread events
7920 from showing up later in last_nonmenu_event.
7921 So turn symbol and integer events into lists,
7922 to indicate that they came from a mouse menu,
7923 so that when present in last_nonmenu_event
7924 they won't confuse things. */
7925 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
7927 record_menu_key (XCAR (tem
));
7928 if (SYMBOLP (XCAR (tem
))
7929 || INTEGERP (XCAR (tem
)))
7930 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
7933 /* If we got more than one event, put all but the first
7934 onto this list to be read later.
7935 Return just the first event now. */
7936 Vunread_command_events
7937 = nconc2 (XCDR (value
), Vunread_command_events
);
7938 value
= XCAR (value
);
7940 else if (NILP (value
))
7942 if (used_mouse_menu
)
7943 *used_mouse_menu
= 1;
7946 #endif /* HAVE_MENUS */
7950 /* Buffer in use so far for the minibuf prompts for menu keymaps.
7951 We make this bigger when necessary, and never free it. */
7952 static char *read_char_minibuf_menu_text
;
7953 /* Size of that buffer. */
7954 static int read_char_minibuf_menu_width
;
7957 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
7963 register Lisp_Object name
;
7965 /* FIXME: Use the minibuffer's frame width. */
7966 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
7969 Lisp_Object rest
, vector
;
7975 if (! menu_prompting
)
7978 /* Make sure we have a big enough buffer for the menu text. */
7979 if (read_char_minibuf_menu_text
== 0)
7981 read_char_minibuf_menu_width
= width
+ 4;
7982 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
7984 else if (width
+ 4 > read_char_minibuf_menu_width
)
7986 read_char_minibuf_menu_width
= width
+ 4;
7987 read_char_minibuf_menu_text
7988 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
7990 menu
= read_char_minibuf_menu_text
;
7992 /* Get the menu name from the first map that has one (a prompt string). */
7993 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7995 name
= Fkeymap_prompt (maps
[mapno
]);
8000 /* If we don't have any menus, just read a character normally. */
8001 if (!STRINGP (name
))
8004 /* Prompt string always starts with map's prompt, and a space. */
8005 strcpy (menu
, SDATA (name
));
8006 nlength
= SBYTES (name
);
8007 menu
[nlength
++] = ':';
8008 menu
[nlength
++] = ' ';
8011 /* Start prompting at start of first map. */
8015 /* Present the documented bindings, a line at a time. */
8022 Lisp_Object orig_defn_macro
;
8024 /* Loop over elements of map. */
8029 /* If reached end of map, start at beginning of next map. */
8033 /* At end of last map, wrap around to first map if just starting,
8034 or end this line if already have something on it. */
8038 if (notfirst
|| nobindings
) break;
8043 /* Look at the next element of the map. */
8045 elt
= XVECTOR (vector
)->contents
[idx
];
8047 elt
= Fcar_safe (rest
);
8049 if (idx
< 0 && VECTORP (elt
))
8051 /* If we found a dense table in the keymap,
8052 advanced past it, but start scanning its contents. */
8053 rest
= Fcdr_safe (rest
);
8059 /* An ordinary element. */
8060 Lisp_Object event
, tem
;
8064 event
= Fcar_safe (elt
); /* alist */
8065 elt
= Fcdr_safe (elt
);
8069 XSETINT (event
, idx
); /* vector */
8072 /* Ignore the element if it has no prompt string. */
8073 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
8075 /* 1 if the char to type matches the string. */
8077 Lisp_Object upcased_event
, downcased_event
;
8078 Lisp_Object desc
= Qnil
;
8080 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8082 upcased_event
= Fupcase (event
);
8083 downcased_event
= Fdowncase (event
);
8084 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8085 || XINT (downcased_event
) == SREF (s
, 0));
8087 desc
= Fsingle_key_description (event
, Qnil
);
8089 #if 0 /* It is redundant to list the equivalent key bindings because
8090 the prefix is what the user has already typed. */
8092 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8094 /* Insert equivalent keybinding. */
8095 s
= concat2 (s
, tem
);
8098 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8099 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8101 /* Insert button prefix. */
8102 Lisp_Object selected
8103 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8104 if (EQ (tem
, QCradio
))
8105 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8107 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8108 s
= concat2 (tem
, s
);
8112 /* If we have room for the prompt string, add it to this line.
8113 If this is the first on the line, always add it. */
8114 if ((SCHARS (s
) + i
+ 2
8115 + (char_matches
? 0 : SCHARS (desc
) + 3))
8121 /* Punctuate between strings. */
8124 strcpy (menu
+ i
, ", ");
8130 /* If the char to type doesn't match the string's
8131 first char, explicitly show what char to type. */
8134 /* Add as much of string as fits. */
8135 thiswidth
= SCHARS (desc
);
8136 if (thiswidth
+ i
> width
)
8137 thiswidth
= width
- i
;
8138 bcopy (SDATA (desc
), menu
+ i
, thiswidth
);
8140 strcpy (menu
+ i
, " = ");
8144 /* Add as much of string as fits. */
8145 thiswidth
= SCHARS (s
);
8146 if (thiswidth
+ i
> width
)
8147 thiswidth
= width
- i
;
8148 bcopy (SDATA (s
), menu
+ i
, thiswidth
);
8154 /* If this element does not fit, end the line now,
8155 and save the element for the next line. */
8156 strcpy (menu
+ i
, "...");
8161 /* Move past this element. */
8162 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8163 /* Handle reaching end of dense table. */
8168 rest
= Fcdr_safe (rest
);
8172 /* Prompt with that and read response. */
8173 message2_nolog (menu
, strlen (menu
),
8174 ! NILP (current_buffer
->enable_multibyte_characters
));
8176 /* Make believe its not a keyboard macro in case the help char
8177 is pressed. Help characters are not recorded because menu prompting
8178 is not used on replay.
8180 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
8181 current_kboard
->defining_kbd_macro
= Qnil
;
8183 obj
= read_char (commandflag
, 0, 0, Qt
, 0);
8184 while (BUFFERP (obj
));
8185 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
8187 if (!INTEGERP (obj
))
8192 if (! EQ (obj
, menu_prompt_more_char
)
8193 && (!INTEGERP (menu_prompt_more_char
)
8194 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8196 if (!NILP (current_kboard
->defining_kbd_macro
))
8197 store_kbd_macro_char (obj
);
8200 /* Help char - go round again */
8204 /* Reading key sequences. */
8206 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8207 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8208 keymap, or nil otherwise. Return the index of the first keymap in
8209 which KEY has any binding, or NMAPS if no map has a binding.
8211 If KEY is a meta ASCII character, treat it like meta-prefix-char
8212 followed by the corresponding non-meta character. Keymaps in
8213 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8216 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8219 NEXT may be the same array as CURRENT. */
8222 follow_key (key
, nmaps
, current
, defs
, next
)
8224 Lisp_Object
*current
, *defs
, *next
;
8227 int i
, first_binding
;
8229 first_binding
= nmaps
;
8230 for (i
= nmaps
- 1; i
>= 0; i
--)
8232 if (! NILP (current
[i
]))
8234 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8235 if (! NILP (defs
[i
]))
8242 /* Given the set of bindings we've found, produce the next set of maps. */
8243 if (first_binding
< nmaps
)
8244 for (i
= 0; i
< nmaps
; i
++)
8245 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8247 return first_binding
;
8250 /* Structure used to keep track of partial application of key remapping
8251 such as Vfunction_key_map and Vkey_translation_map. */
8252 typedef struct keyremap
8254 Lisp_Object map
, parent
;
8258 /* Lookup KEY in MAP.
8259 MAP is a keymap mapping keys to key vectors or functions.
8260 If the mapping is a function and DO_FUNCTION is non-zero, then
8261 the function is called with PROMPT as parameter and its return
8262 value is used as the return value of this function (after checking
8263 that it is indeed a vector). */
8266 access_keymap_keyremap (map
, key
, prompt
, do_funcall
)
8267 Lisp_Object map
, key
, prompt
;
8272 next
= access_keymap (map
, key
, 1, 0, 1);
8274 /* Handle symbol with autoload definition. */
8275 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8276 && CONSP (XSYMBOL (next
)->function
)
8277 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8278 do_autoload (XSYMBOL (next
)->function
, next
);
8280 /* Handle a symbol whose function definition is a keymap
8282 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8283 && (!NILP (Farrayp (XSYMBOL (next
)->function
))
8284 || KEYMAPP (XSYMBOL (next
)->function
)))
8285 next
= XSYMBOL (next
)->function
;
8287 /* If the keymap gives a function, not an
8288 array, then call the function with one arg and use
8289 its value instead. */
8290 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8295 next
= call1 (next
, prompt
);
8296 /* If the function returned something invalid,
8297 barf--don't ignore it.
8298 (To ignore it safely, we would need to gcpro a bunch of
8299 other variables.) */
8300 if (! (VECTORP (next
) || STRINGP (next
)))
8301 error ("Function %s returns invalid key sequence", tem
);
8306 /* Do one step of the key remapping used for function-key-map and
8307 key-translation-map:
8308 KEYBUF is the buffer holding the input events.
8309 BUFSIZE is its maximum size.
8310 FKEY is a pointer to the keyremap structure to use.
8311 INPUT is the index of the last element in KEYBUF.
8312 DOIT if non-zero says that the remapping can actually take place.
8313 DIFF is used to return the number of keys added/removed by the remapping.
8314 PARENT is the root of the keymap.
8315 PROMPT is the prompt to use if the remapping happens through a function.
8316 The return value is non-zero if the remapping actually took place. */
8319 keyremap_step (keybuf
, bufsize
, fkey
, input
, doit
, diff
, prompt
)
8320 Lisp_Object
*keybuf
, prompt
;
8322 int input
, doit
, *diff
, bufsize
;
8324 Lisp_Object next
, key
;
8326 key
= keybuf
[fkey
->end
++];
8327 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8329 /* If keybuf[fkey->start..fkey->end] is bound in the
8330 map and we're in a position to do the key remapping, replace it with
8331 the binding and restart with fkey->start at the end. */
8332 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8334 int len
= XFASTINT (Flength (next
));
8337 *diff
= len
- (fkey
->end
- fkey
->start
);
8339 if (input
+ *diff
>= bufsize
)
8340 error ("Key sequence too long");
8342 /* Shift the keys that follow fkey->end. */
8344 for (i
= fkey
->end
; i
< input
; i
++)
8345 keybuf
[i
+ *diff
] = keybuf
[i
];
8347 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8348 keybuf
[i
+ *diff
] = keybuf
[i
];
8349 /* Overwrite the old keys with the new ones. */
8350 for (i
= 0; i
< len
; i
++)
8351 keybuf
[fkey
->start
+ i
]
8352 = Faref (next
, make_number (i
));
8354 fkey
->start
= fkey
->end
+= *diff
;
8355 fkey
->map
= fkey
->parent
;
8360 fkey
->map
= get_keymap (next
, 0, 1);
8362 /* If we no longer have a bound suffix, try a new position for
8364 if (!CONSP (fkey
->map
))
8366 fkey
->end
= ++fkey
->start
;
8367 fkey
->map
= fkey
->parent
;
8372 /* Read a sequence of keys that ends with a non prefix character,
8373 storing it in KEYBUF, a buffer of size BUFSIZE.
8375 Return the length of the key sequence stored.
8376 Return -1 if the user rejected a command menu.
8378 Echo starting immediately unless `prompt' is 0.
8380 Where a key sequence ends depends on the currently active keymaps.
8381 These include any minor mode keymaps active in the current buffer,
8382 the current buffer's local map, and the global map.
8384 If a key sequence has no other bindings, we check Vfunction_key_map
8385 to see if some trailing subsequence might be the beginning of a
8386 function key's sequence. If so, we try to read the whole function
8387 key, and substitute its symbolic name into the key sequence.
8389 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8390 `double-' events into similar click events, if that would make them
8391 bound. We try to turn `triple-' events first into `double-' events,
8394 If we get a mouse click in a mode line, vertical divider, or other
8395 non-text area, we treat the click as if it were prefixed by the
8396 symbol denoting that area - `mode-line', `vertical-line', or
8399 If the sequence starts with a mouse click, we read the key sequence
8400 with respect to the buffer clicked on, not the current buffer.
8402 If the user switches frames in the midst of a key sequence, we put
8403 off the switch-frame event until later; the next call to
8404 read_char will return it.
8406 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8407 from the selected window's buffer. */
8410 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
8411 can_return_switch_frame
, fix_current_buffer
)
8412 Lisp_Object
*keybuf
;
8415 int dont_downcase_last
;
8416 int can_return_switch_frame
;
8417 int fix_current_buffer
;
8419 volatile Lisp_Object from_string
;
8420 volatile int count
= SPECPDL_INDEX ();
8422 /* How many keys there are in the current key sequence. */
8425 /* The length of the echo buffer when we started reading, and
8426 the length of this_command_keys when we started reading. */
8427 volatile int echo_start
;
8428 volatile int keys_start
;
8430 /* The number of keymaps we're scanning right now, and the number of
8431 keymaps we have allocated space for. */
8433 volatile int nmaps_allocated
= 0;
8435 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8436 the current keymaps. */
8437 Lisp_Object
*volatile defs
= NULL
;
8439 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8440 in the current keymaps, or nil where it is not a prefix. */
8441 Lisp_Object
*volatile submaps
= NULL
;
8443 /* The local map to start out with at start of key sequence. */
8444 volatile Lisp_Object orig_local_map
;
8446 /* The map from the `keymap' property to start out with at start of
8448 volatile Lisp_Object orig_keymap
;
8450 /* 1 if we have already considered switching to the local-map property
8451 of the place where a mouse click occurred. */
8452 volatile int localized_local_map
= 0;
8454 /* The index in defs[] of the first keymap that has a binding for
8455 this key sequence. In other words, the lowest i such that
8456 defs[i] is non-nil. */
8457 volatile int first_binding
;
8458 /* Index of the first key that has no binding.
8459 It is useless to try fkey.start larger than that. */
8460 volatile int first_unbound
;
8462 /* If t < mock_input, then KEYBUF[t] should be read as the next
8465 We use this to recover after recognizing a function key. Once we
8466 realize that a suffix of the current key sequence is actually a
8467 function key's escape sequence, we replace the suffix with the
8468 function key's binding from Vfunction_key_map. Now keybuf
8469 contains a new and different key sequence, so the echo area,
8470 this_command_keys, and the submaps and defs arrays are wrong. In
8471 this situation, we set mock_input to t, set t to 0, and jump to
8472 restart_sequence; the loop will read keys from keybuf up until
8473 mock_input, thus rebuilding the state; and then it will resume
8474 reading characters from the keyboard. */
8475 volatile int mock_input
= 0;
8477 /* If the sequence is unbound in submaps[], then
8478 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8479 and fkey.map is its binding.
8481 These might be > t, indicating that all function key scanning
8482 should hold off until t reaches them. We do this when we've just
8483 recognized a function key, to avoid searching for the function
8484 key's again in Vfunction_key_map. */
8485 volatile keyremap fkey
;
8487 /* Likewise, for key_translation_map. */
8488 volatile keyremap keytran
;
8490 /* If we receive a `switch-frame' or `select-window' event in the middle of
8491 a key sequence, we put it off for later.
8492 While we're reading, we keep the event here. */
8493 volatile Lisp_Object delayed_switch_frame
;
8495 /* See the comment below... */
8496 #if defined (GOBBLE_FIRST_EVENT)
8497 Lisp_Object first_event
;
8500 volatile Lisp_Object original_uppercase
;
8501 volatile int original_uppercase_position
= -1;
8503 /* Gets around Microsoft compiler limitations. */
8506 struct buffer
*starting_buffer
;
8508 /* List of events for which a fake prefix key has been generated. */
8509 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
8511 #if defined (GOBBLE_FIRST_EVENT)
8515 struct gcpro gcpro1
;
8517 GCPRO1 (fake_prefixed_keys
);
8518 raw_keybuf_count
= 0;
8520 last_nonmenu_event
= Qnil
;
8522 delayed_switch_frame
= Qnil
;
8523 fkey
.map
= fkey
.parent
= Vfunction_key_map
;
8524 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
8525 /* If there is no translation-map, turn off scanning. */
8526 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
8527 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
8532 echo_prompt (prompt
);
8533 else if (cursor_in_echo_area
8534 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8535 && NILP (Fzerop (Vecho_keystrokes
)))
8536 /* This doesn't put in a dash if the echo buffer is empty, so
8537 you don't always see a dash hanging out in the minibuffer. */
8541 /* Record the initial state of the echo area and this_command_keys;
8542 we will need to restore them if we replay a key sequence. */
8544 echo_start
= echo_length ();
8545 keys_start
= this_command_key_count
;
8546 this_single_command_key_start
= keys_start
;
8548 #if defined (GOBBLE_FIRST_EVENT)
8549 /* This doesn't quite work, because some of the things that read_char
8550 does cannot safely be bypassed. It seems too risky to try to make
8553 /* Read the first char of the sequence specially, before setting
8554 up any keymaps, in case a filter runs and switches buffers on us. */
8555 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
8557 #endif /* GOBBLE_FIRST_EVENT */
8559 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8560 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8563 /* We jump here when the key sequence has been thoroughly changed, and
8564 we need to rescan it starting from the beginning. When we jump here,
8565 keybuf[0..mock_input] holds the sequence we should reread. */
8568 starting_buffer
= current_buffer
;
8569 first_unbound
= bufsize
+ 1;
8571 /* Build our list of keymaps.
8572 If we recognize a function key and replace its escape sequence in
8573 keybuf with its symbol, or if the sequence starts with a mouse
8574 click and we need to switch buffers, we jump back here to rebuild
8575 the initial keymaps from the current buffer. */
8578 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
8579 || !NILP (Voverriding_local_map
))
8581 if (3 > nmaps_allocated
)
8583 submaps
= (Lisp_Object
*) alloca (3 * sizeof (submaps
[0]));
8584 defs
= (Lisp_Object
*) alloca (3 * sizeof (defs
[0]));
8585 nmaps_allocated
= 3;
8587 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8588 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8589 if (!NILP (Voverriding_local_map
))
8590 submaps
[nmaps
++] = Voverriding_local_map
;
8598 nminor
= current_minor_maps (0, &maps
);
8599 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
8601 if (total
> nmaps_allocated
)
8603 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
8604 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
8605 nmaps_allocated
= total
;
8608 if (!NILP (orig_keymap
))
8609 submaps
[nmaps
++] = orig_keymap
;
8611 bcopy (maps
, (void *) (submaps
+ nmaps
),
8612 nminor
* sizeof (submaps
[0]));
8616 submaps
[nmaps
++] = orig_local_map
;
8618 submaps
[nmaps
++] = current_global_map
;
8620 /* Find an accurate initial value for first_binding. */
8621 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
8622 if (! NILP (submaps
[first_binding
]))
8625 /* Start from the beginning in keybuf. */
8628 /* These are no-ops the first time through, but if we restart, they
8629 revert the echo area and this_command_keys to their original state. */
8630 this_command_key_count
= keys_start
;
8631 if (INTERACTIVE
&& t
< mock_input
)
8632 echo_truncate (echo_start
);
8634 /* If the best binding for the current key sequence is a keymap, or
8635 we may be looking at a function key's escape sequence, keep on
8637 while (first_binding
< nmaps
8638 /* Keep reading as long as there's a prefix binding. */
8639 ? !NILP (submaps
[first_binding
])
8640 /* Don't return in the middle of a possible function key sequence,
8641 if the only bindings we found were via case conversion.
8642 Thus, if ESC O a has a function-key-map translation
8643 and ESC o has a binding, don't return after ESC O,
8644 so that we can translate ESC O plus the next character. */
8645 : (fkey
.start
< t
|| keytran
.start
< t
))
8648 int used_mouse_menu
= 0;
8650 /* Where the last real key started. If we need to throw away a
8651 key that has expanded into more than one element of keybuf
8652 (say, a mouse click on the mode line which is being treated
8653 as [mode-line (mouse-...)], then we backtrack to this point
8655 volatile int last_real_key_start
;
8657 /* These variables are analogous to echo_start and keys_start;
8658 while those allow us to restart the entire key sequence,
8659 echo_local_start and keys_local_start allow us to throw away
8661 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
8663 eassert (fkey
.end
== t
|| (fkey
.end
> t
&& fkey
.end
<= mock_input
));
8664 eassert (fkey
.start
<= fkey
.end
);
8665 eassert (keytran
.start
<= keytran
.end
);
8666 /* key-translation-map is applied *after* function-key-map. */
8667 eassert (keytran
.end
<= fkey
.start
);
8669 if (first_unbound
< fkey
.start
&& first_unbound
< keytran
.start
)
8670 { /* The prefix upto first_unbound has no binding and has
8671 no translation left to do either, so we know it's unbound.
8672 If we don't stop now, we risk staying here indefinitely
8673 (if the user keeps entering fkey or keytran prefixes
8674 like C-c ESC ESC ESC ESC ...) */
8676 for (i
= first_unbound
+ 1; i
< t
; i
++)
8677 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
8678 mock_input
= t
- first_unbound
- 1;
8679 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
8680 fkey
.map
= fkey
.parent
;
8681 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
8682 keytran
.map
= keytran
.parent
;
8683 goto replay_sequence
;
8687 error ("Key sequence too long");
8690 echo_local_start
= echo_length ();
8691 keys_local_start
= this_command_key_count
;
8692 local_first_binding
= first_binding
;
8695 /* These are no-ops, unless we throw away a keystroke below and
8696 jumped back up to replay_key; in that case, these restore the
8697 variables to their original state, allowing us to replay the
8699 if (INTERACTIVE
&& t
< mock_input
)
8700 echo_truncate (echo_local_start
);
8701 this_command_key_count
= keys_local_start
;
8702 first_binding
= local_first_binding
;
8704 /* By default, assume each event is "real". */
8705 last_real_key_start
= t
;
8707 /* Does mock_input indicate that we are re-reading a key sequence? */
8711 add_command_key (key
);
8712 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8713 && NILP (Fzerop (Vecho_keystrokes
)))
8717 /* If not, we should actually read a character. */
8722 KBOARD
*interrupted_kboard
= current_kboard
;
8723 struct frame
*interrupted_frame
= SELECTED_FRAME ();
8724 if (setjmp (wrong_kboard_jmpbuf
))
8726 if (!NILP (delayed_switch_frame
))
8728 interrupted_kboard
->kbd_queue
8729 = Fcons (delayed_switch_frame
,
8730 interrupted_kboard
->kbd_queue
);
8731 delayed_switch_frame
= Qnil
;
8734 interrupted_kboard
->kbd_queue
8735 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
8737 /* If the side queue is non-empty, ensure it begins with a
8738 switch-frame, so we'll replay it in the right context. */
8739 if (CONSP (interrupted_kboard
->kbd_queue
)
8740 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
8741 !(EVENT_HAS_PARAMETERS (key
)
8742 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
8746 XSETFRAME (frame
, interrupted_frame
);
8747 interrupted_kboard
->kbd_queue
8748 = Fcons (make_lispy_switch_frame (frame
),
8749 interrupted_kboard
->kbd_queue
);
8752 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8753 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8754 goto replay_sequence
;
8757 key
= read_char (NILP (prompt
), nmaps
,
8758 (Lisp_Object
*) submaps
, last_nonmenu_event
,
8762 /* read_char returns t when it shows a menu and the user rejects it.
8766 unbind_to (count
, Qnil
);
8771 /* read_char returns -1 at the end of a macro.
8772 Emacs 18 handles this by returning immediately with a
8773 zero, so that's what we'll do. */
8774 if (INTEGERP (key
) && XINT (key
) == -1)
8777 /* The Microsoft C compiler can't handle the goto that
8783 /* If the current buffer has been changed from under us, the
8784 keymap may have changed, so replay the sequence. */
8787 EMACS_TIME initial_idleness_start_time
;
8788 EMACS_SET_SECS_USECS (initial_idleness_start_time
,
8789 EMACS_SECS (timer_last_idleness_start_time
),
8790 EMACS_USECS (timer_last_idleness_start_time
));
8792 /* Resume idle state, using the same start-time as before. */
8793 timer_start_idle ();
8794 timer_idleness_start_time
= initial_idleness_start_time
;
8797 /* Reset the current buffer from the selected window
8798 in case something changed the former and not the latter.
8799 This is to be more consistent with the behavior
8800 of the command_loop_1. */
8801 if (fix_current_buffer
)
8803 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8805 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
8806 Fset_buffer (XWINDOW (selected_window
)->buffer
);
8809 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8810 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8811 goto replay_sequence
;
8814 /* If we have a quit that was typed in another frame, and
8815 quit_throw_to_read_char switched buffers,
8816 replay to get the right keymap. */
8818 && XINT (key
) == quit_char
8819 && current_buffer
!= starting_buffer
)
8822 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8826 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8827 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8828 goto replay_sequence
;
8833 if (EVENT_HAS_PARAMETERS (key
)
8834 /* Either a `switch-frame' or a `select-window' event. */
8835 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
8837 /* If we're at the beginning of a key sequence, and the caller
8838 says it's okay, go ahead and return this event. If we're
8839 in the midst of a key sequence, delay it until the end. */
8840 if (t
> 0 || !can_return_switch_frame
)
8842 delayed_switch_frame
= key
;
8848 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8851 /* Clicks in non-text areas get prefixed by the symbol
8852 in their CHAR-ADDRESS field. For example, a click on
8853 the mode line is prefixed by the symbol `mode-line'.
8855 Furthermore, key sequences beginning with mouse clicks
8856 are read using the keymaps of the buffer clicked on, not
8857 the current buffer. So we may have to switch the buffer
8860 When we turn one event into two events, we must make sure
8861 that neither of the two looks like the original--so that,
8862 if we replay the events, they won't be expanded again.
8863 If not for this, such reexpansion could happen either here
8864 or when user programs play with this-command-keys. */
8865 if (EVENT_HAS_PARAMETERS (key
))
8870 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
8871 if (EQ (kind
, Qmouse_click
))
8873 Lisp_Object window
, posn
;
8875 window
= POSN_WINDOW (EVENT_START (key
));
8876 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
8879 || (!NILP (fake_prefixed_keys
)
8880 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
8882 /* We're looking a second time at an event for which
8883 we generated a fake prefix key. Set
8884 last_real_key_start appropriately. */
8886 last_real_key_start
= t
- 1;
8889 /* Key sequences beginning with mouse clicks are
8890 read using the keymaps in the buffer clicked on,
8891 not the current buffer. If we're at the
8892 beginning of a key sequence, switch buffers. */
8893 if (last_real_key_start
== 0
8895 && BUFFERP (XWINDOW (window
)->buffer
)
8896 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
8898 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8902 /* Arrange to go back to the original buffer once we're
8903 done reading the key sequence. Note that we can't
8904 use save_excursion_{save,restore} here, because they
8905 save point as well as the current buffer; we don't
8906 want to save point, because redisplay may change it,
8907 to accommodate a Fset_window_start or something. We
8908 don't want to do this at the top of the function,
8909 because we may get input from a subprocess which
8910 wants to change the selected window and stuff (say,
8912 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
8914 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8916 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
8917 orig_local_map
= get_local_map (PT
, current_buffer
,
8919 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8920 goto replay_sequence
;
8923 /* For a mouse click, get the local text-property keymap
8924 of the place clicked on, rather than point. */
8925 if (last_real_key_start
== 0
8926 && CONSP (XCDR (key
))
8927 && ! localized_local_map
)
8929 Lisp_Object map_here
, start
, pos
;
8931 localized_local_map
= 1;
8932 start
= EVENT_START (key
);
8934 if (CONSP (start
) && CONSP (XCDR (start
)))
8936 pos
= POSN_BUFFER_POSN (start
);
8938 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
8940 map_here
= get_local_map (XINT (pos
),
8941 current_buffer
, Qlocal_map
);
8942 if (!EQ (map_here
, orig_local_map
))
8944 orig_local_map
= map_here
;
8948 goto replay_sequence
;
8950 map_here
= get_local_map (XINT (pos
),
8951 current_buffer
, Qkeymap
);
8952 if (!EQ (map_here
, orig_keymap
))
8954 orig_keymap
= map_here
;
8958 goto replay_sequence
;
8964 /* Expand mode-line and scroll-bar events into two events:
8965 use posn as a fake prefix key. */
8967 && (NILP (fake_prefixed_keys
)
8968 || NILP (Fmemq (key
, fake_prefixed_keys
))))
8970 if (t
+ 1 >= bufsize
)
8971 error ("Key sequence too long");
8974 keybuf
[t
+ 1] = key
;
8977 /* Record that a fake prefix key has been generated
8978 for KEY. Don't modify the event; this would
8979 prevent proper action when the event is pushed
8980 back into unread-command-events. */
8981 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
8983 /* If on a mode line string with a local keymap,
8984 reconsider the key sequence with that keymap. */
8985 if (string
= POSN_STRING (EVENT_START (key
)),
8986 (CONSP (string
) && STRINGP (XCAR (string
))))
8988 Lisp_Object pos
, map
, map2
;
8990 pos
= XCDR (string
);
8991 string
= XCAR (string
);
8993 && XINT (pos
) < SCHARS (string
))
8995 map
= Fget_text_property (pos
, Qlocal_map
, string
);
8997 orig_local_map
= map
;
8998 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9001 if (!NILP (map
) || !NILP (map2
))
9002 goto replay_sequence
;
9008 else if (NILP (from_string
)
9009 && (string
= POSN_STRING (EVENT_START (key
)),
9010 (CONSP (string
) && STRINGP (XCAR (string
)))))
9012 /* For a click on a string, i.e. overlay string or a
9013 string displayed via the `display' property,
9014 consider `local-map' and `keymap' properties of
9016 Lisp_Object pos
, map
, map2
;
9018 pos
= XCDR (string
);
9019 string
= XCAR (string
);
9021 && XINT (pos
) < SCHARS (string
))
9023 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9025 orig_local_map
= map
;
9026 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9030 if (!NILP (map
) || !NILP (map2
))
9032 from_string
= string
;
9033 goto replay_sequence
;
9038 else if (CONSP (XCDR (key
))
9039 && CONSP (EVENT_START (key
))
9040 && CONSP (XCDR (EVENT_START (key
))))
9044 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
9045 /* Handle menu-bar events:
9046 insert the dummy prefix event `menu-bar'. */
9047 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9049 if (t
+ 1 >= bufsize
)
9050 error ("Key sequence too long");
9054 /* Zap the position in key, so we know that we've
9055 expanded it, and don't try to do so again. */
9056 POSN_BUFFER_SET_POSN (EVENT_START (key
),
9057 Fcons (posn
, Qnil
));
9060 goto replay_sequence
;
9062 else if (CONSP (posn
))
9064 /* We're looking at the second event of a
9065 sequence which we expanded before. Set
9066 last_real_key_start appropriately. */
9067 if (last_real_key_start
== t
&& t
> 0)
9068 last_real_key_start
= t
- 1;
9073 /* We have finally decided that KEY is something we might want
9075 first_binding
= (follow_key (key
,
9076 nmaps
- first_binding
,
9077 submaps
+ first_binding
,
9078 defs
+ first_binding
,
9079 submaps
+ first_binding
)
9082 /* If KEY wasn't bound, we'll try some fallbacks. */
9083 if (first_binding
< nmaps
)
9084 /* This is needed for the following scenario:
9085 event 0: a down-event that gets dropped by calling replay_key.
9086 event 1: some normal prefix like C-h.
9087 After event 0, first_unbound is 0, after event 1 fkey.start
9088 and keytran.start are both 1, so when we see that C-h is bound,
9089 we need to update first_unbound. */
9090 first_unbound
= max (t
+ 1, first_unbound
);
9095 /* Remember the position to put an upper bound on fkey.start. */
9096 first_unbound
= min (t
, first_unbound
);
9098 head
= EVENT_HEAD (key
);
9099 if (help_char_p (head
) && t
> 0)
9101 read_key_sequence_cmd
= Vprefix_help_command
;
9103 last_nonmenu_event
= key
;
9104 /* The Microsoft C compiler can't handle the goto that
9112 Lisp_Object breakdown
;
9115 breakdown
= parse_modifiers (head
);
9116 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9117 /* Attempt to reduce an unbound mouse event to a simpler
9118 event that is bound:
9119 Drags reduce to clicks.
9120 Double-clicks reduce to clicks.
9121 Triple-clicks reduce to double-clicks, then to clicks.
9122 Down-clicks are eliminated.
9123 Double-downs reduce to downs, then are eliminated.
9124 Triple-downs reduce to double-downs, then to downs,
9125 then are eliminated. */
9126 if (modifiers
& (down_modifier
| drag_modifier
9127 | double_modifier
| triple_modifier
))
9129 while (modifiers
& (down_modifier
| drag_modifier
9130 | double_modifier
| triple_modifier
))
9132 Lisp_Object new_head
, new_click
;
9133 if (modifiers
& triple_modifier
)
9134 modifiers
^= (double_modifier
| triple_modifier
);
9135 else if (modifiers
& double_modifier
)
9136 modifiers
&= ~double_modifier
;
9137 else if (modifiers
& drag_modifier
)
9138 modifiers
&= ~drag_modifier
;
9141 /* Dispose of this `down' event by simply jumping
9142 back to replay_key, to get another event.
9144 Note that if this event came from mock input,
9145 then just jumping back to replay_key will just
9146 hand it to us again. So we have to wipe out any
9149 We could delete keybuf[t] and shift everything
9150 after that to the left by one spot, but we'd also
9151 have to fix up any variable that points into
9152 keybuf, and shifting isn't really necessary
9155 Adding prefixes for non-textual mouse clicks
9156 creates two characters of mock input, and both
9157 must be thrown away. If we're only looking at
9158 the prefix now, we can just jump back to
9159 replay_key. On the other hand, if we've already
9160 processed the prefix, and now the actual click
9161 itself is giving us trouble, then we've lost the
9162 state of the keymaps we want to backtrack to, and
9163 we need to replay the whole sequence to rebuild
9166 Beyond that, only function key expansion could
9167 create more than two keys, but that should never
9168 generate mouse events, so it's okay to zero
9169 mock_input in that case too.
9171 FIXME: The above paragraph seems just plain
9172 wrong, if you consider things like
9173 xterm-mouse-mode. -stef
9175 Isn't this just the most wonderful code ever? */
9177 /* If mock_input > t + 1, the above simplification
9178 will actually end up dropping keys on the floor.
9179 This is probably OK for now, but even
9180 if mock_input <= t + 1, we need to adjust fkey
9182 Typical case [header-line down-mouse-N]:
9183 mock_input = 2, t = 1, fkey.end = 1,
9184 last_real_key_start = 0. */
9185 if (fkey
.end
> last_real_key_start
)
9187 fkey
.end
= fkey
.start
9188 = min (last_real_key_start
, fkey
.start
);
9189 fkey
.map
= fkey
.parent
;
9190 if (keytran
.end
> last_real_key_start
)
9192 keytran
.end
= keytran
.start
9193 = min (last_real_key_start
, keytran
.start
);
9194 keytran
.map
= keytran
.parent
;
9197 if (t
== last_real_key_start
)
9204 mock_input
= last_real_key_start
;
9205 goto replay_sequence
;
9210 = apply_modifiers (modifiers
, XCAR (breakdown
));
9212 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9214 /* Look for a binding for this new key. follow_key
9215 promises that it didn't munge submaps the
9216 last time we called it, since key was unbound. */
9218 = (follow_key (new_click
,
9219 nmaps
- local_first_binding
,
9220 submaps
+ local_first_binding
,
9221 defs
+ local_first_binding
,
9222 submaps
+ local_first_binding
)
9223 + local_first_binding
);
9225 /* If that click is bound, go for it. */
9226 if (first_binding
< nmaps
)
9231 /* Otherwise, we'll leave key set to the drag event. */
9238 /* Normally, last_nonmenu_event gets the previous key we read.
9239 But when a mouse popup menu is being used,
9240 we don't update last_nonmenu_event; it continues to hold the mouse
9241 event that preceded the first level of menu. */
9242 if (!used_mouse_menu
)
9243 last_nonmenu_event
= key
;
9245 /* Record what part of this_command_keys is the current key sequence. */
9246 this_single_command_key_start
= this_command_key_count
- t
;
9248 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
]))
9249 /* There is a binding and it's not a prefix.
9250 There is thus no function-key in this sequence.
9251 Moving fkey.start is important in this case to allow keytran.start
9252 to go over the sequence before we return (since we keep the
9253 invariant that keytran.end <= fkey.start). */
9256 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9259 /* If the sequence is unbound, see if we can hang a function key
9260 off the end of it. */
9261 /* Continue scan from fkey.end until we find a bound suffix. */
9262 while (fkey
.end
< t
)
9264 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9267 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9268 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9269 max (t
, mock_input
),
9270 /* If there's a binding (i.e.
9271 first_binding >= nmaps) we don't want
9272 to apply this function-key-mapping. */
9273 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9278 mock_input
= diff
+ max (t
, mock_input
);
9279 goto replay_sequence
;
9283 /* Look for this sequence in key-translation-map.
9284 Scan from keytran.end until we find a bound suffix. */
9285 while (keytran
.end
< fkey
.start
)
9287 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9290 GCPRO3 (fkey
.map
, keytran
.map
, delayed_switch_frame
);
9291 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9296 mock_input
= diff
+ max (t
, mock_input
);
9297 /* Adjust the function-key-map counters. */
9301 goto replay_sequence
;
9305 /* If KEY is not defined in any of the keymaps,
9306 and cannot be part of a function key or translation,
9307 and is an upper case letter
9308 use the corresponding lower-case letter instead. */
9309 if (first_binding
>= nmaps
9310 && fkey
.start
>= t
&& keytran
.start
>= t
9312 && ((((XINT (key
) & 0x3ffff)
9313 < XCHAR_TABLE (current_buffer
->downcase_table
)->size
)
9314 && UPPERCASEP (XINT (key
) & 0x3ffff))
9315 || (XINT (key
) & shift_modifier
)))
9317 Lisp_Object new_key
;
9319 original_uppercase
= key
;
9320 original_uppercase_position
= t
- 1;
9322 if (XINT (key
) & shift_modifier
)
9323 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9325 XSETINT (new_key
, (DOWNCASE (XINT (key
) & 0x3ffff)
9326 | (XINT (key
) & ~0x3ffff)));
9328 /* We have to do this unconditionally, regardless of whether
9329 the lower-case char is defined in the keymaps, because they
9330 might get translated through function-key-map. */
9331 keybuf
[t
- 1] = new_key
;
9332 mock_input
= max (t
, mock_input
);
9334 goto replay_sequence
;
9336 /* If KEY is not defined in any of the keymaps,
9337 and cannot be part of a function key or translation,
9338 and is a shifted function key,
9339 use the corresponding unshifted function key instead. */
9340 if (first_binding
>= nmaps
9341 && fkey
.start
>= t
&& keytran
.start
>= t
9344 Lisp_Object breakdown
;
9347 breakdown
= parse_modifiers (key
);
9348 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9349 if (modifiers
& shift_modifier
)
9351 Lisp_Object new_key
;
9353 original_uppercase
= key
;
9354 original_uppercase_position
= t
- 1;
9356 modifiers
&= ~shift_modifier
;
9357 new_key
= apply_modifiers (modifiers
,
9360 keybuf
[t
- 1] = new_key
;
9361 mock_input
= max (t
, mock_input
);
9362 fkey
.start
= fkey
.end
= KEYMAPP (fkey
.map
) ? 0 : bufsize
+ 1;
9363 keytran
.start
= keytran
.end
= KEYMAPP (keytran
.map
) ? 0 : bufsize
+ 1;
9365 goto replay_sequence
;
9371 read_key_sequence_cmd
= (first_binding
< nmaps
9372 ? defs
[first_binding
]
9375 unread_switch_frame
= delayed_switch_frame
;
9376 unbind_to (count
, Qnil
);
9378 /* Don't downcase the last character if the caller says don't.
9379 Don't downcase it if the result is undefined, either. */
9380 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9381 && t
- 1 == original_uppercase_position
)
9382 keybuf
[t
- 1] = original_uppercase
;
9384 /* Occasionally we fabricate events, perhaps by expanding something
9385 according to function-key-map, or by adding a prefix symbol to a
9386 mouse click in the scroll bar or modeline. In this cases, return
9387 the entire generated key sequence, even if we hit an unbound
9388 prefix or a definition before the end. This means that you will
9389 be able to push back the event properly, and also means that
9390 read-key-sequence will always return a logical unit.
9393 for (; t
< mock_input
; t
++)
9395 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9396 && NILP (Fzerop (Vecho_keystrokes
)))
9397 echo_char (keybuf
[t
]);
9398 add_command_key (keybuf
[t
]);
9407 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9408 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9409 The sequence is sufficient to specify a non-prefix command in the
9410 current local and global maps.
9412 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9413 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9414 as a continuation of the previous key.
9416 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9417 convert the last event to lower case. (Normally any upper case event
9418 is converted to lower case if the original event is undefined and the lower
9419 case equivalent is defined.) A non-nil value is appropriate for reading
9420 a key sequence to be defined.
9422 A C-g typed while in this function is treated like any other character,
9423 and `quit-flag' is not set.
9425 If the key sequence starts with a mouse click, then the sequence is read
9426 using the keymaps of the buffer of the window clicked in, not the buffer
9427 of the selected window as normal.
9429 `read-key-sequence' drops unbound button-down events, since you normally
9430 only care about the click or drag events which follow them. If a drag
9431 or multi-click event is unbound, but the corresponding click event would
9432 be bound, `read-key-sequence' turns the event into a click event at the
9433 drag's starting position. This means that you don't have to distinguish
9434 between click and drag, double, or triple events unless you want to.
9436 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9437 lines separating windows, and scroll bars with imaginary keys
9438 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9440 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9441 function will process a switch-frame event if the user switches frames
9442 before typing anything. If the user switches frames in the middle of a
9443 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9444 is nil, then the event will be put off until after the current key sequence.
9446 `read-key-sequence' checks `function-key-map' for function key
9447 sequences, where they wouldn't conflict with ordinary bindings. See
9448 `function-key-map' for more details.
9450 The optional fifth argument COMMAND-LOOP, if non-nil, means
9451 that this key sequence is being read by something that will
9452 read commands one after another. It should be nil if the caller
9453 will read just one key sequence. */)
9454 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9456 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9457 Lisp_Object can_return_switch_frame
, command_loop
;
9459 Lisp_Object keybuf
[30];
9461 struct gcpro gcpro1
;
9462 int count
= SPECPDL_INDEX ();
9465 CHECK_STRING (prompt
);
9468 specbind (Qinput_method_exit_on_first_char
,
9469 (NILP (command_loop
) ? Qt
: Qnil
));
9470 specbind (Qinput_method_use_echo_area
,
9471 (NILP (command_loop
) ? Qt
: Qnil
));
9473 bzero (keybuf
, sizeof keybuf
);
9475 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9477 if (NILP (continue_echo
))
9479 this_command_key_count
= 0;
9480 this_command_key_count_reset
= 0;
9481 this_single_command_key_start
= 0;
9484 #ifdef HAVE_X_WINDOWS
9485 if (display_hourglass_p
)
9486 cancel_hourglass ();
9489 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9490 prompt
, ! NILP (dont_downcase_last
),
9491 ! NILP (can_return_switch_frame
), 0);
9493 #if 0 /* The following is fine for code reading a key sequence and
9494 then proceeding with a lenghty computation, but it's not good
9495 for code reading keys in a loop, like an input method. */
9496 #ifdef HAVE_X_WINDOWS
9497 if (display_hourglass_p
)
9508 return unbind_to (count
, make_event_array (i
, keybuf
));
9511 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
9512 Sread_key_sequence_vector
, 1, 5, 0,
9513 doc
: /* Like `read-key-sequence' but always return a vector. */)
9514 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9516 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9517 Lisp_Object can_return_switch_frame
, command_loop
;
9519 Lisp_Object keybuf
[30];
9521 struct gcpro gcpro1
;
9522 int count
= SPECPDL_INDEX ();
9525 CHECK_STRING (prompt
);
9528 specbind (Qinput_method_exit_on_first_char
,
9529 (NILP (command_loop
) ? Qt
: Qnil
));
9530 specbind (Qinput_method_use_echo_area
,
9531 (NILP (command_loop
) ? Qt
: Qnil
));
9533 bzero (keybuf
, sizeof keybuf
);
9535 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9537 if (NILP (continue_echo
))
9539 this_command_key_count
= 0;
9540 this_command_key_count_reset
= 0;
9541 this_single_command_key_start
= 0;
9544 #ifdef HAVE_X_WINDOWS
9545 if (display_hourglass_p
)
9546 cancel_hourglass ();
9549 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9550 prompt
, ! NILP (dont_downcase_last
),
9551 ! NILP (can_return_switch_frame
), 0);
9553 #ifdef HAVE_X_WINDOWS
9554 if (display_hourglass_p
)
9564 return unbind_to (count
, Fvector (i
, keybuf
));
9567 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
9568 doc
: /* Execute CMD as an editor command.
9569 CMD must be a symbol that satisfies the `commandp' predicate.
9570 Optional second arg RECORD-FLAG non-nil
9571 means unconditionally put this command in `command-history'.
9572 Otherwise, that is done only if an arg is read using the minibuffer.
9573 The argument KEYS specifies the value to use instead of (this-command-keys)
9574 when reading the arguments; if it is nil, (this-command-keys) is used.
9575 The argument SPECIAL, if non-nil, means that this command is executing
9576 a special event, so ignore the prefix argument and don't clear it. */)
9577 (cmd
, record_flag
, keys
, special
)
9578 Lisp_Object cmd
, record_flag
, keys
, special
;
9580 register Lisp_Object final
;
9581 register Lisp_Object tem
;
9582 Lisp_Object prefixarg
;
9583 struct backtrace backtrace
;
9584 extern int debug_on_next_call
;
9586 debug_on_next_call
= 0;
9590 prefixarg
= current_kboard
->Vprefix_arg
;
9591 Vcurrent_prefix_arg
= prefixarg
;
9592 current_kboard
->Vprefix_arg
= Qnil
;
9599 tem
= Fget (cmd
, Qdisabled
);
9600 if (!NILP (tem
) && !NILP (Vrun_hooks
))
9602 tem
= Fsymbol_value (Qdisabled_command_hook
);
9604 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
9610 final
= Findirect_function (cmd
);
9612 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
9614 struct gcpro gcpro1
, gcpro2
;
9616 GCPRO2 (cmd
, prefixarg
);
9617 do_autoload (final
, cmd
);
9624 if (STRINGP (final
) || VECTORP (final
))
9626 /* If requested, place the macro in the command history. For
9627 other sorts of commands, call-interactively takes care of
9629 if (!NILP (record_flag
))
9632 = Fcons (Fcons (Qexecute_kbd_macro
,
9633 Fcons (final
, Fcons (prefixarg
, Qnil
))),
9636 /* Don't keep command history around forever. */
9637 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
9639 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
9641 XSETCDR (tem
, Qnil
);
9645 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
9648 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
9650 backtrace
.next
= backtrace_list
;
9651 backtrace_list
= &backtrace
;
9652 backtrace
.function
= &Qcall_interactively
;
9653 backtrace
.args
= &cmd
;
9654 backtrace
.nargs
= 1;
9655 backtrace
.evalargs
= 0;
9657 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
9659 backtrace_list
= backtrace
.next
;
9667 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
9669 doc
: /* Read function name, then read its arguments and call it. */)
9671 Lisp_Object prefixarg
;
9673 Lisp_Object function
;
9675 int saved_last_point_position
;
9676 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
9677 Lisp_Object bindings
, value
;
9678 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9680 saved_keys
= Fvector (this_command_key_count
,
9681 XVECTOR (this_command_keys
)->contents
);
9682 saved_last_point_position_buffer
= last_point_position_buffer
;
9683 saved_last_point_position
= last_point_position
;
9685 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
9687 if (EQ (prefixarg
, Qminus
))
9689 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
9690 strcpy (buf
, "C-u ");
9691 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
9693 if (sizeof (int) == sizeof (EMACS_INT
))
9694 sprintf (buf
, "%d ", XINT (XCAR (prefixarg
)));
9695 else if (sizeof (long) == sizeof (EMACS_INT
))
9696 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
9700 else if (INTEGERP (prefixarg
))
9702 if (sizeof (int) == sizeof (EMACS_INT
))
9703 sprintf (buf
, "%d ", XINT (prefixarg
));
9704 else if (sizeof (long) == sizeof (EMACS_INT
))
9705 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
9710 /* This isn't strictly correct if execute-extended-command
9711 is bound to anything else. Perhaps it should use
9712 this_command_keys? */
9713 strcat (buf
, "M-x ");
9715 /* Prompt with buf, and then read a string, completing from and
9716 restricting to the set of all defined commands. Don't provide
9717 any initial input. Save the command read on the extended-command
9719 function
= Fcompleting_read (build_string (buf
),
9720 Vobarray
, Qcommandp
,
9721 Qt
, Qnil
, Qextended_command_history
, Qnil
,
9724 if (STRINGP (function
) && SCHARS (function
) == 0)
9725 error ("No command name given");
9727 /* Set this_command_keys to the concatenation of saved_keys and
9728 function, followed by a RET. */
9733 this_command_key_count
= 0;
9734 this_command_key_count_reset
= 0;
9735 this_single_command_key_start
= 0;
9737 keys
= XVECTOR (saved_keys
)->contents
;
9738 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
9739 add_command_key (keys
[i
]);
9741 for (i
= 0; i
< SCHARS (function
); i
++)
9742 add_command_key (Faref (function
, make_number (i
)));
9744 add_command_key (make_number ('\015'));
9747 last_point_position
= saved_last_point_position
;
9748 last_point_position_buffer
= saved_last_point_position_buffer
;
9752 function
= Fintern (function
, Qnil
);
9753 current_kboard
->Vprefix_arg
= prefixarg
;
9754 Vthis_command
= function
;
9755 real_this_command
= function
;
9757 /* If enabled, show which key runs this command. */
9758 if (!NILP (Vsuggest_key_bindings
)
9759 && NILP (Vexecuting_macro
)
9760 && SYMBOLP (function
))
9761 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
9767 GCPRO2 (bindings
, value
);
9768 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
9770 /* If the command has a key binding, print it now. */
9771 if (!NILP (bindings
)
9772 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
9775 /* But first wait, and skip the message if there is input. */
9777 if (!NILP (echo_area_buffer
[0]))
9778 /* This command displayed something in the echo area;
9779 so wait a few seconds, then display our suggestion message. */
9780 delay_time
= (NUMBERP (Vsuggest_key_bindings
)
9781 ? XINT (Vsuggest_key_bindings
) : 2);
9783 /* This command left the echo area empty,
9784 so display our message immediately. */
9787 if (!NILP (Fsit_for (make_number (delay_time
), Qnil
, Qnil
))
9788 && ! CONSP (Vunread_command_events
))
9790 Lisp_Object binding
;
9792 int message_p
= push_message ();
9793 int count
= SPECPDL_INDEX ();
9795 record_unwind_protect (pop_message_unwind
, Qnil
);
9796 binding
= Fkey_description (bindings
);
9799 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
9802 sprintf (newmessage
, "You can run the command `%s' with %s",
9803 SDATA (SYMBOL_NAME (function
)),
9805 message2_nolog (newmessage
,
9806 strlen (newmessage
),
9807 STRING_MULTIBYTE (binding
));
9808 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
9809 ? Vsuggest_key_bindings
: make_number (2)),
9814 unbind_to (count
, Qnil
);
9818 RETURN_UNGCPRO (value
);
9822 /* Return nonzero if input events are pending. */
9825 detect_input_pending ()
9828 get_input_pending (&input_pending
, 0);
9830 return input_pending
;
9833 /* Return nonzero if input events are pending, and run any pending timers. */
9836 detect_input_pending_run_timers (do_display
)
9839 int old_timers_run
= timers_run
;
9842 get_input_pending (&input_pending
, 1);
9844 if (old_timers_run
!= timers_run
&& do_display
)
9846 redisplay_preserve_echo_area (8);
9847 /* The following fixes a bug when using lazy-lock with
9848 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9849 from an idle timer function. The symptom of the bug is that
9850 the cursor sometimes doesn't become visible until the next X
9851 event is processed. --gerd. */
9853 rif
->flush_display (NULL
);
9856 return input_pending
;
9859 /* This is called in some cases before a possible quit.
9860 It cases the next call to detect_input_pending to recompute input_pending.
9861 So calling this function unnecessarily can't do any harm. */
9864 clear_input_pending ()
9869 /* Return nonzero if there are pending requeued events.
9870 This isn't used yet. The hope is to make wait_reading_process_input
9871 call it, and return if it runs Lisp code that unreads something.
9872 The problem is, kbd_buffer_get_event needs to be fixed to know what
9873 to do in that case. It isn't trivial. */
9876 requeued_events_pending_p ()
9878 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
9882 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
9883 doc
: /* Return t if command input is currently available with no wait.
9884 Actually, the value is nil only if we can be sure that no input is available;
9885 if there is a doubt, the value is t. */)
9888 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
9891 get_filtered_input_pending (&input_pending
, 1, 1);
9892 return input_pending
> 0 ? Qt
: Qnil
;
9895 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
9896 doc
: /* Return vector of last 100 events, not counting those from keyboard macros. */)
9899 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
9902 if (total_keys
< NUM_RECENT_KEYS
)
9903 return Fvector (total_keys
, keys
);
9906 val
= Fvector (NUM_RECENT_KEYS
, keys
);
9907 bcopy (keys
+ recent_keys_index
,
9908 XVECTOR (val
)->contents
,
9909 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
9911 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
9912 recent_keys_index
* sizeof (Lisp_Object
));
9917 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
9918 doc
: /* Return the key sequence that invoked this command.
9919 However, if the command has called `read-key-sequence', it returns
9920 the last key sequence that has been read.
9921 The value is a string or a vector. */)
9924 return make_event_array (this_command_key_count
,
9925 XVECTOR (this_command_keys
)->contents
);
9928 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
9929 doc
: /* Return the key sequence that invoked this command, as a vector.
9930 However, if the command has called `read-key-sequence', it returns
9931 the last key sequence that has been read. */)
9934 return Fvector (this_command_key_count
,
9935 XVECTOR (this_command_keys
)->contents
);
9938 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
9939 Sthis_single_command_keys
, 0, 0, 0,
9940 doc
: /* Return the key sequence that invoked this command.
9941 More generally, it returns the last key sequence read, either by
9942 the command loop or by `read-key-sequence'.
9943 Unlike `this-command-keys', this function's value
9944 does not include prefix arguments.
9945 The value is always a vector. */)
9948 return Fvector (this_command_key_count
9949 - this_single_command_key_start
,
9950 (XVECTOR (this_command_keys
)->contents
9951 + this_single_command_key_start
));
9954 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
9955 Sthis_single_command_raw_keys
, 0, 0, 0,
9956 doc
: /* Return the raw events that were read for this command.
9957 More generally, it returns the last key sequence read, either by
9958 the command loop or by `read-key-sequence'.
9959 Unlike `this-single-command-keys', this function's value
9960 shows the events before all translations (except for input methods).
9961 The value is always a vector. */)
9964 return Fvector (raw_keybuf_count
,
9965 (XVECTOR (raw_keybuf
)->contents
));
9968 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
9969 Sreset_this_command_lengths
, 0, 0, 0,
9970 doc
: /* Make the unread events replace the last command and echo.
9971 Used in `universal-argument-other-key'.
9973 `universal-argument-other-key' rereads the event just typed.
9974 It then gets translated through `function-key-map'.
9975 The translated event has to replace the real events,
9976 both in the value of (this-command-keys) and in echoing.
9977 To achieve this, `universal-argument-other-key' calls
9978 `reset-this-command-lengths', which discards the record of reading
9979 these events the first time. */)
9982 this_command_key_count
= before_command_key_count
;
9983 if (this_command_key_count
< this_single_command_key_start
)
9984 this_single_command_key_start
= this_command_key_count
;
9986 echo_truncate (before_command_echo_length
);
9988 /* Cause whatever we put into unread-command-events
9989 to echo as if it were being freshly read from the keyboard. */
9990 this_command_key_count_reset
= 1;
9995 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
9996 Sclear_this_command_keys
, 0, 1, 0,
9997 doc
: /* Clear out the vector that `this-command-keys' returns.
9998 Also clear the record of the last 100 events, unless optional arg
9999 KEEP-RECORD is non-nil. */)
10001 Lisp_Object keep_record
;
10005 this_command_key_count
= 0;
10006 this_command_key_count_reset
= 0;
10008 if (NILP (keep_record
))
10010 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10011 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10013 recent_keys_index
= 0;
10018 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10019 doc
: /* Return the current depth in recursive edits. */)
10023 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10027 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10028 "FOpen dribble file: ",
10029 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10030 If FILE is nil, close any open dribble file. */)
10041 file
= Fexpand_file_name (file
, Qnil
);
10042 dribble
= fopen (SDATA (file
), "w");
10044 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10049 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10050 doc
: /* Discard the contents of the terminal input buffer.
10051 Also end any kbd macro being defined. */)
10054 if (!NILP (current_kboard
->defining_kbd_macro
))
10056 /* Discard the last command from the macro. */
10057 Fcancel_kbd_macro_events ();
10061 update_mode_lines
++;
10063 Vunread_command_events
= Qnil
;
10064 unread_command_char
= -1;
10066 discard_tty_input ();
10068 kbd_fetch_ptr
= kbd_store_ptr
;
10069 Ffillarray (kbd_buffer_gcpro
, Qnil
);
10075 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10076 doc
: /* Stop Emacs and return to superior process. You can resume later.
10077 If `cannot-suspend' is non-nil, or if the system doesn't support job
10078 control, run a subshell instead.
10080 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10081 to be read as terminal input by Emacs's parent, after suspension.
10083 Before suspending, run the normal hook `suspend-hook'.
10084 After resumption run the normal hook `suspend-resume-hook'.
10086 Some operating systems cannot stop the Emacs process and resume it later.
10087 On such systems, Emacs starts a subshell instead of suspending. */)
10089 Lisp_Object stuffstring
;
10091 int count
= SPECPDL_INDEX ();
10092 int old_height
, old_width
;
10094 struct gcpro gcpro1
;
10096 if (tty_list
&& tty_list
->next
)
10097 error ("Suspend is not supported with multiple ttys");
10099 if (!NILP (stuffstring
))
10100 CHECK_STRING (stuffstring
);
10102 /* Run the functions in suspend-hook. */
10103 if (!NILP (Vrun_hooks
))
10104 call1 (Vrun_hooks
, intern ("suspend-hook"));
10106 GCPRO1 (stuffstring
);
10107 get_tty_size (CURTTY (), &old_width
, &old_height
);
10108 reset_all_sys_modes ();
10109 /* sys_suspend can get an error if it tries to fork a subshell
10110 and the system resources aren't available for that. */
10111 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_sys_modes
,
10113 stuff_buffered_input (stuffstring
);
10114 if (cannot_suspend
)
10118 unbind_to (count
, Qnil
);
10120 /* Check if terminal/window size has changed.
10121 Note that this is not useful when we are running directly
10122 with a window system; but suspend should be disabled in that case. */
10123 get_tty_size (CURTTY (), &width
, &height
);
10124 if (width
!= old_width
|| height
!= old_height
)
10125 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10127 /* Run suspend-resume-hook. */
10128 if (!NILP (Vrun_hooks
))
10129 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10135 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10136 Then in any case stuff anything Emacs has read ahead and not used. */
10139 stuff_buffered_input (stuffstring
)
10140 Lisp_Object stuffstring
;
10142 /* stuff_char works only in BSD, versions 4.2 and up. */
10145 register unsigned char *p
;
10147 if (STRINGP (stuffstring
))
10149 register int count
;
10151 p
= SDATA (stuffstring
);
10152 count
= SBYTES (stuffstring
);
10153 while (count
-- > 0)
10158 /* Anything we have read ahead, put back for the shell to read. */
10159 /* ?? What should this do when we have multiple keyboards??
10160 Should we ignore anything that was typed in at the "wrong" kboard? */
10161 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10165 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10166 kbd_fetch_ptr
= kbd_buffer
;
10167 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10168 stuff_char (kbd_fetch_ptr
->code
);
10170 kbd_fetch_ptr
->kind
= NO_EVENT
;
10171 idx
= 2 * (kbd_fetch_ptr
- kbd_buffer
);
10172 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
10173 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
10178 #endif /* BSD_SYSTEM and not BSD4_1 */
10182 set_waiting_for_input (time_to_clear
)
10183 EMACS_TIME
*time_to_clear
;
10185 input_available_clear_time
= time_to_clear
;
10187 /* Tell interrupt_signal to throw back to read_char, */
10188 waiting_for_input
= 1;
10190 /* If interrupt_signal was called before and buffered a C-g,
10191 make it run again now, to avoid timing error. */
10192 if (!NILP (Vquit_flag
))
10193 quit_throw_to_read_char ();
10197 clear_waiting_for_input ()
10199 /* Tell interrupt_signal not to throw back to read_char, */
10200 waiting_for_input
= 0;
10201 input_available_clear_time
= 0;
10204 /* This routine is called at interrupt level in response to C-g.
10206 If interrupt_input, this is the handler for SIGINT. Otherwise, it
10207 is called from kbd_buffer_store_event, in handling SIGIO or
10210 If `waiting_for_input' is non zero, then unless `echoing' is
10211 nonzero, immediately throw back to read_char.
10213 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10214 eval to throw, when it gets a chance. If quit-flag is already
10215 non-nil, it stops the job right away. */
10218 interrupt_signal (signalnum
) /* If we don't have an argument, */
10219 int signalnum
; /* some compilers complain in signal calls. */
10222 /* Must preserve main program's value of errno. */
10223 int old_errno
= errno
;
10224 struct frame
*sf
= SELECTED_FRAME ();
10226 #if defined (USG) && !defined (POSIX_SIGNALS)
10227 if (!read_socket_hook
&& NILP (Vwindow_system
))
10229 /* USG systems forget handlers when they are used;
10230 must reestablish each time */
10231 signal (SIGINT
, interrupt_signal
);
10232 signal (SIGQUIT
, interrupt_signal
);
10238 if (!NILP (Vquit_flag
)
10239 && (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
)))
10241 /* If SIGINT isn't blocked, don't let us be interrupted by
10242 another SIGINT, it might be harmful due to non-reentrancy
10243 in I/O functions. */
10244 sigblock (sigmask (SIGINT
));
10247 reset_all_sys_modes ();
10249 #ifdef SIGTSTP /* Support possible in later USG versions */
10251 * On systems which can suspend the current process and return to the original
10252 * shell, this command causes the user to end up back at the shell.
10253 * The "Auto-save" and "Abort" questions are not asked until
10254 * the user elects to return to emacs, at which point he can save the current
10255 * job and either dump core or continue.
10260 if (sys_suspend () == -1)
10262 printf ("Not running as a subprocess;\n");
10263 printf ("you can continue or abort.\n");
10265 #else /* not VMS */
10266 /* Perhaps should really fork an inferior shell?
10267 But that would not provide any way to get back
10268 to the original shell, ever. */
10269 printf ("No support for stopping a process on this operating system;\n");
10270 printf ("you can continue or abort.\n");
10271 #endif /* not VMS */
10272 #endif /* not SIGTSTP */
10274 /* We must remain inside the screen area when the internal terminal
10275 is used. Note that [Enter] is not echoed by dos. */
10278 /* It doesn't work to autosave while GC is in progress;
10279 the code used for auto-saving doesn't cope with the mark bit. */
10280 if (!gc_in_progress
)
10282 printf ("Auto-save? (y or n) ");
10284 if (((c
= getchar ()) & ~040) == 'Y')
10286 Fdo_auto_save (Qt
, Qnil
);
10288 printf ("\r\nAuto-save done");
10289 #else /* not MSDOS */
10290 printf ("Auto-save done\n");
10291 #endif /* not MSDOS */
10293 while (c
!= '\n') c
= getchar ();
10297 /* During GC, it must be safe to reenable quitting again. */
10298 Vinhibit_quit
= Qnil
;
10301 #endif /* not MSDOS */
10302 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10303 printf ("but will instead do a real quit after garbage collection ends\r\n");
10308 printf ("\r\nAbort? (y or n) ");
10309 #else /* not MSDOS */
10311 printf ("Abort (and enter debugger)? (y or n) ");
10312 #else /* not VMS */
10313 printf ("Abort (and dump core)? (y or n) ");
10314 #endif /* not VMS */
10315 #endif /* not MSDOS */
10317 if (((c
= getchar ()) & ~040) == 'Y')
10319 while (c
!= '\n') c
= getchar ();
10321 printf ("\r\nContinuing...\r\n");
10322 #else /* not MSDOS */
10323 printf ("Continuing...\n");
10324 #endif /* not MSDOS */
10326 init_all_sys_modes ();
10331 /* If executing a function that wants to be interrupted out of
10332 and the user has not deferred quitting by binding `inhibit-quit'
10333 then quit right away. */
10334 if (immediate_quit
&& NILP (Vinhibit_quit
))
10336 struct gl_state_s saved
;
10337 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10339 immediate_quit
= 0;
10342 GCPRO4 (saved
.object
, saved
.global_code
,
10343 saved
.current_syntax_table
, saved
.old_prop
);
10344 Fsignal (Qquit
, Qnil
);
10349 /* Else request quit when it's safe */
10353 if (waiting_for_input
&& !echoing
)
10354 quit_throw_to_read_char ();
10359 /* Handle a C-g by making read_char return C-g. */
10362 quit_throw_to_read_char ()
10365 /* Prevent another signal from doing this before we finish. */
10366 clear_waiting_for_input ();
10369 Vunread_command_events
= Qnil
;
10370 unread_command_char
= -1;
10372 #if 0 /* Currently, sit_for is called from read_char without turning
10373 off polling. And that can call set_waiting_for_input.
10374 It seems to be harmless. */
10375 #ifdef POLL_FOR_INPUT
10376 /* May be > 1 if in recursive minibuffer. */
10377 if (poll_suppress_count
== 0)
10381 if (FRAMEP (internal_last_event_frame
)
10382 && !EQ (internal_last_event_frame
, selected_frame
))
10383 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10386 _longjmp (getcjmp
, 1);
10389 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
10390 doc
: /* Set mode of reading keyboard input.
10391 First arg INTERRUPT non-nil means use input interrupts;
10392 nil means use CBREAK mode.
10393 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10394 (no effect except in CBREAK mode).
10395 Third arg META t means accept 8-bit input (for a Meta key).
10396 META nil means ignore the top bit, on the assumption it is parity.
10397 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10398 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10399 See also `current-input-mode'. */)
10400 (interrupt
, flow
, meta
, quit
)
10401 Lisp_Object interrupt
, flow
, meta
, quit
;
10404 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
10405 error ("set-input-mode: QUIT must be an ASCII character");
10407 #ifdef POLL_FOR_INPUT
10412 /* this causes startup screen to be restored and messes with the mouse */
10413 reset_all_sys_modes ();
10417 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10418 if (read_socket_hook
)
10420 /* When using X, don't give the user a real choice,
10421 because we haven't implemented the mechanisms to support it. */
10422 #ifdef NO_SOCK_SIGIO
10423 interrupt_input
= 0;
10424 #else /* not NO_SOCK_SIGIO */
10425 interrupt_input
= 1;
10426 #endif /* NO_SOCK_SIGIO */
10429 interrupt_input
= !NILP (interrupt
);
10430 #else /* not SIGIO */
10431 interrupt_input
= 0;
10432 #endif /* not SIGIO */
10434 /* Our VMS input only works by interrupts, as of now. */
10436 interrupt_input
= 1;
10439 flow_control
= !NILP (flow
);
10442 else if (EQ (meta
, Qt
))
10447 /* Don't let this value be out of range. */
10448 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
10451 init_all_sys_modes ();
10454 #ifdef POLL_FOR_INPUT
10455 poll_suppress_count
= 1;
10461 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
10462 doc
: /* Return information about the way Emacs currently reads keyboard input.
10463 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10464 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10465 nil, Emacs is using CBREAK mode.
10466 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10467 terminal; this does not apply if Emacs uses interrupt-driven input.
10468 META is t if accepting 8-bit input with 8th bit as Meta flag.
10469 META nil means ignoring the top bit, on the assumption it is parity.
10470 META is neither t nor nil if accepting 8-bit input and using
10471 all 8 bits as the character code.
10472 QUIT is the character Emacs currently uses to quit.
10473 The elements of this list correspond to the arguments of
10474 `set-input-mode'. */)
10477 Lisp_Object val
[4];
10479 val
[0] = interrupt_input
? Qt
: Qnil
;
10480 val
[1] = flow_control
? Qt
: Qnil
;
10481 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
10482 XSETFASTINT (val
[3], quit_char
);
10484 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
10489 * Set up a new kboard object with reasonable initial values.
10495 kb
->Voverriding_terminal_local_map
= Qnil
;
10496 kb
->Vlast_command
= Qnil
;
10497 kb
->Vreal_last_command
= Qnil
;
10498 kb
->Vprefix_arg
= Qnil
;
10499 kb
->Vlast_prefix_arg
= Qnil
;
10500 kb
->kbd_queue
= Qnil
;
10501 kb
->kbd_queue_has_data
= 0;
10502 kb
->immediate_echo
= 0;
10503 kb
->echo_string
= Qnil
;
10504 kb
->echo_after_prompt
= -1;
10505 kb
->kbd_macro_buffer
= 0;
10506 kb
->kbd_macro_bufsize
= 0;
10507 kb
->defining_kbd_macro
= Qnil
;
10508 kb
->Vlast_kbd_macro
= Qnil
;
10509 kb
->reference_count
= 0;
10510 kb
->Vsystem_key_alist
= Qnil
;
10511 kb
->system_key_syms
= Qnil
;
10512 kb
->Vdefault_minibuffer_frame
= Qnil
;
10516 * Destroy the contents of a kboard object, but not the object itself.
10517 * We use this just before deleting it, or if we're going to initialize
10518 * it a second time.
10524 if (kb
->kbd_macro_buffer
)
10525 xfree (kb
->kbd_macro_buffer
);
10528 #ifdef MULTI_KBOARD
10530 /* Free KB and memory referenced from it. */
10538 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
10541 *kbp
= kb
->next_kboard
;
10543 /* Prevent a dangling reference to KB. */
10544 if (kb
== current_kboard
10545 && FRAMEP (selected_frame
)
10546 && FRAME_LIVE_P (XFRAME (selected_frame
)))
10548 current_kboard
= XFRAME (selected_frame
)->kboard
;
10549 if (current_kboard
== kb
)
10557 #endif /* MULTI_KBOARD */
10562 /* This is correct before outermost invocation of the editor loop */
10563 command_loop_level
= -1;
10564 immediate_quit
= 0;
10565 quit_char
= Ctl ('g');
10566 Vunread_command_events
= Qnil
;
10567 unread_command_char
= -1;
10568 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
10570 recent_keys_index
= 0;
10571 kbd_fetch_ptr
= kbd_buffer
;
10572 kbd_store_ptr
= kbd_buffer
;
10573 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10575 do_mouse_tracking
= Qnil
;
10579 /* This means that command_loop_1 won't try to select anything the first
10581 internal_last_event_frame
= Qnil
;
10582 Vlast_event_frame
= internal_last_event_frame
;
10584 #ifdef MULTI_KBOARD
10585 current_kboard
= initial_kboard
;
10587 wipe_kboard (current_kboard
);
10588 init_kboard (current_kboard
);
10590 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
10592 signal (SIGINT
, interrupt_signal
);
10593 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
10594 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10595 SIGQUIT and we can't tell which one it will give us. */
10596 signal (SIGQUIT
, interrupt_signal
);
10597 #endif /* HAVE_TERMIO */
10599 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10601 if (!noninteractive
)
10602 signal (SIGIO
, input_available_signal
);
10605 /* Use interrupt input by default, if it works and noninterrupt input
10606 has deficiencies. */
10608 #ifdef INTERRUPT_INPUT
10609 interrupt_input
= 1;
10611 interrupt_input
= 0;
10614 /* Our VMS input only works by interrupts, as of now. */
10616 interrupt_input
= 1;
10622 if (keyboard_init_hook
)
10623 (*keyboard_init_hook
) ();
10625 #ifdef POLL_FOR_INPUT
10626 poll_suppress_count
= 1;
10631 /* At least provide an escape route since C-g doesn't work. */
10632 signal (SIGINT
, interrupt_signal
);
10636 /* This type's only use is in syms_of_keyboard, to initialize the
10637 event header symbols and put properties on them. */
10638 struct event_head
{
10644 struct event_head head_table
[] = {
10645 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
10646 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
10647 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
10648 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
10649 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
10650 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
10651 /* `select-window' should be handled just like `switch-frame'
10652 in read_key_sequence. */
10653 {&Qselect_window
, "select-window", &Qswitch_frame
}
10657 syms_of_keyboard ()
10659 Vpre_help_message
= Qnil
;
10660 staticpro (&Vpre_help_message
);
10662 Vlispy_mouse_stem
= build_string ("mouse");
10663 staticpro (&Vlispy_mouse_stem
);
10666 QCimage
= intern (":image");
10667 staticpro (&QCimage
);
10669 staticpro (&Qhelp_echo
);
10670 Qhelp_echo
= intern ("help-echo");
10672 staticpro (&item_properties
);
10673 item_properties
= Qnil
;
10675 staticpro (&tool_bar_item_properties
);
10676 tool_bar_item_properties
= Qnil
;
10677 staticpro (&tool_bar_items_vector
);
10678 tool_bar_items_vector
= Qnil
;
10680 staticpro (&real_this_command
);
10681 real_this_command
= Qnil
;
10683 Qtimer_event_handler
= intern ("timer-event-handler");
10684 staticpro (&Qtimer_event_handler
);
10686 Qdisabled_command_hook
= intern ("disabled-command-hook");
10687 staticpro (&Qdisabled_command_hook
);
10689 Qself_insert_command
= intern ("self-insert-command");
10690 staticpro (&Qself_insert_command
);
10692 Qforward_char
= intern ("forward-char");
10693 staticpro (&Qforward_char
);
10695 Qbackward_char
= intern ("backward-char");
10696 staticpro (&Qbackward_char
);
10698 Qdisabled
= intern ("disabled");
10699 staticpro (&Qdisabled
);
10701 Qundefined
= intern ("undefined");
10702 staticpro (&Qundefined
);
10704 Qpre_command_hook
= intern ("pre-command-hook");
10705 staticpro (&Qpre_command_hook
);
10707 Qpost_command_hook
= intern ("post-command-hook");
10708 staticpro (&Qpost_command_hook
);
10710 Qpost_command_idle_hook
= intern ("post-command-idle-hook");
10711 staticpro (&Qpost_command_idle_hook
);
10713 Qdeferred_action_function
= intern ("deferred-action-function");
10714 staticpro (&Qdeferred_action_function
);
10716 Qcommand_hook_internal
= intern ("command-hook-internal");
10717 staticpro (&Qcommand_hook_internal
);
10719 Qfunction_key
= intern ("function-key");
10720 staticpro (&Qfunction_key
);
10721 Qmouse_click
= intern ("mouse-click");
10722 staticpro (&Qmouse_click
);
10724 Qlanguage_change
= intern ("language-change");
10725 staticpro (&Qlanguage_change
);
10727 Qdrag_n_drop
= intern ("drag-n-drop");
10728 staticpro (&Qdrag_n_drop
);
10730 Qsave_session
= intern ("save-session");
10731 staticpro(&Qsave_session
);
10733 Qusr1_signal
= intern ("usr1-signal");
10734 staticpro (&Qusr1_signal
);
10735 Qusr2_signal
= intern ("usr2-signal");
10736 staticpro (&Qusr2_signal
);
10738 Qmenu_enable
= intern ("menu-enable");
10739 staticpro (&Qmenu_enable
);
10740 Qmenu_alias
= intern ("menu-alias");
10741 staticpro (&Qmenu_alias
);
10742 QCenable
= intern (":enable");
10743 staticpro (&QCenable
);
10744 QCvisible
= intern (":visible");
10745 staticpro (&QCvisible
);
10746 QChelp
= intern (":help");
10747 staticpro (&QChelp
);
10748 QCfilter
= intern (":filter");
10749 staticpro (&QCfilter
);
10750 QCbutton
= intern (":button");
10751 staticpro (&QCbutton
);
10752 QCkeys
= intern (":keys");
10753 staticpro (&QCkeys
);
10754 QCkey_sequence
= intern (":key-sequence");
10755 staticpro (&QCkey_sequence
);
10756 QCtoggle
= intern (":toggle");
10757 staticpro (&QCtoggle
);
10758 QCradio
= intern (":radio");
10759 staticpro (&QCradio
);
10761 Qmode_line
= intern ("mode-line");
10762 staticpro (&Qmode_line
);
10763 Qvertical_line
= intern ("vertical-line");
10764 staticpro (&Qvertical_line
);
10765 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
10766 staticpro (&Qvertical_scroll_bar
);
10767 Qmenu_bar
= intern ("menu-bar");
10768 staticpro (&Qmenu_bar
);
10770 Qabove_handle
= intern ("above-handle");
10771 staticpro (&Qabove_handle
);
10772 Qhandle
= intern ("handle");
10773 staticpro (&Qhandle
);
10774 Qbelow_handle
= intern ("below-handle");
10775 staticpro (&Qbelow_handle
);
10776 Qup
= intern ("up");
10778 Qdown
= intern ("down");
10779 staticpro (&Qdown
);
10780 Qtop
= intern ("top");
10782 Qbottom
= intern ("bottom");
10783 staticpro (&Qbottom
);
10784 Qend_scroll
= intern ("end-scroll");
10785 staticpro (&Qend_scroll
);
10786 Qratio
= intern ("ratio");
10787 staticpro (&Qratio
);
10789 Qevent_kind
= intern ("event-kind");
10790 staticpro (&Qevent_kind
);
10791 Qevent_symbol_elements
= intern ("event-symbol-elements");
10792 staticpro (&Qevent_symbol_elements
);
10793 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
10794 staticpro (&Qevent_symbol_element_mask
);
10795 Qmodifier_cache
= intern ("modifier-cache");
10796 staticpro (&Qmodifier_cache
);
10798 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
10799 staticpro (&Qrecompute_lucid_menubar
);
10800 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
10801 staticpro (&Qactivate_menubar_hook
);
10803 Qpolling_period
= intern ("polling-period");
10804 staticpro (&Qpolling_period
);
10806 Qinput_method_function
= intern ("input-method-function");
10807 staticpro (&Qinput_method_function
);
10809 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
10810 staticpro (&Qinput_method_exit_on_first_char
);
10811 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
10812 staticpro (&Qinput_method_use_echo_area
);
10814 Fset (Qinput_method_exit_on_first_char
, Qnil
);
10815 Fset (Qinput_method_use_echo_area
, Qnil
);
10817 last_point_position_buffer
= Qnil
;
10820 struct event_head
*p
;
10822 for (p
= head_table
;
10823 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
10826 *p
->var
= intern (p
->name
);
10827 staticpro (p
->var
);
10828 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
10829 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
10833 button_down_location
= Fmake_vector (make_number (1), Qnil
);
10834 staticpro (&button_down_location
);
10835 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
10836 staticpro (&mouse_syms
);
10837 wheel_syms
= Fmake_vector (make_number (2), Qnil
);
10838 staticpro (&wheel_syms
);
10842 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
10844 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
10845 for (i
= 0; i
< len
; i
++)
10846 if (modifier_names
[i
])
10847 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
10848 staticpro (&modifier_symbols
);
10851 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
10852 staticpro (&recent_keys
);
10854 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
10855 staticpro (&this_command_keys
);
10857 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
10858 staticpro (&raw_keybuf
);
10860 Qextended_command_history
= intern ("extended-command-history");
10861 Fset (Qextended_command_history
, Qnil
);
10862 staticpro (&Qextended_command_history
);
10864 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10865 staticpro (&kbd_buffer_gcpro
);
10867 accent_key_syms
= Qnil
;
10868 staticpro (&accent_key_syms
);
10870 func_key_syms
= Qnil
;
10871 staticpro (&func_key_syms
);
10873 drag_n_drop_syms
= Qnil
;
10874 staticpro (&drag_n_drop_syms
);
10876 unread_switch_frame
= Qnil
;
10877 staticpro (&unread_switch_frame
);
10879 internal_last_event_frame
= Qnil
;
10880 staticpro (&internal_last_event_frame
);
10882 read_key_sequence_cmd
= Qnil
;
10883 staticpro (&read_key_sequence_cmd
);
10885 menu_bar_one_keymap_changed_items
= Qnil
;
10886 staticpro (&menu_bar_one_keymap_changed_items
);
10888 defsubr (&Sevent_convert_list
);
10889 defsubr (&Sread_key_sequence
);
10890 defsubr (&Sread_key_sequence_vector
);
10891 defsubr (&Srecursive_edit
);
10893 defsubr (&Strack_mouse
);
10895 defsubr (&Sinput_pending_p
);
10896 defsubr (&Scommand_execute
);
10897 defsubr (&Srecent_keys
);
10898 defsubr (&Sthis_command_keys
);
10899 defsubr (&Sthis_command_keys_vector
);
10900 defsubr (&Sthis_single_command_keys
);
10901 defsubr (&Sthis_single_command_raw_keys
);
10902 defsubr (&Sreset_this_command_lengths
);
10903 defsubr (&Sclear_this_command_keys
);
10904 defsubr (&Ssuspend_emacs
);
10905 defsubr (&Sabort_recursive_edit
);
10906 defsubr (&Sexit_recursive_edit
);
10907 defsubr (&Srecursion_depth
);
10908 defsubr (&Stop_level
);
10909 defsubr (&Sdiscard_input
);
10910 defsubr (&Sopen_dribble_file
);
10911 defsubr (&Sset_input_mode
);
10912 defsubr (&Scurrent_input_mode
);
10913 defsubr (&Sexecute_extended_command
);
10915 DEFVAR_LISP ("last-command-char", &last_command_char
,
10916 doc
: /* Last input event that was part of a command. */);
10918 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
10919 doc
: /* Last input event that was part of a command. */);
10921 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
10922 doc
: /* Last input event in a command, except for mouse menu events.
10923 Mouse menus give back keys that don't look like mouse events;
10924 this variable holds the actual mouse event that led to the menu,
10925 so that you can determine whether the command was run by mouse or not. */);
10927 DEFVAR_LISP ("last-input-char", &last_input_char
,
10928 doc
: /* Last input event. */);
10930 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
10931 doc
: /* Last input event. */);
10933 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
10934 doc
: /* List of events to be read as the command input.
10935 These events are processed first, before actual keyboard input. */);
10936 Vunread_command_events
= Qnil
;
10938 DEFVAR_INT ("unread-command-char", &unread_command_char
,
10939 doc
: /* If not -1, an object to be read as next command input event. */);
10941 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
10942 doc
: /* List of events to be processed as input by input methods.
10943 These events are processed after `unread-command-events', but
10944 before actual keyboard input. */);
10945 Vunread_post_input_method_events
= Qnil
;
10947 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
10948 doc
: /* List of events to be processed as input by input methods.
10949 These events are processed after `unread-command-events', but
10950 before actual keyboard input. */);
10951 Vunread_input_method_events
= Qnil
;
10953 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
10954 doc
: /* Meta-prefix character code.
10955 Meta-foo as command input turns into this character followed by foo. */);
10956 XSETINT (meta_prefix_char
, 033);
10958 DEFVAR_KBOARD ("last-command", Vlast_command
,
10959 doc
: /* The last command executed.
10960 Normally a symbol with a function definition, but can be whatever was found
10961 in the keymap, or whatever the variable `this-command' was set to by that
10964 The value `mode-exit' is special; it means that the previous command
10965 read an event that told it to exit, and it did so and unread that event.
10966 In other words, the present command is the event that made the previous
10969 The value `kill-region' is special; it means that the previous command
10970 was a kill command. */);
10972 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
10973 doc
: /* Same as `last-command', but never altered by Lisp code. */);
10975 DEFVAR_LISP ("this-command", &Vthis_command
,
10976 doc
: /* The command now being executed.
10977 The command can set this variable; whatever is put here
10978 will be in `last-command' during the following command. */);
10979 Vthis_command
= Qnil
;
10981 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
10982 doc
: /* The command bound to the current key sequence before remapping.
10983 It equals `this-command' if the original command was not remapped through
10984 any of the active keymaps. Otherwise, the value of `this-command' is the
10985 result of looking up the original command in the active keymaps. */);
10986 Vthis_original_command
= Qnil
;
10988 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
10989 doc
: /* *Number of input events between auto-saves.
10990 Zero means disable autosaving due to number of characters typed. */);
10991 auto_save_interval
= 300;
10993 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
10994 doc
: /* *Number of seconds idle time before auto-save.
10995 Zero or nil means disable auto-saving due to idleness.
10996 After auto-saving due to this many seconds of idle time,
10997 Emacs also does a garbage collection if that seems to be warranted. */);
10998 XSETFASTINT (Vauto_save_timeout
, 30);
11000 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
11001 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11002 The value may be integer or floating point. */);
11003 Vecho_keystrokes
= make_number (1);
11005 DEFVAR_INT ("polling-period", &polling_period
,
11006 doc
: /* *Interval between polling for input during Lisp execution.
11007 The reason for polling is to make C-g work to stop a running program.
11008 Polling is needed only when using X windows and SIGIO does not work.
11009 Polling is automatically disabled in all other cases. */);
11010 polling_period
= 2;
11012 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
11013 doc
: /* *Maximum time between mouse clicks to make a double-click.
11014 Measured in milliseconds. nil means disable double-click recognition;
11015 t means double-clicks have no time limit and are detected
11016 by position only. */);
11017 Vdouble_click_time
= make_number (500);
11019 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
11020 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11021 On window-system frames, value is the number of pixels the mouse may have
11022 moved horizontally or vertically between two clicks to make a double-click.
11023 On non window-system frames, value is interpreted in units of 1/8 characters
11026 This variable is also the threshold for motion of the mouse
11027 to count as a drag. */);
11028 double_click_fuzz
= 3;
11030 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
11031 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11032 inhibit_local_menu_bar_menus
= 0;
11034 DEFVAR_INT ("num-input-keys", &num_input_keys
,
11035 doc
: /* Number of complete key sequences read as input so far.
11036 This includes key sequences read from keyboard macros.
11037 The number is effectively the number of interactive command invocations. */);
11038 num_input_keys
= 0;
11040 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
11041 doc
: /* Number of input events read from the keyboard so far.
11042 This does not include events generated by keyboard macros. */);
11043 num_nonmacro_input_events
= 0;
11045 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
11046 doc
: /* The frame in which the most recently read event occurred.
11047 If the last event came from a keyboard macro, this is set to `macro'. */);
11048 Vlast_event_frame
= Qnil
;
11050 /* This variable is set up in sysdep.c. */
11051 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
11052 doc
: /* The ERASE character as set by the user with stty. */);
11054 DEFVAR_LISP ("help-char", &Vhelp_char
,
11055 doc
: /* Character to recognize as meaning Help.
11056 When it is read, do `(eval help-form)', and display result if it's a string.
11057 If the value of `help-form' is nil, this char can be read normally. */);
11058 XSETINT (Vhelp_char
, Ctl ('H'));
11060 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
11061 doc
: /* List of input events to recognize as meaning Help.
11062 These work just like the value of `help-char' (see that). */);
11063 Vhelp_event_list
= Qnil
;
11065 DEFVAR_LISP ("help-form", &Vhelp_form
,
11066 doc
: /* Form to execute when character `help-char' is read.
11067 If the form returns a string, that string is displayed.
11068 If `help-form' is nil, the help char is not recognized. */);
11071 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
11072 doc
: /* Command to run when `help-char' character follows a prefix key.
11073 This command is used only when there is no actual binding
11074 for that character after that prefix key. */);
11075 Vprefix_help_command
= Qnil
;
11077 DEFVAR_LISP ("top-level", &Vtop_level
,
11078 doc
: /* Form to evaluate when Emacs starts up.
11079 Useful to set before you dump a modified Emacs. */);
11082 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
11083 doc
: /* Translate table for keyboard input, or nil.
11084 Each character is looked up in this string and the contents used instead.
11085 The value may be a string, a vector, or a char-table.
11086 If it is a string or vector of length N,
11087 character codes N and up are untranslated.
11088 In a vector or a char-table, an element which is nil means "no translation".
11090 This is applied to the characters supplied to input methods, not their
11091 output. See also `translation-table-for-input'. */);
11092 Vkeyboard_translate_table
= Qnil
;
11094 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
11095 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11096 \(Even if the operating system has support for stopping a process.\) */);
11097 cannot_suspend
= 0;
11099 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
11100 doc
: /* Non-nil means prompt with menus when appropriate.
11101 This is done when reading from a keymap that has a prompt string,
11102 for elements that have prompt strings.
11103 The menu is displayed on the screen
11104 if X menus were enabled at configuration
11105 time and the previous event was a mouse click prefix key.
11106 Otherwise, menu prompting uses the echo area. */);
11107 menu_prompting
= 1;
11109 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
11110 doc
: /* Character to see next line of menu prompt.
11111 Type this character while in a menu prompt to rotate around the lines of it. */);
11112 XSETINT (menu_prompt_more_char
, ' ');
11114 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
11115 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11116 Emacs applies the modifiers of the character stored here to each keyboard
11117 character it reads. For example, after evaluating the expression
11118 (setq extra-keyboard-modifiers ?\\C-x)
11119 all input characters will have the control modifier applied to them.
11121 Note that the character ?\\C-@, equivalent to the integer zero, does
11122 not count as a control character; rather, it counts as a character
11123 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11124 cancels any modification. */);
11125 extra_keyboard_modifiers
= 0;
11127 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
11128 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11129 The command loop sets this to nil before each command,
11130 and tests the value when the command returns.
11131 Buffer modification stores t in this variable. */);
11132 Vdeactivate_mark
= Qnil
;
11134 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
11135 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
11136 Vcommand_hook_internal
= Qnil
;
11138 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
11139 doc
: /* Normal hook run before each command is executed.
11140 If an unhandled error happens in running this hook,
11141 the hook value is set to nil, since otherwise the error
11142 might happen repeatedly and make Emacs nonfunctional. */);
11143 Vpre_command_hook
= Qnil
;
11145 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
11146 doc
: /* Normal hook run after each command is executed.
11147 If an unhandled error happens in running this hook,
11148 the hook value is set to nil, since otherwise the error
11149 might happen repeatedly and make Emacs nonfunctional. */);
11150 Vpost_command_hook
= Qnil
;
11152 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook
,
11153 doc
: /* Normal hook run after each command is executed, if idle.
11154 Errors running the hook are caught and ignored. */);
11155 Vpost_command_idle_hook
= Qnil
;
11157 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay
,
11158 doc
: /* Delay time before running `post-command-idle-hook'.
11159 This is measured in microseconds. */);
11160 post_command_idle_delay
= 100000;
11163 DEFVAR_LISP ("echo-area-clear-hook", ...,
11164 doc
: /* Normal hook run when clearing the echo area. */);
11166 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
11167 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
11169 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
11170 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11171 Vlucid_menu_bar_dirty_flag
= Qnil
;
11173 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
11174 doc
: /* List of menu bar items to move to the end of the menu bar.
11175 The elements of the list are event types that may have menu bar bindings. */);
11176 Vmenu_bar_final_items
= Qnil
;
11178 DEFVAR_KBOARD ("overriding-terminal-local-map",
11179 Voverriding_terminal_local_map
,
11180 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11181 If this variable is non-nil, it is used as a keymap instead of the
11182 buffer's local map, and the minor mode keymaps and text property keymaps.
11183 This variable is intended to let commands such as `universal-argument'
11184 set up a different keymap for reading the next command. */);
11186 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
11187 doc
: /* Keymap that overrides all other local keymaps.
11188 If this variable is non-nil, it is used as a keymap instead of the
11189 buffer's local map, and the minor mode keymaps and text property keymaps. */);
11190 Voverriding_local_map
= Qnil
;
11192 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
11193 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11194 Otherwise, the menu bar continues to reflect the buffer's local map
11195 and the minor mode maps regardless of `overriding-local-map'. */);
11196 Voverriding_local_map_menu_flag
= Qnil
;
11198 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
11199 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11200 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
11202 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
11203 doc
: /* *Non-nil means generate motion events for mouse motion. */);
11205 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11206 doc
: /* Alist of system-specific X windows key symbols.
11207 Each element should have the form (N . SYMBOL) where N is the
11208 numeric keysym code (sans the \"system-specific\" bit 1<<28)
11209 and SYMBOL is its name. */);
11211 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
11212 doc
: /* List of deferred actions to be performed at a later time.
11213 The precise format isn't relevant here; we just check whether it is nil. */);
11214 Vdeferred_action_list
= Qnil
;
11216 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
11217 doc
: /* Function to call to handle deferred actions, after each command.
11218 This function is called with no arguments after each command
11219 whenever `deferred-action-list' is non-nil. */);
11220 Vdeferred_action_function
= Qnil
;
11222 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
11223 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
11224 The value can be a length of time to show the message for.
11225 If the value is non-nil and not a number, we wait 2 seconds. */);
11226 Vsuggest_key_bindings
= Qt
;
11228 DEFVAR_LISP ("timer-list", &Vtimer_list
,
11229 doc
: /* List of active absolute time timers in order of increasing time. */);
11230 Vtimer_list
= Qnil
;
11232 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
11233 doc
: /* List of active idle-time timers in order of increasing time. */);
11234 Vtimer_idle_list
= Qnil
;
11236 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
11237 doc
: /* If non-nil, the function that implements the current input method.
11238 It's called with one argument, a printing character that was just read.
11239 \(That means a character with code 040...0176.)
11240 Typically this function uses `read-event' to read additional events.
11241 When it does so, it should first bind `input-method-function' to nil
11242 so it will not be called recursively.
11244 The function should return a list of zero or more events
11245 to be used as input. If it wants to put back some events
11246 to be reconsidered, separately, by the input method,
11247 it can add them to the beginning of `unread-command-events'.
11249 The input method function can find in `input-method-previous-method'
11250 the previous echo area message.
11252 The input method function should refer to the variables
11253 `input-method-use-echo-area' and `input-method-exit-on-first-char'
11254 for guidance on what to do. */);
11255 Vinput_method_function
= Qnil
;
11257 DEFVAR_LISP ("input-method-previous-message",
11258 &Vinput_method_previous_message
,
11259 doc
: /* When `input-method-function' is called, hold the previous echo area message.
11260 This variable exists because `read-event' clears the echo area
11261 before running the input method. It is nil if there was no message. */);
11262 Vinput_method_previous_message
= Qnil
;
11264 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
11265 doc
: /* If non-nil, the function that implements the display of help.
11266 It's called with one argument, the help string to display. */);
11267 Vshow_help_function
= Qnil
;
11269 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
11270 doc
: /* If non-nil, suppress point adjustment after executing a command.
11272 After a command is executed, if point is moved into a region that has
11273 special properties (e.g. composition, display), we adjust point to
11274 the boundary of the region. But, several special commands sets this
11275 variable to non-nil, then we suppress the point adjustment.
11277 This variable is set to nil before reading a command, and is checked
11278 just after executing the command. */);
11279 Vdisable_point_adjustment
= Qnil
;
11281 DEFVAR_LISP ("global-disable-point-adjustment",
11282 &Vglobal_disable_point_adjustment
,
11283 doc
: /* *If non-nil, always suppress point adjustment.
11285 The default value is nil, in which case, point adjustment are
11286 suppressed only after special commands that set
11287 `disable-point-adjustment' (which see) to non-nil. */);
11288 Vglobal_disable_point_adjustment
= Qnil
;
11290 DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings
,
11291 doc
: /* Non-nil means updating menu bindings is allowed.
11292 A value of nil means menu bindings should not be updated.
11293 Used during Emacs' startup. */);
11294 update_menu_bindings
= 1;
11296 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
11297 doc
: /* *How long to display an echo-area message when the minibuffer is active.
11298 If the value is not a number, such messages don't time out. */);
11299 Vminibuffer_message_timeout
= make_number (2);
11303 keys_of_keyboard ()
11305 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
11306 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
11307 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
11308 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
11309 initial_define_key (meta_map
, 'x', "execute-extended-command");
11311 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
11312 "handle-delete-frame");
11313 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
11315 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
11317 /* Handling it at such a low-level causes read_key_sequence to get
11318 * confused because it doesn't realize that the current_buffer was
11319 * changed by read_char.
11321 * initial_define_lispy_key (Vspecial_event_map, "select-window",
11322 * "handle-select-window"); */
11323 initial_define_lispy_key (Vspecial_event_map
, "save-session",
11324 "handle-save-session");
11327 /* Mark the pointers in the kboard objects.
11328 Called by the Fgarbage_collector. */
11334 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
11336 if (kb
->kbd_macro_buffer
)
11337 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
11339 mark_object (kb
->Voverriding_terminal_local_map
);
11340 mark_object (kb
->Vlast_command
);
11341 mark_object (kb
->Vreal_last_command
);
11342 mark_object (kb
->Vprefix_arg
);
11343 mark_object (kb
->Vlast_prefix_arg
);
11344 mark_object (kb
->kbd_queue
);
11345 mark_object (kb
->defining_kbd_macro
);
11346 mark_object (kb
->Vlast_kbd_macro
);
11347 mark_object (kb
->Vsystem_key_alist
);
11348 mark_object (kb
->system_key_syms
);
11349 mark_object (kb
->Vdefault_minibuffer_frame
);
11350 mark_object (kb
->echo_string
);
11353 struct input_event
*event
;
11354 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
11356 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
11357 event
= kbd_buffer
;
11358 mark_object (event
->x
);
11359 mark_object (event
->y
);
11360 mark_object (event
->frame_or_window
);
11361 mark_object (event
->arg
);
11366 /* arch-tag: 774e34d7-6d31-42f3-8397-e079a4e4c9ca
11367 (do not change this comment) */