1 /* Keyboard and mouse input; editor command loop.
2 Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "termhooks.h"
35 #include "character.h"
37 #include "dispextern.h"
39 #include "intervals.h"
41 #include "blockinput.h"
53 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
60 #include <sys/types.h>
65 /* This is to get the definitions of the XK_ symbols. */
72 #endif /* HAVE_NTGUI */
82 /* Variables for blockinput.h: */
84 /* Non-zero if interrupt input is blocked right now. */
85 int interrupt_input_blocked
;
87 /* Nonzero means an input interrupt has arrived
88 during the current critical section. */
89 int interrupt_input_pending
;
92 /* File descriptor to use for input. */
95 #ifdef HAVE_WINDOW_SYSTEM
96 /* Make all keyboard buffers much bigger when using X windows. */
98 /* But not too big (local data > 32K error) if on macintosh. */
99 #define KBD_BUFFER_SIZE 512
101 #define KBD_BUFFER_SIZE 4096
103 #else /* No X-windows, character input */
104 #define KBD_BUFFER_SIZE 4096
105 #endif /* No X-windows */
107 #define abs(x) ((x) >= 0 ? (x) : -(x))
109 /* Following definition copied from eval.c */
113 struct backtrace
*next
;
114 Lisp_Object
*function
;
115 Lisp_Object
*args
; /* Points to vector of args. */
116 int nargs
; /* length of vector. If nargs is UNEVALLED,
117 args points to slot holding list of
123 KBOARD
*initial_kboard
;
124 KBOARD
*current_kboard
;
128 KBOARD the_only_kboard
;
131 /* Non-nil disable property on a command means
132 do not execute it; call disabled-command-hook's value instead. */
133 Lisp_Object Qdisabled
, Qdisabled_command_hook
;
135 #define NUM_RECENT_KEYS (100)
136 int recent_keys_index
; /* Index for storing next element into recent_keys */
137 int total_keys
; /* Total number of elements stored into recent_keys */
138 Lisp_Object recent_keys
; /* A vector, holding the last 100 keystrokes */
140 /* Vector holding the key sequence that invoked the current command.
141 It is reused for each command, and it may be longer than the current
142 sequence; this_command_key_count indicates how many elements
143 actually mean something.
144 It's easier to staticpro a single Lisp_Object than an array. */
145 Lisp_Object this_command_keys
;
146 int this_command_key_count
;
148 /* This vector is used as a buffer to record the events that were actually read
149 by read_key_sequence. */
150 Lisp_Object raw_keybuf
;
151 int raw_keybuf_count
;
153 #define GROW_RAW_KEYBUF \
154 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
156 int newsize = 2 * XVECTOR (raw_keybuf)->size; \
158 new = Fmake_vector (make_number (newsize), Qnil); \
159 bcopy (XVECTOR (raw_keybuf)->contents, XVECTOR (new)->contents, \
160 raw_keybuf_count * sizeof (Lisp_Object)); \
164 /* Number of elements of this_command_keys
165 that precede this key sequence. */
166 int this_single_command_key_start
;
168 /* Record values of this_command_key_count and echo_length ()
169 before this command was read. */
170 static int before_command_key_count
;
171 static int before_command_echo_length
;
172 /* Values of before_command_key_count and before_command_echo_length
173 saved by reset-this-command-lengths. */
174 static int before_command_key_count_1
;
175 static int before_command_echo_length_1
;
176 /* Flag set by reset-this-command-lengths,
177 saying to reset the lengths when add_command_key is called. */
178 static int before_command_restore_flag
;
180 extern int minbuf_level
;
182 extern int message_enable_multibyte
;
184 extern struct backtrace
*backtrace_list
;
186 /* If non-nil, the function that implements the display of help.
187 It's called with one argument, the help string to display. */
189 Lisp_Object Vshow_help_function
;
191 /* If a string, the message displayed before displaying a help-echo
194 Lisp_Object Vpre_help_message
;
196 /* Nonzero means do menu prompting. */
198 static int menu_prompting
;
200 /* Character to see next line of menu prompt. */
202 static Lisp_Object menu_prompt_more_char
;
204 /* For longjmp to where kbd input is being done. */
206 static jmp_buf getcjmp
;
208 /* True while doing kbd input. */
209 int waiting_for_input
;
211 /* True while displaying for echoing. Delays C-g throwing. */
215 /* Non-null means we can start echoing at the next input pause even
216 though there is something in the echo area. */
218 static struct kboard
*ok_to_echo_at_next_pause
;
220 /* The kboard last echoing, or null for none. Reset to 0 in
221 cancel_echoing. If non-null, and a current echo area message
222 exists, and echo_message_buffer is eq to the current message
223 buffer, we know that the message comes from echo_kboard. */
225 struct kboard
*echo_kboard
;
227 /* The buffer used for echoing. Set in echo_now, reset in
230 Lisp_Object echo_message_buffer
;
232 /* Nonzero means disregard local maps for the menu bar. */
233 static int inhibit_local_menu_bar_menus
;
235 /* Nonzero means C-g should cause immediate error-signal. */
238 /* The user's ERASE setting. */
239 Lisp_Object Vtty_erase_char
;
241 /* Character to recognize as the help char. */
242 Lisp_Object Vhelp_char
;
244 /* List of other event types to recognize as meaning "help". */
245 Lisp_Object Vhelp_event_list
;
247 /* Form to execute when help char is typed. */
248 Lisp_Object Vhelp_form
;
250 /* Command to run when the help character follows a prefix key. */
251 Lisp_Object Vprefix_help_command
;
253 /* List of items that should move to the end of the menu bar. */
254 Lisp_Object Vmenu_bar_final_items
;
256 /* Non-nil means show the equivalent key-binding for
257 any M-x command that has one.
258 The value can be a length of time to show the message for.
259 If the value is non-nil and not a number, we wait 2 seconds. */
260 Lisp_Object Vsuggest_key_bindings
;
262 /* How long to display an echo-area message when the minibuffer is active.
263 If the value is not a number, such messages don't time out. */
264 Lisp_Object Vminibuffer_message_timeout
;
266 /* Character that causes a quit. Normally C-g.
268 If we are running on an ordinary terminal, this must be an ordinary
269 ASCII char, since we want to make it our interrupt character.
271 If we are not running on an ordinary terminal, it still needs to be
272 an ordinary ASCII char. This character needs to be recognized in
273 the input interrupt handler. At this point, the keystroke is
274 represented as a struct input_event, while the desired quit
275 character is specified as a lispy event. The mapping from struct
276 input_events to lispy events cannot run in an interrupt handler,
277 and the reverse mapping is difficult for anything but ASCII
280 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
284 extern Lisp_Object current_global_map
;
285 extern int minibuf_level
;
287 /* If non-nil, this is a map that overrides all other local maps. */
288 Lisp_Object Voverriding_local_map
;
290 /* If non-nil, Voverriding_local_map applies to the menu bar. */
291 Lisp_Object Voverriding_local_map_menu_flag
;
293 /* Keymap that defines special misc events that should
294 be processed immediately at a low level. */
295 Lisp_Object Vspecial_event_map
;
297 /* Current depth in recursive edits. */
298 int command_loop_level
;
300 /* Total number of times command_loop has read a key sequence. */
303 /* Last input character read as a command. */
304 Lisp_Object last_command_char
;
306 /* Last input character read as a command, not counting menus
307 reached by the mouse. */
308 Lisp_Object last_nonmenu_event
;
310 /* Last input character read for any purpose. */
311 Lisp_Object last_input_char
;
313 /* If not Qnil, a list of objects to be read as subsequent command input. */
314 Lisp_Object Vunread_command_events
;
316 /* If not Qnil, a list of objects to be read as subsequent command input
317 including input method processing. */
318 Lisp_Object Vunread_input_method_events
;
320 /* If not Qnil, a list of objects to be read as subsequent command input
321 but NOT including input method processing. */
322 Lisp_Object Vunread_post_input_method_events
;
324 /* If not -1, an event to be read as subsequent command input. */
325 int unread_command_char
;
327 /* If not Qnil, this is a switch-frame event which we decided to put
328 off until the end of a key sequence. This should be read as the
329 next command input, after any unread_command_events.
331 read_key_sequence uses this to delay switch-frame events until the
332 end of the key sequence; Fread_char uses it to put off switch-frame
333 events until a non-ASCII event is acceptable as input. */
334 Lisp_Object unread_switch_frame
;
336 /* A mask of extra modifier bits to put into every keyboard char. */
337 int extra_keyboard_modifiers
;
339 /* Char to use as prefix when a meta character is typed in.
340 This is bound on entry to minibuffer in case ESC is changed there. */
342 Lisp_Object meta_prefix_char
;
344 /* Last size recorded for a current buffer which is not a minibuffer. */
345 static int last_non_minibuf_size
;
347 /* Number of idle seconds before an auto-save and garbage collection. */
348 static Lisp_Object Vauto_save_timeout
;
350 /* Total number of times read_char has returned. */
351 int num_input_events
;
353 /* Total number of times read_char has returned, outside of macros. */
354 int num_nonmacro_input_events
;
356 /* Auto-save automatically when this many characters have been typed
357 since the last time. */
359 static int auto_save_interval
;
361 /* Value of num_nonmacro_input_events as of last auto save. */
365 /* The command being executed by the command loop.
366 Commands may set this, and the value set will be copied into
367 current_kboard->Vlast_command instead of the actual command. */
368 Lisp_Object Vthis_command
;
370 /* This is like Vthis_command, except that commands never set it. */
371 Lisp_Object real_this_command
;
373 /* If the lookup of the command returns a binding, the original
374 command is stored in this-original-command. It is nil otherwise. */
375 Lisp_Object Vthis_original_command
;
377 /* The value of point when the last command was executed. */
378 int last_point_position
;
380 /* The buffer that was current when the last command was started. */
381 Lisp_Object last_point_position_buffer
;
383 /* The frame in which the last input event occurred, or Qmacro if the
384 last event came from a macro. We use this to determine when to
385 generate switch-frame events. This may be cleared by functions
386 like Fselect_frame, to make sure that a switch-frame event is
387 generated by the next character. */
388 Lisp_Object internal_last_event_frame
;
390 /* A user-visible version of the above, intended to allow users to
391 figure out where the last event came from, if the event doesn't
392 carry that information itself (i.e. if it was a character). */
393 Lisp_Object Vlast_event_frame
;
395 /* The timestamp of the last input event we received from the X server.
396 X Windows wants this for selection ownership. */
397 unsigned long last_event_timestamp
;
399 Lisp_Object Qself_insert_command
;
400 Lisp_Object Qforward_char
;
401 Lisp_Object Qbackward_char
;
402 Lisp_Object Qundefined
;
403 Lisp_Object Qtimer_event_handler
;
405 /* read_key_sequence stores here the command definition of the
406 key sequence that it reads. */
407 Lisp_Object read_key_sequence_cmd
;
409 /* Echo unfinished commands after this many seconds of pause. */
410 Lisp_Object Vecho_keystrokes
;
412 /* Form to evaluate (if non-nil) when Emacs is started. */
413 Lisp_Object Vtop_level
;
415 /* User-supplied string to translate input characters through. */
416 Lisp_Object Vkeyboard_translate_table
;
418 /* Keymap mapping ASCII function key sequences onto their preferred forms. */
419 extern Lisp_Object Vfunction_key_map
;
421 /* Another keymap that maps key sequences into key sequences.
422 This one takes precedence over ordinary definitions. */
423 extern Lisp_Object Vkey_translation_map
;
425 /* If non-nil, this implements the current input method. */
426 Lisp_Object Vinput_method_function
;
427 Lisp_Object Qinput_method_function
;
429 /* When we call Vinput_method_function,
430 this holds the echo area message that was just erased. */
431 Lisp_Object Vinput_method_previous_message
;
433 /* Non-nil means deactivate the mark at end of this command. */
434 Lisp_Object Vdeactivate_mark
;
436 /* Menu bar specified in Lucid Emacs fashion. */
438 Lisp_Object Vlucid_menu_bar_dirty_flag
;
439 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
441 Lisp_Object Qecho_area_clear_hook
;
443 /* Hooks to run before and after each command. */
444 Lisp_Object Qpre_command_hook
, Vpre_command_hook
;
445 Lisp_Object Qpost_command_hook
, Vpost_command_hook
;
446 Lisp_Object Qcommand_hook_internal
, Vcommand_hook_internal
;
447 /* Hook run after a command if there's no more input soon. */
448 Lisp_Object Qpost_command_idle_hook
, Vpost_command_idle_hook
;
450 /* Delay time in microseconds before running post-command-idle-hook. */
451 int post_command_idle_delay
;
453 /* List of deferred actions to be performed at a later time.
454 The precise format isn't relevant here; we just check whether it is nil. */
455 Lisp_Object Vdeferred_action_list
;
457 /* Function to call to handle deferred actions, when there are any. */
458 Lisp_Object Vdeferred_action_function
;
459 Lisp_Object Qdeferred_action_function
;
461 Lisp_Object Qinput_method_exit_on_first_char
;
462 Lisp_Object Qinput_method_use_echo_area
;
464 /* File in which we write all commands we read. */
467 /* Nonzero if input is available. */
470 /* 1 if should obey 0200 bit in input chars as "Meta", 2 if should
471 keep 0200 bit in input chars. 0 to ignore the 0200 bit. */
475 /* Non-zero means force key bindings update in parse_menu_item. */
477 int update_menu_bindings
;
479 extern char *pending_malloc_warning
;
481 /* Circular buffer for pre-read keyboard input. */
483 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
485 /* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
487 The interrupt-level event handlers will never enqueue an event on a
488 frame which is not in Vframe_list, and once an event is dequeued,
489 internal_last_event_frame or the event itself points to the frame.
492 But while the event is sitting in the queue, it's completely
493 unprotected. Suppose the user types one command which will run for
494 a while and then delete a frame, and then types another event at
495 the frame that will be deleted, before the command gets around to
496 it. Suppose there are no references to this frame elsewhere in
497 Emacs, and a GC occurs before the second event is dequeued. Now we
498 have an event referring to a freed frame, which will crash Emacs
501 Similar things happen when an event on a scroll bar is enqueued; the
502 window may be deleted while the event is in the queue.
504 So, we use this vector to protect the Lisp_Objects in the event
505 queue. That way, they'll be dequeued as dead frames or windows,
506 but still valid Lisp objects.
508 If kbd_buffer[i].kind != no_event, then
510 AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
511 AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg. */
513 static Lisp_Object kbd_buffer_gcpro
;
515 /* Pointer to next available character in kbd_buffer.
516 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
517 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
518 next available char is in kbd_buffer[0]. */
519 static struct input_event
*kbd_fetch_ptr
;
521 /* Pointer to next place to store character in kbd_buffer. This
522 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
523 character should go in kbd_buffer[0]. */
524 static struct input_event
* volatile kbd_store_ptr
;
526 /* The above pair of variables forms a "queue empty" flag. When we
527 enqueue a non-hook event, we increment kbd_store_ptr. When we
528 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
529 there is input available iff the two pointers are not equal.
531 Why not just have a flag set and cleared by the enqueuing and
532 dequeuing functions? Such a flag could be screwed up by interrupts
533 at inopportune times. */
535 /* If this flag is non-nil, we check mouse_moved to see when the
536 mouse moves, and motion events will appear in the input stream.
537 Otherwise, mouse motion is ignored. */
538 Lisp_Object do_mouse_tracking
;
540 /* Symbols to head events. */
541 Lisp_Object Qmouse_movement
;
542 Lisp_Object Qscroll_bar_movement
;
543 Lisp_Object Qswitch_frame
;
544 Lisp_Object Qdelete_frame
;
545 Lisp_Object Qiconify_frame
;
546 Lisp_Object Qmake_frame_visible
;
547 Lisp_Object Qhelp_echo
;
549 /* Symbols to denote kinds of events. */
550 Lisp_Object Qfunction_key
;
551 Lisp_Object Qmouse_click
;
553 Lisp_Object Qmouse_wheel
;
554 Lisp_Object Qlanguage_change
;
556 Lisp_Object Qdrag_n_drop
;
557 /* Lisp_Object Qmouse_movement; - also an event header */
559 /* Properties of event headers. */
560 Lisp_Object Qevent_kind
;
561 Lisp_Object Qevent_symbol_elements
;
563 /* menu item parts */
564 Lisp_Object Qmenu_alias
;
565 Lisp_Object Qmenu_enable
;
566 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
567 Lisp_Object QCbutton
, QCtoggle
, QCradio
;
568 extern Lisp_Object Vdefine_key_rebound_commands
;
569 extern Lisp_Object Qmenu_item
;
571 /* An event header symbol HEAD may have a property named
572 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
573 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
574 mask of modifiers applied to it. If present, this is used to help
575 speed up parse_modifiers. */
576 Lisp_Object Qevent_symbol_element_mask
;
578 /* An unmodified event header BASE may have a property named
579 Qmodifier_cache, which is an alist mapping modifier masks onto
580 modified versions of BASE. If present, this helps speed up
582 Lisp_Object Qmodifier_cache
;
584 /* Symbols to use for parts of windows. */
585 Lisp_Object Qmode_line
;
586 Lisp_Object Qvertical_line
;
587 Lisp_Object Qvertical_scroll_bar
;
588 Lisp_Object Qmenu_bar
;
590 Lisp_Object
recursive_edit_unwind (), command_loop ();
591 Lisp_Object
Fthis_command_keys ();
592 Lisp_Object Qextended_command_history
;
593 EMACS_TIME
timer_check ();
595 extern Lisp_Object Vhistory_length
;
597 extern char *x_get_keysym_name ();
599 static void record_menu_key ();
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 #ifdef HAVE_WINDOW_SYSTEM
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 valiable 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
;
664 /* Global variable declarations. */
666 /* Function for init_keyboard to call with no args (if nonzero). */
667 void (*keyboard_init_hook
) ();
669 static int read_avail_input
P_ ((int));
670 static void get_input_pending
P_ ((int *, int));
671 static int readable_events
P_ ((int));
672 static Lisp_Object read_char_x_menu_prompt
P_ ((int, Lisp_Object
*,
673 Lisp_Object
, int *));
674 static Lisp_Object
read_char_x_menu_prompt ();
675 static Lisp_Object read_char_minibuf_menu_prompt
P_ ((int, int,
677 static Lisp_Object make_lispy_event
P_ ((struct input_event
*));
679 static Lisp_Object make_lispy_movement
P_ ((struct frame
*, Lisp_Object
,
680 enum scroll_bar_part
,
681 Lisp_Object
, Lisp_Object
,
684 static Lisp_Object modify_event_symbol
P_ ((int, unsigned, Lisp_Object
,
685 Lisp_Object
, char **,
686 Lisp_Object
*, unsigned));
687 static Lisp_Object make_lispy_switch_frame
P_ ((Lisp_Object
));
688 static int parse_solitary_modifier
P_ ((Lisp_Object
));
689 static int parse_solitary_modifier ();
690 static void save_getcjmp
P_ ((jmp_buf));
691 static void save_getcjmp ();
692 static void restore_getcjmp
P_ ((jmp_buf));
693 static Lisp_Object apply_modifiers
P_ ((int, Lisp_Object
));
694 static void clear_event
P_ ((struct input_event
*));
695 static void any_kboard_state
P_ ((void));
697 /* Nonzero means don't try to suspend even if the operating system seems
699 static int cannot_suspend
;
701 /* Install the string STR as the beginning of the string of echoing,
702 so that it serves as a prompt for the next character.
703 Also start echoing. */
709 int nbytes
= STRING_BYTES (XSTRING (str
));
710 int multibyte_p
= STRING_MULTIBYTE (str
);
712 if (nbytes
> ECHOBUFSIZE
- 4)
716 /* Have to find the last character that fit's into the
718 unsigned char *p
= XSTRING (str
)->data
;
719 unsigned char *pend
= p
+ ECHOBUFSIZE
- 4;
724 PARSE_MULTIBYTE_SEQ (p
, pend
- p
, char_len
);
729 nbytes
= p
- XSTRING (str
)->data
- char_len
;
732 nbytes
= ECHOBUFSIZE
- 4;
735 nbytes
= copy_text (XSTRING (str
)->data
, current_kboard
->echobuf
, nbytes
,
736 STRING_MULTIBYTE (str
), 1);
737 current_kboard
->echoptr
= current_kboard
->echobuf
+ nbytes
;
738 *current_kboard
->echoptr
= '\0';
739 current_kboard
->echo_after_prompt
= nbytes
;
744 /* Add C to the echo string, if echoing is going on.
745 C can be a character, which is printed prettily ("M-C-x" and all that
746 jazz), or a symbol, whose name is printed. */
752 if (current_kboard
->immediate_echo
)
754 char *ptr
= current_kboard
->echoptr
;
756 if (ptr
!= current_kboard
->echobuf
)
759 /* If someone has passed us a composite event, use its head symbol. */
766 if (ptr
- current_kboard
->echobuf
767 > ECHOBUFSIZE
- KEY_DESCRIPTION_SIZE
)
770 ptr
= push_key_description (ch
, ptr
, 1);
772 else if (SYMBOLP (c
))
774 struct Lisp_String
*name
= XSYMBOL (c
)->name
;
775 if ((ptr
- current_kboard
->echobuf
) + STRING_BYTES (name
) + 4
778 ptr
+= copy_text (name
->data
, ptr
, STRING_BYTES (name
),
779 name
->size_byte
>= 0, 1);
782 if (current_kboard
->echoptr
== current_kboard
->echobuf
785 strcpy (ptr
, " (Type ? for further options)");
790 current_kboard
->echoptr
= ptr
;
796 /* Temporarily add a dash to the end of the echo string if it's not
797 empty, so that it serves as a mini-prompt for the very next character. */
802 if (!current_kboard
->immediate_echo
803 && current_kboard
->echoptr
== current_kboard
->echobuf
)
805 /* Do nothing if we just printed a prompt. */
806 if (current_kboard
->echo_after_prompt
807 == current_kboard
->echoptr
- current_kboard
->echobuf
)
809 /* Do nothing if not echoing at all. */
810 if (current_kboard
->echoptr
== 0)
813 /* Put a dash at the end of the buffer temporarily,
814 but make it go away when the next character is added. */
815 current_kboard
->echoptr
[0] = '-';
816 current_kboard
->echoptr
[1] = 0;
821 /* Display the current echo string, and begin echoing if not already
827 if (!current_kboard
->immediate_echo
)
830 current_kboard
->immediate_echo
= 1;
832 for (i
= 0; i
< this_command_key_count
; i
++)
835 c
= XVECTOR (this_command_keys
)->contents
[i
];
836 if (! (EVENT_HAS_PARAMETERS (c
)
837 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
844 message2_nolog (current_kboard
->echobuf
, strlen (current_kboard
->echobuf
),
848 /* Record in what buffer we echoed, and from which kboard. */
849 echo_message_buffer
= echo_area_buffer
[0];
850 echo_kboard
= current_kboard
;
852 if (waiting_for_input
&& !NILP (Vquit_flag
))
853 quit_throw_to_read_char ();
856 /* Turn off echoing, for the start of a new command. */
861 current_kboard
->immediate_echo
= 0;
862 current_kboard
->echoptr
= current_kboard
->echobuf
;
863 current_kboard
->echo_after_prompt
= -1;
864 ok_to_echo_at_next_pause
= NULL
;
866 echo_message_buffer
= Qnil
;
869 /* Return the length of the current echo string. */
874 return current_kboard
->echoptr
- current_kboard
->echobuf
;
877 /* Truncate the current echo message to its first LEN chars.
878 This and echo_char get used by read_key_sequence when the user
879 switches frames while entering a key sequence. */
885 current_kboard
->echobuf
[len
] = '\0';
886 current_kboard
->echoptr
= current_kboard
->echobuf
+ len
;
887 truncate_echo_area (len
);
891 /* Functions for manipulating this_command_keys. */
893 add_command_key (key
)
896 /* If reset-this-command-length was called recently, obey it now.
897 See the doc string of that function for an explanation of why. */
898 if (before_command_restore_flag
)
900 this_command_key_count
= before_command_key_count_1
;
901 if (this_command_key_count
< this_single_command_key_start
)
902 this_single_command_key_start
= this_command_key_count
;
903 echo_truncate (before_command_echo_length_1
);
904 before_command_restore_flag
= 0;
907 if (this_command_key_count
>= ASIZE (this_command_keys
))
908 this_command_keys
= larger_vector (this_command_keys
,
909 2 * ASIZE (this_command_keys
),
912 AREF (this_command_keys
, this_command_key_count
) = key
;
913 ++this_command_key_count
;
920 int count
= specpdl_ptr
- specpdl
;
923 if (command_loop_level
> 0)
925 specbind (Qstandard_output
, Qt
);
926 specbind (Qstandard_input
, Qt
);
929 #ifdef HAVE_X_WINDOWS
930 /* The command loop has started an hourglass timer, so we have to
931 cancel it here, otherwise it will fire because the recursive edit
932 can take some time. Do not check for display_hourglass_p here,
933 because it could already be nil. */
937 /* This function may have been called from a debugger called from
938 within redisplay, for instance by Edebugging a function called
939 from fontification-functions. We want to allow redisplay in
940 the debugging session.
942 The recursive edit is left with a `(throw exit ...)'. The `exit'
943 tag is not caught anywhere in redisplay, i.e. when we leave the
944 recursive edit, the original redisplay leading to the recursive
945 edit will be unwound. The outcome should therefore be safe. */
946 specbind (Qinhibit_redisplay
, Qnil
);
949 val
= command_loop ();
951 Fsignal (Qquit
, Qnil
);
952 /* Handle throw from read_minibuf when using minibuffer
953 while it's active but we're in another window. */
955 Fsignal (Qerror
, Fcons (val
, Qnil
));
957 return unbind_to (count
, Qnil
);
960 /* When an auto-save happens, record the "time", and don't do again soon. */
965 last_auto_save
= num_nonmacro_input_events
;
968 /* Make an auto save happen as soon as possible at command level. */
971 force_auto_save_soon ()
973 last_auto_save
= - auto_save_interval
- 1;
975 record_asynch_buffer_change ();
978 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
979 doc
: /* Invoke the editor command loop recursively.
980 To get out of the recursive edit, a command can do `(throw 'exit nil)';
981 that tells this function to return.
982 Alternately, `(throw 'exit t)' makes this function signal an error.
983 This function is called by the editor initialization to begin editing. */)
986 int count
= specpdl_ptr
- specpdl
;
989 command_loop_level
++;
990 update_mode_lines
= 1;
992 if (command_loop_level
993 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
994 buffer
= Fcurrent_buffer ();
998 /* If we leave recursive_edit_1 below with a `throw' for instance,
999 like it is done in the splash screen display, we have to
1000 make sure that we restore single_kboard as command_loop_1
1001 would have done if it were left normally. */
1002 record_unwind_protect (recursive_edit_unwind
,
1003 Fcons (buffer
, single_kboard
? Qt
: Qnil
));
1005 recursive_edit_1 ();
1006 return unbind_to (count
, Qnil
);
1010 recursive_edit_unwind (info
)
1013 if (BUFFERP (XCAR (info
)))
1014 Fset_buffer (XCAR (info
));
1016 if (NILP (XCDR (info
)))
1017 any_kboard_state ();
1019 single_kboard_state ();
1021 command_loop_level
--;
1022 update_mode_lines
= 1;
1031 #if 0 /* Theory: if there's anything in Vunread_command_events,
1032 it will right away be read by read_key_sequence,
1033 and then if we do switch KBOARDS, it will go into the side
1034 queue then. So we don't need to do anything special here -- rms. */
1035 if (CONSP (Vunread_command_events
))
1037 current_kboard
->kbd_queue
1038 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
1039 current_kboard
->kbd_queue_has_data
= 1;
1041 Vunread_command_events
= Qnil
;
1047 /* Switch to the single-kboard state, making current_kboard
1048 the only KBOARD from which further input is accepted. */
1051 single_kboard_state ()
1058 /* Maintain a stack of kboards, so other parts of Emacs
1059 can switch temporarily to the kboard of a given frame
1060 and then revert to the previous status. */
1065 struct kboard_stack
*next
;
1068 static struct kboard_stack
*kboard_stack
;
1071 push_frame_kboard (f
)
1075 struct kboard_stack
*p
1076 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
1078 p
->next
= kboard_stack
;
1079 p
->kboard
= current_kboard
;
1082 current_kboard
= FRAME_KBOARD (f
);
1090 struct kboard_stack
*p
= kboard_stack
;
1091 current_kboard
= p
->kboard
;
1092 kboard_stack
= p
->next
;
1097 /* Handle errors that are not handled at inner levels
1098 by printing an error message and returning to the editor command loop. */
1104 Lisp_Object old_level
, old_length
;
1105 char macroerror
[50];
1107 if (!NILP (executing_macro
))
1109 if (executing_macro_iterations
== 1)
1110 sprintf (macroerror
, "After 1 kbd macro iteration: ");
1112 sprintf (macroerror
, "After %d kbd macro iterations: ",
1113 executing_macro_iterations
);
1118 Vstandard_output
= Qt
;
1119 Vstandard_input
= Qt
;
1120 Vexecuting_macro
= Qnil
;
1121 executing_macro
= Qnil
;
1122 current_kboard
->Vprefix_arg
= Qnil
;
1123 current_kboard
->Vlast_prefix_arg
= Qnil
;
1126 /* Avoid unquittable loop if data contains a circular list. */
1127 old_level
= Vprint_level
;
1128 old_length
= Vprint_length
;
1129 XSETFASTINT (Vprint_level
, 10);
1130 XSETFASTINT (Vprint_length
, 10);
1131 cmd_error_internal (data
, macroerror
);
1132 Vprint_level
= old_level
;
1133 Vprint_length
= old_length
;
1137 Vinhibit_quit
= Qnil
;
1139 any_kboard_state ();
1142 return make_number (0);
1145 /* Take actions on handling an error. DATA is the data that describes
1148 CONTEXT is a C-string containing ASCII characters only which
1149 describes the context in which the error happened. If we need to
1150 generalize CONTEXT to allow multibyte characters, make it a Lisp
1154 cmd_error_internal (data
, context
)
1159 int kill_emacs_p
= 0;
1160 struct frame
*sf
= SELECTED_FRAME ();
1164 clear_message (1, 0);
1166 /* If the window system or terminal frame hasn't been initialized
1167 yet, or we're not interactive, it's best to dump this message out
1168 to stderr and exit. */
1169 if (!sf
->glyphs_initialized_p
1170 /* This is the case of the frame dumped with Emacs, when we're
1171 running under a window system. */
1172 || (!NILP (Vwindow_system
)
1173 && !inhibit_window_system
1174 && FRAME_TERMCAP_P (sf
))
1177 stream
= Qexternal_debugging_output
;
1188 write_string_1 (context
, -1, stream
);
1190 print_error_message (data
, stream
);
1192 /* If the window system or terminal frame hasn't been initialized
1193 yet, or we're in -batch mode, this error should cause Emacs to exit. */
1197 Fkill_emacs (make_number (-1));
1201 Lisp_Object
command_loop_1 ();
1202 Lisp_Object
command_loop_2 ();
1203 Lisp_Object
top_level_1 ();
1205 /* Entry to editor-command-loop.
1206 This level has the catches for exiting/returning to editor command loop.
1207 It returns nil to exit recursive edit, t to abort it. */
1212 if (command_loop_level
> 0 || minibuf_level
> 0)
1215 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1216 executing_macro
= Qnil
;
1222 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1223 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1224 executing_macro
= Qnil
;
1226 /* End of file in -batch run causes exit here. */
1232 /* Here we catch errors in execution of commands within the
1233 editing loop, and reenter the editing loop.
1234 When there is an error, cmd_error runs and returns a non-nil
1235 value to us. A value of nil means that cmd_loop_1 itself
1236 returned due to end of file (or end of kbd macro). */
1241 register Lisp_Object val
;
1244 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1245 while (!NILP (val
));
1253 return Feval (Vtop_level
);
1259 /* On entry to the outer level, run the startup file */
1260 if (!NILP (Vtop_level
))
1261 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1262 else if (!NILP (Vpurify_flag
))
1263 message ("Bare impure Emacs (standard Lisp code not loaded)");
1265 message ("Bare Emacs (standard Lisp code not loaded)");
1269 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1270 doc
: /* Exit all recursive editing levels. */)
1273 #ifdef HAVE_X_WINDOWS
1274 if (display_hourglass_p
)
1275 cancel_hourglass ();
1277 return Fthrow (Qtop_level
, Qnil
);
1280 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1281 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1284 if (command_loop_level
> 0 || minibuf_level
> 0)
1285 Fthrow (Qexit
, Qnil
);
1287 error ("No recursive edit is in progress");
1291 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1292 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1295 if (command_loop_level
> 0 || minibuf_level
> 0)
1298 error ("No recursive edit is in progress");
1302 /* This is the actual command reading loop,
1303 sans error-handling encapsulation. */
1305 static int read_key_sequence
P_ ((Lisp_Object
*, int, Lisp_Object
,
1307 void safe_run_hooks
P_ ((Lisp_Object
));
1308 static void adjust_point_for_property
P_ ((int));
1316 Lisp_Object keybuf
[30];
1320 struct buffer
*prev_buffer
= NULL
;
1322 int was_locked
= single_kboard
;
1325 current_kboard
->Vprefix_arg
= Qnil
;
1326 current_kboard
->Vlast_prefix_arg
= Qnil
;
1327 Vdeactivate_mark
= Qnil
;
1328 waiting_for_input
= 0;
1332 this_command_key_count
= 0;
1333 this_single_command_key_start
= 0;
1335 /* Make sure this hook runs after commands that get errors and
1336 throw to top level. */
1337 /* Note that the value cell will never directly contain nil
1338 if the symbol is a local variable. */
1339 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1340 safe_run_hooks (Qpost_command_hook
);
1342 /* If displaying a message, resize the echo area window to fit
1343 that message's size exactly. */
1344 if (!NILP (echo_area_buffer
[0]))
1345 resize_echo_area_exactly ();
1347 if (!NILP (Vdeferred_action_list
))
1348 call0 (Vdeferred_action_function
);
1350 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1352 if (NILP (Vunread_command_events
)
1353 && NILP (Vunread_input_method_events
)
1354 && NILP (Vunread_post_input_method_events
)
1355 && NILP (Vexecuting_macro
)
1356 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1357 safe_run_hooks (Qpost_command_idle_hook
);
1360 /* Do this after running Vpost_command_hook, for consistency. */
1361 current_kboard
->Vlast_command
= Vthis_command
;
1362 current_kboard
->Vreal_last_command
= real_this_command
;
1366 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1369 /* Make sure the current window's buffer is selected. */
1370 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1371 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1373 /* Display any malloc warning that just came out. Use while because
1374 displaying one warning can cause another. */
1376 while (pending_malloc_warning
)
1377 display_malloc_warning ();
1381 Vdeactivate_mark
= Qnil
;
1383 /* If minibuffer on and echo area in use,
1384 wait a short time and redraw minibuffer. */
1387 && !NILP (echo_area_buffer
[0])
1388 && EQ (minibuf_window
, echo_area_window
)
1389 && NUMBERP (Vminibuffer_message_timeout
))
1391 /* Bind inhibit-quit to t so that C-g gets read in
1392 rather than quitting back to the minibuffer. */
1393 int count
= specpdl_ptr
- specpdl
;
1394 specbind (Qinhibit_quit
, Qt
);
1396 Fsit_for (Vminibuffer_message_timeout
, Qnil
, Qnil
);
1397 /* Clear the echo area. */
1399 safe_run_hooks (Qecho_area_clear_hook
);
1401 unbind_to (count
, Qnil
);
1403 /* If a C-g came in before, treat it as input now. */
1404 if (!NILP (Vquit_flag
))
1407 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1412 alloca (0); /* Cause a garbage collection now */
1413 /* Since we can free the most stuff here. */
1414 #endif /* C_ALLOCA */
1417 /* Select the frame that the last event came from. Usually,
1418 switch-frame events will take care of this, but if some lisp
1419 code swallows a switch-frame event, we'll fix things up here.
1420 Is this a good idea? */
1421 if (FRAMEP (internal_last_event_frame
)
1422 && !EQ (internal_last_event_frame
, selected_frame
))
1423 Fselect_frame (internal_last_event_frame
, Qnil
);
1425 /* If it has changed current-menubar from previous value,
1426 really recompute the menubar from the value. */
1427 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1428 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1429 call0 (Qrecompute_lucid_menubar
);
1431 before_command_key_count
= this_command_key_count
;
1432 before_command_echo_length
= echo_length ();
1434 Vthis_command
= Qnil
;
1435 real_this_command
= Qnil
;
1437 /* Read next key sequence; i gets its length. */
1438 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1441 /* A filter may have run while we were reading the input. */
1442 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1444 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1445 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1449 /* Now we have read a key sequence of length I,
1450 or else I is 0 and we found end of file. */
1452 if (i
== 0) /* End of file -- happens only in */
1453 return Qnil
; /* a kbd macro, at the end. */
1454 /* -1 means read_key_sequence got a menu that was rejected.
1455 Just loop around and read another command. */
1459 this_command_key_count
= 0;
1460 this_single_command_key_start
= 0;
1464 last_command_char
= keybuf
[i
- 1];
1466 /* If the previous command tried to force a specific window-start,
1467 forget about that, in case this command moves point far away
1468 from that position. But also throw away beg_unchanged and
1469 end_unchanged information in that case, so that redisplay will
1470 update the whole window properly. */
1471 if (!NILP (XWINDOW (selected_window
)->force_start
))
1474 XWINDOW (selected_window
)->force_start
= Qnil
;
1475 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1476 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1479 cmd
= read_key_sequence_cmd
;
1480 if (!NILP (Vexecuting_macro
))
1482 if (!NILP (Vquit_flag
))
1484 Vexecuting_macro
= Qt
;
1485 QUIT
; /* Make some noise. */
1486 /* Will return since macro now empty. */
1490 /* Do redisplay processing after this command except in special
1491 cases identified below. */
1492 prev_buffer
= current_buffer
;
1493 prev_modiff
= MODIFF
;
1494 last_point_position
= PT
;
1495 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1497 /* By default, we adjust point to a boundary of a region that
1498 has such a property that should be treated intangible
1499 (e.g. composition, display). But, some commands will set
1500 this variable differently. */
1501 Vdisable_point_adjustment
= Qnil
;
1503 /* Process filters and timers may have messed with deactivate-mark.
1504 reset it before we execute the command. */
1505 Vdeactivate_mark
= Qnil
;
1507 /* Remap command through active keymaps */
1508 Vthis_original_command
= cmd
;
1512 if (cmd1
= Fremap_command (cmd
), !NILP (cmd1
))
1516 /* Execute the command. */
1518 Vthis_command
= cmd
;
1519 real_this_command
= cmd
;
1520 /* Note that the value cell will never directly contain nil
1521 if the symbol is a local variable. */
1522 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1523 safe_run_hooks (Qpre_command_hook
);
1525 if (NILP (Vthis_command
))
1527 /* nil means key is undefined. */
1529 current_kboard
->defining_kbd_macro
= Qnil
;
1530 update_mode_lines
= 1;
1531 current_kboard
->Vprefix_arg
= Qnil
;
1535 if (NILP (current_kboard
->Vprefix_arg
) && ! no_direct
)
1537 /* In case we jump to directly_done. */
1538 Vcurrent_prefix_arg
= current_kboard
->Vprefix_arg
;
1540 /* Recognize some common commands in common situations and
1541 do them directly. */
1542 if (EQ (Vthis_command
, Qforward_char
) && PT
< ZV
)
1544 struct Lisp_Char_Table
*dp
1545 = window_display_table (XWINDOW (selected_window
));
1546 lose
= FETCH_CHAR (PT_BYTE
);
1549 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1550 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1551 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1552 && (lose
>= 0x20 && lose
< 0x7f)))
1553 : (lose
>= 0x20 && lose
< 0x7f))
1554 /* To extract the case of continuation on
1555 wide-column characters. */
1556 && ASCII_BYTE_P (lose
)
1557 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1559 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1561 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1563 && !windows_or_buffers_changed
1564 && EQ (current_buffer
->selective_display
, Qnil
)
1565 && !detect_input_pending ()
1566 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1567 && NILP (Vexecuting_macro
))
1568 direct_output_forward_char (1);
1571 else if (EQ (Vthis_command
, Qbackward_char
) && PT
> BEGV
)
1573 struct Lisp_Char_Table
*dp
1574 = window_display_table (XWINDOW (selected_window
));
1576 lose
= FETCH_CHAR (PT_BYTE
);
1578 ? (VECTORP (DISP_CHAR_VECTOR (dp
, lose
))
1579 ? XVECTOR (DISP_CHAR_VECTOR (dp
, lose
))->size
== 1
1580 : (NILP (DISP_CHAR_VECTOR (dp
, lose
))
1581 && (lose
>= 0x20 && lose
< 0x7f)))
1582 : (lose
>= 0x20 && lose
< 0x7f))
1583 && (XFASTINT (XWINDOW (selected_window
)->last_modified
)
1585 && (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1587 && (XFASTINT (XWINDOW (selected_window
)->last_point
)
1589 && !windows_or_buffers_changed
1590 && EQ (current_buffer
->selective_display
, Qnil
)
1591 && !detect_input_pending ()
1592 && NILP (XWINDOW (selected_window
)->column_number_displayed
)
1593 && NILP (Vexecuting_macro
))
1594 direct_output_forward_char (-1);
1597 else if (EQ (Vthis_command
, Qself_insert_command
)
1598 /* Try this optimization only on ascii keystrokes. */
1599 && INTEGERP (last_command_char
))
1601 unsigned int c
= XINT (last_command_char
);
1603 if (NILP (Vexecuting_macro
)
1604 && !EQ (minibuf_window
, selected_window
))
1606 if (!nonundocount
|| nonundocount
>= 20)
1614 lose
= ((XFASTINT (XWINDOW (selected_window
)->last_modified
)
1616 || (XFASTINT (XWINDOW (selected_window
)->last_overlay_modified
)
1618 || (XFASTINT (XWINDOW (selected_window
)->last_point
)
1620 || MODIFF
<= SAVE_MODIFF
1621 || windows_or_buffers_changed
1622 || !EQ (current_buffer
->selective_display
, Qnil
)
1623 || detect_input_pending ()
1624 || !NILP (XWINDOW (selected_window
)->column_number_displayed
)
1625 || !NILP (Vexecuting_macro
));
1627 value
= internal_self_insert (c
, 0);
1632 /* VALUE == 1 when AFTER-CHANGE functions are
1633 installed which is the case most of the time
1634 because FONT-LOCK installs one. */
1635 if (!lose
&& !value
)
1636 direct_output_for_insert (c
);
1641 /* Here for a command that isn't executed directly */
1643 #ifdef HAVE_X_WINDOWS
1644 if (display_hourglass_p
)
1649 if (NILP (current_kboard
->Vprefix_arg
))
1651 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1653 #ifdef HAVE_X_WINDOWS
1654 /* Do not check display_hourglass_p here, because
1655 Fcommand_execute could change it, but we should cancel
1656 hourglass cursor anyway. */
1657 cancel_hourglass ();
1661 current_kboard
->Vlast_prefix_arg
= Vcurrent_prefix_arg
;
1663 /* Note that the value cell will never directly contain nil
1664 if the symbol is a local variable. */
1665 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1666 safe_run_hooks (Qpost_command_hook
);
1668 /* If displaying a message, resize the echo area window to fit
1669 that message's size exactly. */
1670 if (!NILP (echo_area_buffer
[0]))
1671 resize_echo_area_exactly ();
1673 if (!NILP (Vdeferred_action_list
))
1674 safe_run_hooks (Qdeferred_action_function
);
1676 if (!NILP (Vpost_command_idle_hook
) && !NILP (Vrun_hooks
))
1678 if (NILP (Vunread_command_events
)
1679 && NILP (Vunread_input_method_events
)
1680 && NILP (Vunread_post_input_method_events
)
1681 && NILP (Vexecuting_macro
)
1682 && !NILP (sit_for (0, post_command_idle_delay
, 0, 1, 1)))
1683 safe_run_hooks (Qpost_command_idle_hook
);
1686 /* If there is a prefix argument,
1687 1) We don't want Vlast_command to be ``universal-argument''
1688 (that would be dumb), so don't set Vlast_command,
1689 2) we want to leave echoing on so that the prefix will be
1690 echoed as part of this key sequence, so don't call
1692 3) we want to leave this_command_key_count non-zero, so that
1693 read_char will realize that it is re-reading a character, and
1694 not echo it a second time.
1696 If the command didn't actually create a prefix arg,
1697 but is merely a frame event that is transparent to prefix args,
1698 then the above doesn't apply. */
1699 if (NILP (current_kboard
->Vprefix_arg
) || CONSP (last_command_char
))
1701 current_kboard
->Vlast_command
= Vthis_command
;
1702 current_kboard
->Vreal_last_command
= real_this_command
;
1704 this_command_key_count
= 0;
1705 this_single_command_key_start
= 0;
1708 if (!NILP (current_buffer
->mark_active
) && !NILP (Vrun_hooks
))
1710 if (!NILP (Vdeactivate_mark
) && !NILP (Vtransient_mark_mode
))
1712 current_buffer
->mark_active
= Qnil
;
1713 call1 (Vrun_hooks
, intern ("deactivate-mark-hook"));
1715 else if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1716 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1721 if (current_buffer
== prev_buffer
1722 && last_point_position
!= PT
1723 && NILP (Vdisable_point_adjustment
)
1724 && NILP (Vglobal_disable_point_adjustment
))
1725 adjust_point_for_property (last_point_position
);
1727 /* Install chars successfully executed in kbd macro. */
1729 if (!NILP (current_kboard
->defining_kbd_macro
)
1730 && NILP (current_kboard
->Vprefix_arg
))
1731 finalize_kbd_macro_chars ();
1735 any_kboard_state ();
1740 extern Lisp_Object Qcomposition
, Qdisplay
;
1742 /* Adjust point to a boundary of a region that has such a property
1743 that should be treated intangible. For the moment, we check
1744 `composition' and `display' property. LAST_PT is the last position
1748 adjust_point_for_property (last_pt
)
1753 int check_composition
= 1, check_display
= 1;
1755 while (check_composition
|| check_display
)
1757 if (check_composition
1758 && PT
> BEGV
&& PT
< ZV
1759 && get_property_and_range (PT
, Qcomposition
, &val
, &start
, &end
, Qnil
)
1760 && COMPOSITION_VALID_P (start
, end
, val
)
1761 && start
< PT
&& end
> PT
1762 && (last_pt
<= start
|| last_pt
>= end
))
1770 check_composition
= 0;
1772 && PT
> BEGV
&& PT
< ZV
1773 && get_property_and_range (PT
, Qdisplay
, &val
, &start
, &end
, Qnil
)
1774 && display_prop_intangible_p (val
)
1775 && start
< PT
&& end
> PT
1776 && (last_pt
<= start
|| last_pt
>= end
))
1782 check_composition
= 1;
1788 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1791 safe_run_hooks_1 (hook
)
1794 return call1 (Vrun_hooks
, Vinhibit_quit
);
1797 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1800 safe_run_hooks_error (data
)
1803 return Fset (Vinhibit_quit
, Qnil
);
1806 /* If we get an error while running the hook, cause the hook variable
1807 to be nil. Also inhibit quits, so that C-g won't cause the hook
1808 to mysteriously evaporate. */
1811 safe_run_hooks (hook
)
1814 int count
= specpdl_ptr
- specpdl
;
1815 specbind (Qinhibit_quit
, hook
);
1817 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
1819 unbind_to (count
, Qnil
);
1823 /* Number of seconds between polling for input. This is a Lisp
1824 variable that can be bound. */
1828 /* Nonzero means polling for input is temporarily suppressed. */
1830 int poll_suppress_count
;
1832 /* Asynchronous timer for polling. */
1834 struct atimer
*poll_timer
;
1837 #ifdef POLL_FOR_INPUT
1839 /* Poll for input, so what we catch a C-g if it comes in. This
1840 function is called from x_make_frame_visible, see comment
1846 if (interrupt_input_blocked
== 0
1847 && !waiting_for_input
)
1848 read_avail_input (0);
1851 /* Timer callback function for poll_timer. TIMER is equal to
1855 poll_for_input (timer
)
1856 struct atimer
*timer
;
1858 if (poll_suppress_count
== 0)
1859 poll_for_input_1 ();
1862 #endif /* POLL_FOR_INPUT */
1864 /* Begin signals to poll for input, if they are appropriate.
1865 This function is called unconditionally from various places. */
1870 #ifdef POLL_FOR_INPUT
1871 if (read_socket_hook
&& !interrupt_input
)
1873 /* Turn alarm handling on unconditionally. It might have
1874 been turned off in process.c. */
1875 turn_on_atimers (1);
1877 /* If poll timer doesn't exist, are we need one with
1878 a different interval, start a new one. */
1879 if (poll_timer
== NULL
1880 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
1882 EMACS_TIME interval
;
1885 cancel_atimer (poll_timer
);
1887 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
1888 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
1889 poll_for_input
, NULL
);
1892 /* Let the timer's callback function poll for input
1893 if this becomes zero. */
1894 --poll_suppress_count
;
1899 /* Nonzero if we are using polling to handle input asynchronously. */
1902 input_polling_used ()
1904 #ifdef POLL_FOR_INPUT
1905 return read_socket_hook
&& !interrupt_input
;
1911 /* Turn off polling. */
1916 #ifdef POLL_FOR_INPUT
1917 if (read_socket_hook
&& !interrupt_input
)
1918 ++poll_suppress_count
;
1922 /* Set the value of poll_suppress_count to COUNT
1923 and start or stop polling accordingly. */
1926 set_poll_suppress_count (count
)
1929 #ifdef POLL_FOR_INPUT
1930 if (count
== 0 && poll_suppress_count
!= 0)
1932 poll_suppress_count
= 1;
1935 else if (count
!= 0 && poll_suppress_count
== 0)
1939 poll_suppress_count
= count
;
1943 /* Bind polling_period to a value at least N.
1944 But don't decrease it. */
1947 bind_polling_period (n
)
1950 #ifdef POLL_FOR_INPUT
1951 int new = polling_period
;
1956 stop_other_atimers (poll_timer
);
1958 specbind (Qpolling_period
, make_number (new));
1959 /* Start a new alarm with the new period. */
1964 /* Apply the control modifier to CHARACTER. */
1970 /* Save the upper bits here. */
1971 int upper
= c
& ~0177;
1975 /* Everything in the columns containing the upper-case letters
1976 denotes a control character. */
1977 if (c
>= 0100 && c
< 0140)
1981 /* Set the shift modifier for a control char
1982 made from a shifted letter. But only for letters! */
1983 if (oc
>= 'A' && oc
<= 'Z')
1984 c
|= shift_modifier
;
1987 /* The lower-case letters denote control characters too. */
1988 else if (c
>= 'a' && c
<= 'z')
1991 /* Include the bits for control and shift
1992 only if the basic ASCII code can't indicate them. */
1996 /* Replace the high bits. */
1997 c
|= (upper
& ~ctrl_modifier
);
2002 /* Display help echo in the echo area.
2004 HELP a string means display that string, HELP nil means clear the
2005 help echo. If HELP is a function, call it with OBJECT and POS as
2006 arguments; the function should return a help string or nil for
2007 none. For all other types of HELP evaluate it to obtain a string.
2009 WINDOW is the window in which the help was generated, if any.
2010 It is nil if not in a window.
2012 If OBJECT is a buffer, POS is the position in the buffer where the
2013 `help-echo' text property was found.
2015 If OBJECT is an overlay, that overlay has a `help-echo' property,
2016 and POS is the position in the overlay's buffer under the mouse.
2018 If OBJECT is a string (an overlay string or a string displayed with
2019 the `display' property). POS is the position in that string under
2022 OK_TO_IVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2023 echo overwrites a keystroke echo currently displayed in the echo
2026 Note: this function may only be called with HELP nil or a string
2027 from X code running asynchronously. */
2030 show_help_echo (help
, window
, object
, pos
, ok_to_overwrite_keystroke_echo
)
2031 Lisp_Object help
, window
, object
, pos
;
2032 int ok_to_overwrite_keystroke_echo
;
2034 if (!NILP (help
) && !STRINGP (help
))
2036 if (FUNCTIONP (help
))
2038 Lisp_Object args
[4];
2043 help
= safe_call (4, args
);
2046 help
= safe_eval (help
);
2048 if (!STRINGP (help
))
2052 if (STRINGP (help
) || NILP (help
))
2054 if (!NILP (Vshow_help_function
))
2055 call1 (Vshow_help_function
, help
);
2056 else if (/* Don't overwrite minibuffer contents. */
2057 !MINI_WINDOW_P (XWINDOW (selected_window
))
2058 /* Don't overwrite a keystroke echo. */
2059 && (NILP (echo_message_buffer
)
2060 || ok_to_overwrite_keystroke_echo
)
2061 /* Don't overwrite a prompt. */
2062 && !cursor_in_echo_area
)
2066 int count
= BINDING_STACK_SIZE ();
2068 if (!help_echo_showing_p
)
2069 Vpre_help_message
= current_message ();
2071 specbind (Qmessage_truncate_lines
, Qt
);
2072 message3_nolog (help
, STRING_BYTES (XSTRING (help
)),
2073 STRING_MULTIBYTE (help
));
2074 unbind_to (count
, Qnil
);
2076 else if (STRINGP (Vpre_help_message
))
2078 message3_nolog (Vpre_help_message
,
2079 STRING_BYTES (XSTRING (Vpre_help_message
)),
2080 STRING_MULTIBYTE (Vpre_help_message
));
2081 Vpre_help_message
= Qnil
;
2087 help_echo_showing_p
= STRINGP (help
);
2093 /* Input of single characters from keyboard */
2095 Lisp_Object
print_help ();
2096 static Lisp_Object
kbd_buffer_get_event ();
2097 static void record_char ();
2100 static jmp_buf wrong_kboard_jmpbuf
;
2103 /* read a character from the keyboard; call the redisplay if needed */
2104 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2105 -1 means do not do redisplay, but do do autosaving.
2108 /* The arguments MAPS and NMAPS are for menu prompting.
2109 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2111 PREV_EVENT is the previous input event, or nil if we are reading
2112 the first event of a key sequence (or not reading a key sequence).
2113 If PREV_EVENT is t, that is a "magic" value that says
2114 not to run input methods, but in other respects to act as if
2115 not reading a key sequence.
2117 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2118 if we used a mouse menu to read the input, or zero otherwise. If
2119 USED_MOUSE_MENU is null, we don't dereference it.
2121 Value is t if we showed a menu and the user rejected it. */
2124 read_char (commandflag
, nmaps
, maps
, prev_event
, used_mouse_menu
)
2128 Lisp_Object prev_event
;
2129 int *used_mouse_menu
;
2131 volatile Lisp_Object c
;
2133 jmp_buf local_getcjmp
;
2135 volatile int key_already_recorded
= 0;
2136 Lisp_Object tem
, save
;
2137 volatile Lisp_Object previous_echo_area_message
;
2138 volatile Lisp_Object also_record
;
2139 volatile int reread
;
2140 struct gcpro gcpro1
, gcpro2
;
2141 EMACS_TIME last_idle_start
;
2145 before_command_key_count
= this_command_key_count
;
2146 before_command_echo_length
= echo_length ();
2148 previous_echo_area_message
= Qnil
;
2150 GCPRO2 (c
, previous_echo_area_message
);
2155 if (CONSP (Vunread_post_input_method_events
))
2157 c
= XCAR (Vunread_post_input_method_events
);
2158 Vunread_post_input_method_events
2159 = XCDR (Vunread_post_input_method_events
);
2161 /* Undo what read_char_x_menu_prompt did when it unread
2162 additional keys returned by Fx_popup_menu. */
2164 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2172 if (unread_command_char
!= -1)
2174 XSETINT (c
, unread_command_char
);
2175 unread_command_char
= -1;
2181 if (CONSP (Vunread_command_events
))
2183 c
= XCAR (Vunread_command_events
);
2184 Vunread_command_events
= XCDR (Vunread_command_events
);
2186 /* Undo what read_char_x_menu_prompt did when it unread
2187 additional keys returned by Fx_popup_menu. */
2189 && EQ (XCDR (c
), Qdisabled
)
2190 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2193 /* If the queued event is something that used the mouse,
2194 set used_mouse_menu accordingly. */
2196 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
)))
2197 *used_mouse_menu
= 1;
2200 goto reread_for_input_method
;
2203 if (CONSP (Vunread_input_method_events
))
2205 c
= XCAR (Vunread_input_method_events
);
2206 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2208 /* Undo what read_char_x_menu_prompt did when it unread
2209 additional keys returned by Fx_popup_menu. */
2211 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2215 goto reread_for_input_method
;
2218 /* If there is no function key translated before
2219 reset-this-command-lengths takes effect, forget about it. */
2220 before_command_restore_flag
= 0;
2222 if (!NILP (Vexecuting_macro
))
2224 /* We set this to Qmacro; since that's not a frame, nobody will
2225 try to switch frames on us, and the selected window will
2228 Since this event came from a macro, it would be misleading to
2229 leave internal_last_event_frame set to wherever the last
2230 real event came from. Normally, a switch-frame event selects
2231 internal_last_event_frame after each command is read, but
2232 events read from a macro should never cause a new frame to be
2234 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2236 /* Exit the macro if we are at the end.
2237 Also, some things replace the macro with t
2238 to force an early exit. */
2239 if (EQ (Vexecuting_macro
, Qt
)
2240 || executing_macro_index
>= XFASTINT (Flength (Vexecuting_macro
)))
2246 c
= Faref (Vexecuting_macro
, make_number (executing_macro_index
));
2247 if (STRINGP (Vexecuting_macro
)
2248 && (XINT (c
) & 0x80))
2249 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2251 executing_macro_index
++;
2256 if (!NILP (unread_switch_frame
))
2258 c
= unread_switch_frame
;
2259 unread_switch_frame
= Qnil
;
2261 /* This event should make it into this_command_keys, and get echoed
2262 again, so we do not set `reread'. */
2266 /* if redisplay was requested */
2267 if (commandflag
>= 0)
2269 /* If there is pending input, process any events which are not
2270 user-visible, such as X selection_request events. */
2272 || detect_input_pending_run_timers (0))
2273 swallow_events (0); /* may clear input_pending */
2275 /* Redisplay if no pending input. */
2276 while (!input_pending
)
2278 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2279 redisplay_preserve_echo_area (5);
2284 /* Normal case: no input arrived during redisplay. */
2287 /* Input arrived and pre-empted redisplay.
2288 Process any events which are not user-visible. */
2290 /* If that cleared input_pending, try again to redisplay. */
2294 /* Message turns off echoing unless more keystrokes turn it on again.
2296 The code in 20.x for the condition was
2298 1. echo_area_glyphs && *echo_area_glyphs
2299 2. && echo_area_glyphs != current_kboard->echobuf
2300 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2302 (1) means there's a current message displayed
2304 (2) means it's not the message from echoing from the current
2307 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2308 is set to a non-null value. This is done in read_char and it is
2309 set to echo_area_glyphs after a call to echo_char. That means
2310 ok_to_echo_at_next_pause is either null or
2311 current_kboard->echobuf with the appropriate current_kboard at
2314 So, condition (3) means in clear text ok_to_echo_at_next_pause
2315 must be either null, or the current message isn't from echoing at
2316 all, or it's from echoing from a different kboard than the
2319 if (/* There currently something in the echo area */
2320 !NILP (echo_area_buffer
[0])
2321 && (/* And it's either not from echoing. */
2322 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2323 /* Or it's an echo from a different kboard. */
2324 || echo_kboard
!= current_kboard
2325 /* Or we explicitly allow overwriting whatever there is. */
2326 || ok_to_echo_at_next_pause
== NULL
))
2331 /* Try reading a character via menu prompting in the minibuf.
2332 Try this before the sit-for, because the sit-for
2333 would do the wrong thing if we are supposed to do
2334 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2335 after a mouse event so don't try a minibuf menu. */
2337 if (nmaps
> 0 && INTERACTIVE
2338 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2339 /* Don't bring up a menu if we already have another event. */
2340 && NILP (Vunread_command_events
)
2341 && unread_command_char
< 0
2342 && !detect_input_pending_run_timers (0))
2344 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2347 key_already_recorded
= 1;
2352 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2353 We will do that below, temporarily for short sections of code,
2354 when appropriate. local_getcjmp must be in effect
2355 around any call to sit_for or kbd_buffer_get_event;
2356 it *must not* be in effect when we call redisplay. */
2358 if (_setjmp (local_getcjmp
))
2360 XSETINT (c
, quit_char
);
2361 internal_last_event_frame
= selected_frame
;
2362 Vlast_event_frame
= internal_last_event_frame
;
2363 /* If we report the quit char as an event,
2364 don't do so more than once. */
2365 if (!NILP (Vinhibit_quit
))
2370 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2371 if (kb
!= current_kboard
)
2373 Lisp_Object link
= kb
->kbd_queue
;
2374 /* We shouldn't get here if we were in single-kboard mode! */
2379 while (CONSP (XCDR (link
)))
2381 if (!NILP (XCDR (link
)))
2385 kb
->kbd_queue
= Fcons (c
, Qnil
);
2387 XSETCDR (link
, Fcons (c
, Qnil
));
2388 kb
->kbd_queue_has_data
= 1;
2389 current_kboard
= kb
;
2390 /* This is going to exit from read_char
2391 so we had better get rid of this frame's stuff. */
2393 longjmp (wrong_kboard_jmpbuf
, 1);
2400 timer_start_idle ();
2402 /* If in middle of key sequence and minibuffer not active,
2403 start echoing if enough time elapses. */
2405 if (minibuf_level
== 0
2406 && !current_kboard
->immediate_echo
2407 && this_command_key_count
> 0
2409 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2410 && NILP (Fzerop (Vecho_keystrokes
))
2411 && (/* No message. */
2412 NILP (echo_area_buffer
[0])
2413 /* Or empty message. */
2414 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2415 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2416 /* Or already echoing from same kboard. */
2417 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2418 /* Or not echoing before and echoing allowed. */
2419 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2423 /* After a mouse event, start echoing right away.
2424 This is because we are probably about to display a menu,
2425 and we don't want to delay before doing so. */
2426 if (EVENT_HAS_PARAMETERS (prev_event
))
2431 double duration
= extract_float (Vecho_keystrokes
);
2432 sec
= (int) duration
;
2433 usec
= (duration
- sec
) * 1000000;
2434 save_getcjmp (save_jump
);
2435 restore_getcjmp (local_getcjmp
);
2436 tem0
= sit_for (sec
, usec
, 1, 1, 0);
2437 restore_getcjmp (save_jump
);
2439 && ! CONSP (Vunread_command_events
))
2444 /* Maybe auto save due to number of keystrokes. */
2446 if (commandflag
!= 0
2447 && auto_save_interval
> 0
2448 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2449 && !detect_input_pending_run_timers (0))
2451 Fdo_auto_save (Qnil
, Qnil
);
2452 /* Hooks can actually change some buffers in auto save. */
2456 /* Try reading using an X menu.
2457 This is never confused with reading using the minibuf
2458 because the recursive call of read_char in read_char_minibuf_menu_prompt
2459 does not pass on any keymaps. */
2461 if (nmaps
> 0 && INTERACTIVE
2462 && !NILP (prev_event
)
2463 && EVENT_HAS_PARAMETERS (prev_event
)
2464 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2465 && !EQ (XCAR (prev_event
), Qtool_bar
)
2466 /* Don't bring up a menu if we already have another event. */
2467 && NILP (Vunread_command_events
)
2468 && unread_command_char
< 0)
2470 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2472 /* Now that we have read an event, Emacs is not idle. */
2478 /* Maybe autosave and/or garbage collect due to idleness. */
2480 if (INTERACTIVE
&& NILP (c
))
2482 int delay_level
, buffer_size
;
2484 /* Slow down auto saves logarithmically in size of current buffer,
2485 and garbage collect while we're at it. */
2486 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2487 last_non_minibuf_size
= Z
- BEG
;
2488 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2490 while (buffer_size
> 64)
2491 delay_level
++, buffer_size
-= buffer_size
>> 2;
2492 if (delay_level
< 4) delay_level
= 4;
2493 /* delay_level is 4 for files under around 50k, 7 at 100k,
2494 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2496 /* Auto save if enough time goes by without input. */
2497 if (commandflag
!= 0
2498 && num_nonmacro_input_events
> last_auto_save
2499 && INTEGERP (Vauto_save_timeout
)
2500 && XINT (Vauto_save_timeout
) > 0)
2504 save_getcjmp (save_jump
);
2505 restore_getcjmp (local_getcjmp
);
2506 tem0
= sit_for (delay_level
* XFASTINT (Vauto_save_timeout
) / 4,
2508 restore_getcjmp (save_jump
);
2511 && ! CONSP (Vunread_command_events
))
2513 Fdo_auto_save (Qnil
, Qnil
);
2515 /* If we have auto-saved and there is still no input
2516 available, garbage collect if there has been enough
2517 consing going on to make it worthwhile. */
2518 if (!detect_input_pending_run_timers (0)
2519 && consing_since_gc
> gc_cons_threshold
/ 2)
2520 Fgarbage_collect ();
2527 /* If this has become non-nil here, it has been set by a timer
2528 or sentinel or filter. */
2529 if (CONSP (Vunread_command_events
))
2531 c
= XCAR (Vunread_command_events
);
2532 Vunread_command_events
= XCDR (Vunread_command_events
);
2535 /* Read something from current KBOARD's side queue, if possible. */
2539 if (current_kboard
->kbd_queue_has_data
)
2541 if (!CONSP (current_kboard
->kbd_queue
))
2543 c
= XCAR (current_kboard
->kbd_queue
);
2544 current_kboard
->kbd_queue
2545 = XCDR (current_kboard
->kbd_queue
);
2546 if (NILP (current_kboard
->kbd_queue
))
2547 current_kboard
->kbd_queue_has_data
= 0;
2548 input_pending
= readable_events (0);
2549 if (EVENT_HAS_PARAMETERS (c
)
2550 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2551 internal_last_event_frame
= XCAR (XCDR (c
));
2552 Vlast_event_frame
= internal_last_event_frame
;
2557 /* If current_kboard's side queue is empty check the other kboards.
2558 If one of them has data that we have not yet seen here,
2559 switch to it and process the data waiting for it.
2561 Note: if the events queued up for another kboard
2562 have already been seen here, and therefore are not a complete command,
2563 the kbd_queue_has_data field is 0, so we skip that kboard here.
2564 That's to avoid an infinite loop switching between kboards here. */
2565 if (NILP (c
) && !single_kboard
)
2568 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2569 if (kb
->kbd_queue_has_data
)
2571 current_kboard
= kb
;
2572 /* This is going to exit from read_char
2573 so we had better get rid of this frame's stuff. */
2575 longjmp (wrong_kboard_jmpbuf
, 1);
2584 /* Finally, we read from the main queue,
2585 and if that gives us something we can't use yet, we put it on the
2586 appropriate side queue and try again. */
2592 /* Actually read a character, waiting if necessary. */
2593 save_getcjmp (save_jump
);
2594 restore_getcjmp (local_getcjmp
);
2595 timer_start_idle ();
2596 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
);
2597 restore_getcjmp (save_jump
);
2600 if (! NILP (c
) && (kb
!= current_kboard
))
2602 Lisp_Object link
= kb
->kbd_queue
;
2605 while (CONSP (XCDR (link
)))
2607 if (!NILP (XCDR (link
)))
2611 kb
->kbd_queue
= Fcons (c
, Qnil
);
2613 XSETCDR (link
, Fcons (c
, Qnil
));
2614 kb
->kbd_queue_has_data
= 1;
2618 current_kboard
= kb
;
2619 /* This is going to exit from read_char
2620 so we had better get rid of this frame's stuff. */
2622 longjmp (wrong_kboard_jmpbuf
, 1);
2627 /* Terminate Emacs in batch mode if at eof. */
2628 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2629 Fkill_emacs (make_number (1));
2633 /* Add in any extra modifiers, where appropriate. */
2634 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2635 || ((extra_keyboard_modifiers
& 0177) < ' '
2636 && (extra_keyboard_modifiers
& 0177) != 0))
2637 XSETINT (c
, make_ctrl_char (XINT (c
)));
2639 /* Transfer any other modifier bits directly from
2640 extra_keyboard_modifiers to c. Ignore the actual character code
2641 in the low 16 bits of extra_keyboard_modifiers. */
2642 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2647 /* Record the last idle start time so that we can reset it
2648 should the next event read be a help-echo. */
2649 last_idle_start
= timer_idleness_start_time
;
2655 if (commandflag
>= 0
2656 && !input_pending
&& !detect_input_pending_run_timers (0))
2664 /* Buffer switch events are only for internal wakeups
2665 so don't show them to the user.
2666 Also, don't record a key if we already did. */
2667 if (BUFFERP (c
) || key_already_recorded
)
2670 /* Process special events within read_char
2671 and loop around to read another event. */
2674 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2679 int was_locked
= single_kboard
;
2681 last_input_char
= c
;
2682 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_char
), Qt
);
2684 /* Resume allowing input from any kboard, if that was true before. */
2686 any_kboard_state ();
2691 /* Handle things that only apply to characters. */
2694 /* If kbd_buffer_get_event gave us an EOF, return that. */
2698 if ((STRINGP (Vkeyboard_translate_table
)
2699 && XSTRING (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2700 || (VECTORP (Vkeyboard_translate_table
)
2701 && XVECTOR (Vkeyboard_translate_table
)->size
> (unsigned) XFASTINT (c
))
2702 || CHAR_TABLE_P (Vkeyboard_translate_table
))
2705 d
= Faref (Vkeyboard_translate_table
, c
);
2706 /* nil in keyboard-translate-table means no translation. */
2712 /* If this event is a mouse click in the menu bar,
2713 return just menu-bar for now. Modify the mouse click event
2714 so we won't do this twice, then queue it up. */
2715 if (EVENT_HAS_PARAMETERS (c
)
2717 && CONSP (EVENT_START (c
))
2718 && CONSP (XCDR (EVENT_START (c
))))
2722 posn
= POSN_BUFFER_POSN (EVENT_START (c
));
2723 /* Handle menu-bar events:
2724 insert the dummy prefix event `menu-bar'. */
2725 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2727 /* Change menu-bar to (menu-bar) as the event "position". */
2728 POSN_BUFFER_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2731 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2736 /* Store these characters into recent_keys, the dribble file if any,
2737 and the keyboard macro being defined, if any. */
2739 if (! NILP (also_record
))
2740 record_char (also_record
);
2742 /* Wipe the echo area.
2743 But first, if we are about to use an input method,
2744 save the echo area contents for it to refer to. */
2746 && ! NILP (Vinput_method_function
)
2747 && (unsigned) XINT (c
) >= ' '
2748 && (unsigned) XINT (c
) != 127
2749 && (unsigned) XINT (c
) < 256)
2751 previous_echo_area_message
= Fcurrent_message ();
2752 Vinput_method_previous_message
= previous_echo_area_message
;
2755 /* Now wipe the echo area, except for help events which do their
2756 own stuff with the echo area. */
2758 || (!(EQ (Qhelp_echo
, XCAR (c
)))
2759 && !(EQ (Qswitch_frame
, XCAR (c
)))))
2761 if (!NILP (echo_area_buffer
[0]))
2762 safe_run_hooks (Qecho_area_clear_hook
);
2763 clear_message (1, 0);
2766 reread_for_input_method
:
2768 /* Pass this to the input method, if appropriate. */
2770 && ! NILP (Vinput_method_function
)
2771 /* Don't run the input method within a key sequence,
2772 after the first event of the key sequence. */
2773 && NILP (prev_event
)
2774 && (unsigned) XINT (c
) >= ' '
2775 && (unsigned) XINT (c
) != 127
2776 && (unsigned) XINT (c
) < 256)
2780 struct gcpro gcpro1
;
2781 int count
= specpdl_ptr
- specpdl
;
2783 /* Save the echo status. */
2784 int saved_immediate_echo
= current_kboard
->immediate_echo
;
2785 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
2786 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
2788 if (before_command_restore_flag
)
2790 this_command_key_count
= before_command_key_count_1
;
2791 if (this_command_key_count
< this_single_command_key_start
)
2792 this_single_command_key_start
= this_command_key_count
;
2793 echo_truncate (before_command_echo_length_1
);
2794 before_command_restore_flag
= 0;
2797 /* Save the this_command_keys status. */
2798 key_count
= this_command_key_count
;
2801 keys
= Fcopy_sequence (this_command_keys
);
2806 /* Clear out this_command_keys. */
2807 this_command_key_count
= 0;
2809 /* Now wipe the echo area. */
2810 if (!NILP (echo_area_buffer
[0]))
2811 safe_run_hooks (Qecho_area_clear_hook
);
2812 clear_message (1, 0);
2815 /* If we are not reading a key sequence,
2816 never use the echo area. */
2819 specbind (Qinput_method_use_echo_area
, Qt
);
2822 /* Call the input method. */
2823 tem
= call1 (Vinput_method_function
, c
);
2825 tem
= unbind_to (count
, tem
);
2827 /* Restore the saved echoing state
2828 and this_command_keys state. */
2829 this_command_key_count
= key_count
;
2831 this_command_keys
= keys
;
2834 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
2835 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
2836 if (saved_immediate_echo
)
2841 /* The input method can return no events. */
2844 /* Bring back the previous message, if any. */
2845 if (! NILP (previous_echo_area_message
))
2846 message_with_string ("%s", previous_echo_area_message
, 0);
2849 /* It returned one event or more. */
2851 Vunread_post_input_method_events
2852 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
2857 /* Display help if not echoing. */
2858 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
2860 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
2861 Lisp_Object help
, object
, position
, window
, tem
;
2863 tem
= Fcdr (XCDR (c
));
2866 window
= Fcar (tem
);
2868 object
= Fcar (tem
);
2870 position
= Fcar (tem
);
2872 show_help_echo (help
, window
, object
, position
, 0);
2874 /* We stopped being idle for this event; undo that. */
2875 timer_idleness_start_time
= last_idle_start
;
2879 if (this_command_key_count
== 0 || ! reread
)
2881 before_command_key_count
= this_command_key_count
;
2882 before_command_echo_length
= echo_length ();
2884 /* Don't echo mouse motion events. */
2885 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2886 && NILP (Fzerop (Vecho_keystrokes
))
2887 && ! (EVENT_HAS_PARAMETERS (c
)
2888 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
2891 if (! NILP (also_record
))
2892 echo_char (also_record
);
2893 /* Once we reread a character, echoing can happen
2894 the next time we pause to read a new one. */
2895 ok_to_echo_at_next_pause
= current_kboard
;
2898 /* Record this character as part of the current key. */
2899 add_command_key (c
);
2900 if (! NILP (also_record
))
2901 add_command_key (also_record
);
2904 last_input_char
= c
;
2907 /* Process the help character specially if enabled */
2908 if (!NILP (Vhelp_form
) && help_char_p (c
))
2911 count
= specpdl_ptr
- specpdl
;
2913 record_unwind_protect (Fset_window_configuration
,
2914 Fcurrent_window_configuration (Qnil
));
2916 tem0
= Feval (Vhelp_form
);
2918 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
2922 c
= read_char (0, 0, 0, Qnil
, 0);
2923 while (BUFFERP (c
));
2924 /* Remove the help from the frame */
2925 unbind_to (count
, Qnil
);
2928 if (EQ (c
, make_number (040)))
2932 c
= read_char (0, 0, 0, Qnil
, 0);
2933 while (BUFFERP (c
));
2940 /* Record a key that came from a mouse menu.
2941 Record it for echoing, for this-command-keys, and so on. */
2947 /* Wipe the echo area. */
2948 clear_message (1, 0);
2952 before_command_key_count
= this_command_key_count
;
2953 before_command_echo_length
= echo_length ();
2955 /* Don't echo mouse motion events. */
2956 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2957 && NILP (Fzerop (Vecho_keystrokes
)))
2961 /* Once we reread a character, echoing can happen
2962 the next time we pause to read a new one. */
2963 ok_to_echo_at_next_pause
= 0;
2966 /* Record this character as part of the current key. */
2967 add_command_key (c
);
2969 /* Re-reading in the middle of a command */
2970 last_input_char
= c
;
2974 /* Return 1 if should recognize C as "the help character". */
2982 if (EQ (c
, Vhelp_char
))
2984 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
2985 if (EQ (c
, XCAR (tail
)))
2990 /* Record the input event C in various ways. */
2998 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3000 /* To avoid filling recent_keys with help-echo and mouse-movement
3001 events, we filter out repeated help-echo events, only store the
3002 first and last in a series of mouse-movement events, and don't
3003 store repeated help-echo events which are only separated by
3004 mouse-movement events. */
3006 Lisp_Object ev1
, ev2
, ev3
;
3009 if ((ix1
= recent_keys_index
- 1) < 0)
3010 ix1
= NUM_RECENT_KEYS
- 1;
3011 ev1
= AREF (recent_keys
, ix1
);
3013 if ((ix2
= ix1
- 1) < 0)
3014 ix2
= NUM_RECENT_KEYS
- 1;
3015 ev2
= AREF (recent_keys
, ix2
);
3017 if ((ix3
= ix2
- 1) < 0)
3018 ix3
= NUM_RECENT_KEYS
- 1;
3019 ev3
= AREF (recent_keys
, ix3
);
3021 if (EQ (XCAR (c
), Qhelp_echo
))
3023 /* Don't record `help-echo' in recent_keys unless it shows some help
3024 message, and a different help than the previously recorded
3026 Lisp_Object help
, last_help
;
3028 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3029 if (!STRINGP (help
))
3031 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3032 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3034 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3035 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3036 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3038 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3039 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3040 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3041 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3044 else if (EQ (XCAR (c
), Qmouse_movement
))
3046 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3047 So additional mouse movement events replace the last element. */
3048 Lisp_Object last_window
, window
;
3050 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3051 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3052 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3053 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3054 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3056 ASET (recent_keys
, ix1
, c
);
3062 store_kbd_macro_char (c
);
3067 ASET (recent_keys
, recent_keys_index
, c
);
3068 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3069 recent_keys_index
= 0;
3071 else if (recorded
< 0)
3073 /* We need to remove one or two events from recent_keys.
3074 To do this, we simply put nil at those events and move the
3075 recent_keys_index backwards over those events. Usually,
3076 users will never see those nil events, as they will be
3077 overwritten by the command keys entered to see recent_keys
3080 while (recorded
++ < 0 && total_keys
> 0)
3082 if (total_keys
< NUM_RECENT_KEYS
)
3084 if (--recent_keys_index
< 0)
3085 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3086 ASET (recent_keys
, recent_keys_index
, Qnil
);
3090 num_nonmacro_input_events
++;
3092 /* Write c to the dribble file. If c is a lispy event, write
3093 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3094 If you, dear reader, have a better idea, you've got the source. :-) */
3099 if (XUINT (c
) < 0x100)
3100 putc (XINT (c
), dribble
);
3102 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3106 Lisp_Object dribblee
;
3108 /* If it's a structured event, take the event header. */
3109 dribblee
= EVENT_HEAD (c
);
3111 if (SYMBOLP (dribblee
))
3113 putc ('<', dribble
);
3114 fwrite (XSYMBOL (dribblee
)->name
->data
, sizeof (char),
3115 STRING_BYTES (XSYMBOL (dribblee
)->name
),
3117 putc ('>', dribble
);
3129 struct buffer
*old
= current_buffer
;
3130 Fprinc (object
, Qnil
);
3131 set_buffer_internal (XBUFFER (Vstandard_output
));
3132 call0 (intern ("help-mode"));
3133 set_buffer_internal (old
);
3137 /* Copy out or in the info on where C-g should throw to.
3138 This is used when running Lisp code from within get_char,
3139 in case get_char is called recursively.
3140 See read_process_output. */
3146 bcopy (getcjmp
, temp
, sizeof getcjmp
);
3150 restore_getcjmp (temp
)
3153 bcopy (temp
, getcjmp
, sizeof getcjmp
);
3158 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
3159 of this function. */
3162 tracking_off (old_value
)
3163 Lisp_Object old_value
;
3165 do_mouse_tracking
= old_value
;
3166 if (NILP (old_value
))
3168 /* Redisplay may have been preempted because there was input
3169 available, and it assumes it will be called again after the
3170 input has been processed. If the only input available was
3171 the sort that we have just disabled, then we need to call
3173 if (!readable_events (1))
3175 redisplay_preserve_echo_area (6);
3176 get_input_pending (&input_pending
, 1);
3182 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
3183 doc
: /* Evaluate BODY with mouse movement events enabled.
3184 Within a `track-mouse' form, mouse motion generates input events that
3185 you can read with `read-event'.
3186 Normally, mouse motion is ignored.
3187 usage: (track-mouse BODY ...) */)
3191 int count
= specpdl_ptr
- specpdl
;
3194 record_unwind_protect (tracking_off
, do_mouse_tracking
);
3196 do_mouse_tracking
= Qt
;
3198 val
= Fprogn (args
);
3199 return unbind_to (count
, val
);
3202 /* If mouse has moved on some frame, return one of those frames.
3203 Return 0 otherwise. */
3208 Lisp_Object tail
, frame
;
3210 FOR_EACH_FRAME (tail
, frame
)
3212 if (XFRAME (frame
)->mouse_moved
)
3213 return XFRAME (frame
);
3219 #endif /* HAVE_MOUSE */
3221 /* Low level keyboard/mouse input.
3222 kbd_buffer_store_event places events in kbd_buffer, and
3223 kbd_buffer_get_event retrieves them. */
3225 /* Return true iff there are any events in the queue that read-char
3226 would return. If this returns false, a read-char would block. */
3228 readable_events (do_timers_now
)
3232 timer_check (do_timers_now
);
3234 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3237 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3242 if (current_kboard
->kbd_queue_has_data
)
3248 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3249 if (kb
->kbd_queue_has_data
)
3255 /* Set this for debugging, to have a way to get out */
3260 event_to_kboard (event
)
3261 struct input_event
*event
;
3264 frame
= event
->frame_or_window
;
3266 frame
= XCAR (frame
);
3267 else if (WINDOWP (frame
))
3268 frame
= WINDOW_FRAME (XWINDOW (frame
));
3270 /* There are still some events that don't set this field.
3271 For now, just ignore the problem.
3272 Also ignore dead frames here. */
3273 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3276 return FRAME_KBOARD (XFRAME (frame
));
3280 /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3283 kbd_buffer_store_event (event
)
3284 register struct input_event
*event
;
3286 if (event
->kind
== no_event
)
3289 if (event
->kind
== ascii_keystroke
)
3291 register int c
= event
->code
& 0377;
3293 if (event
->modifiers
& ctrl_modifier
)
3294 c
= make_ctrl_char (c
);
3296 c
|= (event
->modifiers
3297 & (meta_modifier
| alt_modifier
3298 | hyper_modifier
| super_modifier
));
3302 static SIGTYPE interrupt_signal
P_ ((int));
3305 struct input_event
*sp
;
3308 && (kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
)),
3309 kb
!= current_kboard
))
3312 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3313 Fcons (make_number (c
), Qnil
));
3314 kb
->kbd_queue_has_data
= 1;
3315 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3317 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3320 if (event_to_kboard (sp
) == kb
)
3322 sp
->kind
= no_event
;
3323 sp
->frame_or_window
= Qnil
;
3331 /* If this results in a quit_char being returned to Emacs as
3332 input, set Vlast_event_frame properly. If this doesn't
3333 get returned to Emacs as an event, the next event read
3334 will set Vlast_event_frame again, so this is safe to do. */
3338 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3340 focus
= event
->frame_or_window
;
3341 internal_last_event_frame
= focus
;
3342 Vlast_event_frame
= focus
;
3345 last_event_timestamp
= event
->timestamp
;
3346 interrupt_signal (0 /* dummy */);
3350 if (c
&& c
== stop_character
)
3356 /* Don't insert two buffer_switch_event's in a row.
3357 Just ignore the second one. */
3358 else if (event
->kind
== buffer_switch_event
3359 && kbd_fetch_ptr
!= kbd_store_ptr
3360 && kbd_store_ptr
->kind
== buffer_switch_event
)
3363 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3364 kbd_store_ptr
= kbd_buffer
;
3366 /* Don't let the very last slot in the buffer become full,
3367 since that would make the two pointers equal,
3368 and that is indistinguishable from an empty buffer.
3369 Discard the event if it would fill the last slot. */
3370 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3374 #if 0 /* The selection_request_event case looks bogus, and it's error
3375 prone to assign individual members for other events, in case
3376 the input_event structure is changed. --2000-07-13, gerd. */
3377 struct input_event
*sp
= kbd_store_ptr
;
3378 sp
->kind
= event
->kind
;
3379 if (event
->kind
== selection_request_event
)
3381 /* We must not use the ordinary copying code for this case,
3382 since `part' is an enum and copying it might not copy enough
3384 bcopy (event
, (char *) sp
, sizeof (*event
));
3389 sp
->code
= event
->code
;
3390 sp
->part
= event
->part
;
3391 sp
->frame_or_window
= event
->frame_or_window
;
3392 sp
->arg
= event
->arg
;
3393 sp
->modifiers
= event
->modifiers
;
3396 sp
->timestamp
= event
->timestamp
;
3399 *kbd_store_ptr
= *event
;
3402 idx
= 2 * (kbd_store_ptr
- kbd_buffer
);
3403 ASET (kbd_buffer_gcpro
, idx
, event
->frame_or_window
);
3404 ASET (kbd_buffer_gcpro
, idx
+ 1, event
->arg
);
3410 /* Generate HELP_EVENT input_events in BUFP which has room for
3411 SIZE events. If there's not enough room in BUFP, ignore this
3414 HELP is the help form.
3416 FRAME is the frame on which the help is generated. OBJECT is the
3417 Lisp object where the help was found (a buffer, a string, an
3418 overlay, or nil if neither from a string nor from a buffer. POS is
3419 the position within OBJECT where the help was found.
3421 Value is the number of input_events generated. */
3424 gen_help_event (bufp
, size
, help
, frame
, window
, object
, pos
)
3425 struct input_event
*bufp
;
3427 Lisp_Object help
, frame
, object
, window
;
3430 int nevents_stored
= 0;
3434 bufp
->kind
= HELP_EVENT
;
3435 bufp
->frame_or_window
= frame
;
3437 bufp
->x
= make_number (pos
);
3441 bufp
->kind
= HELP_EVENT
;
3442 bufp
->frame_or_window
= WINDOWP (window
) ? window
: frame
;
3448 return nevents_stored
;
3452 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3455 kbd_buffer_store_help_event (frame
, help
)
3456 Lisp_Object frame
, help
;
3458 struct input_event event
;
3460 event
.kind
= HELP_EVENT
;
3461 event
.frame_or_window
= frame
;
3463 event
.x
= make_number (0);
3465 kbd_buffer_store_event (&event
);
3467 event
.kind
= HELP_EVENT
;
3468 event
.frame_or_window
= frame
;
3470 event
.x
= make_number (0);
3472 kbd_buffer_store_event (&event
);
3476 /* Discard any mouse events in the event buffer by setting them to
3479 discard_mouse_events ()
3481 struct input_event
*sp
;
3482 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3484 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3487 if (sp
->kind
== mouse_click
3489 || sp
->kind
== w32_scroll_bar_click
3491 || sp
->kind
== scroll_bar_click
)
3493 sp
->kind
= no_event
;
3499 /* Return non-zero if there are any real events waiting in the event
3500 buffer, not counting `no_event's.
3502 If DISCARD is non-zero, discard no_event events at the front of
3503 the input queue, possibly leaving the input queue empty if there
3504 are no real input events. */
3507 kbd_buffer_events_waiting (discard
)
3510 struct input_event
*sp
;
3512 for (sp
= kbd_fetch_ptr
;
3513 sp
!= kbd_store_ptr
&& sp
->kind
== no_event
;
3516 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3523 return sp
!= kbd_store_ptr
&& sp
->kind
!= no_event
;
3527 /* Clear input event EVENT. */
3531 struct input_event
*event
;
3533 int idx
= 2 * (event
- kbd_buffer
);
3534 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
3535 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
3536 event
->kind
= no_event
;
3540 /* Read one event from the event buffer, waiting if necessary.
3541 The value is a Lisp object representing the event.
3542 The value is nil for an event that should be ignored,
3543 or that was handled here.
3544 We always read and discard one event. */
3547 kbd_buffer_get_event (kbp
, used_mouse_menu
)
3549 int *used_mouse_menu
;
3558 *kbp
= current_kboard
;
3562 /* Wait until there is input available. */
3565 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3568 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3572 /* If the quit flag is set, then read_char will return
3573 quit_char, so that counts as "available input." */
3574 if (!NILP (Vquit_flag
))
3575 quit_throw_to_read_char ();
3577 /* One way or another, wait until input is available; then, if
3578 interrupt handlers have not read it, read it now. */
3581 wait_for_kbd_input ();
3583 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3587 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3590 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3594 Lisp_Object minus_one
;
3596 XSETINT (minus_one
, -1);
3597 wait_reading_process_input (0, 0, minus_one
, 1);
3599 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3600 /* Pass 1 for EXPECT since we just waited to have input. */
3601 read_avail_input (1);
3603 #endif /* not VMS */
3606 if (CONSP (Vunread_command_events
))
3609 first
= XCAR (Vunread_command_events
);
3610 Vunread_command_events
= XCDR (Vunread_command_events
);
3611 *kbp
= current_kboard
;
3615 /* At this point, we know that there is a readable event available
3616 somewhere. If the event queue is empty, then there must be a
3617 mouse movement enabled and available. */
3618 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3620 struct input_event
*event
;
3622 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3626 last_event_timestamp
= event
->timestamp
;
3629 *kbp
= event_to_kboard (event
);
3631 *kbp
= current_kboard
; /* Better than returning null ptr? */
3633 *kbp
= &the_only_kboard
;
3638 /* These two kinds of events get special handling
3639 and don't actually appear to the command loop.
3640 We return nil for them. */
3641 if (event
->kind
== selection_request_event
)
3644 struct input_event copy
;
3646 /* Remove it from the buffer before processing it,
3647 since otherwise swallow_events will see it
3648 and process it again. */
3650 kbd_fetch_ptr
= event
+ 1;
3651 input_pending
= readable_events (0);
3652 x_handle_selection_request (©
);
3654 /* We're getting selection request events, but we don't have
3660 else if (event
->kind
== selection_clear_event
)
3663 struct input_event copy
;
3665 /* Remove it from the buffer before processing it. */
3667 kbd_fetch_ptr
= event
+ 1;
3668 input_pending
= readable_events (0);
3669 x_handle_selection_clear (©
);
3671 /* We're getting selection request events, but we don't have
3676 #if defined (HAVE_X11) || defined (HAVE_NTGUI) || defined (macintosh)
3677 else if (event
->kind
== delete_window_event
)
3679 /* Make an event (delete-frame (FRAME)). */
3680 obj
= Fcons (event
->frame_or_window
, Qnil
);
3681 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3682 kbd_fetch_ptr
= event
+ 1;
3685 #if defined (HAVE_X11) || defined (HAVE_NTGUI)
3686 else if (event
->kind
== iconify_event
)
3688 /* Make an event (iconify-frame (FRAME)). */
3689 obj
= Fcons (event
->frame_or_window
, Qnil
);
3690 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3691 kbd_fetch_ptr
= event
+ 1;
3693 else if (event
->kind
== deiconify_event
)
3695 /* Make an event (make-frame-visible (FRAME)). */
3696 obj
= Fcons (event
->frame_or_window
, Qnil
);
3697 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3698 kbd_fetch_ptr
= event
+ 1;
3701 else if (event
->kind
== buffer_switch_event
)
3703 /* The value doesn't matter here; only the type is tested. */
3704 XSETBUFFER (obj
, current_buffer
);
3705 kbd_fetch_ptr
= event
+ 1;
3707 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
3708 else if (event
->kind
== menu_bar_activate_event
)
3710 kbd_fetch_ptr
= event
+ 1;
3711 input_pending
= readable_events (0);
3712 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
3713 x_activate_menubar (XFRAME (event
->frame_or_window
));
3717 else if (event
->kind
== language_change_event
)
3719 /* Make an event (language-change (FRAME CHARSET LCID)). */
3720 obj
= Fcons (event
->modifiers
, Qnil
);
3721 obj
= Fcons (event
->code
, obj
);
3722 obj
= Fcons (event
->frame_or_window
, obj
);
3723 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
3724 kbd_fetch_ptr
= event
+ 1;
3727 /* Just discard these, by returning nil.
3728 With MULTI_KBOARD, these events are used as placeholders
3729 when we need to randomly delete events from the queue.
3730 (They shouldn't otherwise be found in the buffer,
3731 but on some machines it appears they do show up
3732 even without MULTI_KBOARD.) */
3733 /* On Windows NT/9X, no_event is used to delete extraneous
3734 mouse events during a popup-menu call. */
3735 else if (event
->kind
== no_event
)
3736 kbd_fetch_ptr
= event
+ 1;
3737 else if (event
->kind
== HELP_EVENT
)
3739 /* There are always two HELP_EVENTs in the input queue. */
3740 Lisp_Object object
, position
, help
, frame
, window
;
3742 xassert (event
->code
== 0);
3743 frame
= event
->frame_or_window
;
3744 object
= event
->arg
;
3745 position
= event
->x
;
3746 clear_event (event
);
3748 kbd_fetch_ptr
= event
+ 1;
3749 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3752 xassert (event
->code
== 1);
3754 window
= event
->frame_or_window
;
3755 if (!WINDOWP (window
))
3757 obj
= Fcons (Qhelp_echo
,
3758 list5 (frame
, help
, window
, object
, position
));
3759 clear_event (event
);
3760 kbd_fetch_ptr
= event
+ 1;
3762 else if (event
->kind
== FOCUS_IN_EVENT
)
3764 /* Notification of a FocusIn event. The frame receiving the
3765 focus is in event->frame_or_window. Generate a
3766 switch-frame event if necessary. */
3767 Lisp_Object frame
, focus
;
3769 frame
= event
->frame_or_window
;
3770 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
3774 if (!EQ (frame
, internal_last_event_frame
)
3775 && !EQ (frame
, selected_frame
))
3776 obj
= make_lispy_switch_frame (frame
);
3777 internal_last_event_frame
= frame
;
3778 kbd_fetch_ptr
= event
+ 1;
3782 /* If this event is on a different frame, return a switch-frame this
3783 time, and leave the event in the queue for next time. */
3787 frame
= event
->frame_or_window
;
3789 frame
= XCAR (frame
);
3790 else if (WINDOWP (frame
))
3791 frame
= WINDOW_FRAME (XWINDOW (frame
));
3793 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
3797 if (! EQ (frame
, internal_last_event_frame
)
3798 && !EQ (frame
, selected_frame
))
3799 obj
= make_lispy_switch_frame (frame
);
3800 internal_last_event_frame
= frame
;
3802 /* If we didn't decide to make a switch-frame event, go ahead
3803 and build a real event from the queue entry. */
3807 obj
= make_lispy_event (event
);
3809 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
3810 /* If this was a menu selection, then set the flag to inhibit
3811 writing to last_nonmenu_event. Don't do this if the event
3812 we're returning is (menu-bar), though; that indicates the
3813 beginning of the menu sequence, and we might as well leave
3814 that as the `event with parameters' for this selection. */
3816 && !EQ (event
->frame_or_window
, event
->arg
)
3817 && (event
->kind
== MENU_BAR_EVENT
3818 || event
->kind
== TOOL_BAR_EVENT
))
3819 *used_mouse_menu
= 1;
3822 /* Wipe out this event, to catch bugs. */
3823 clear_event (event
);
3824 kbd_fetch_ptr
= event
+ 1;
3829 /* Try generating a mouse motion event. */
3830 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3832 FRAME_PTR f
= some_mouse_moved ();
3833 Lisp_Object bar_window
;
3834 enum scroll_bar_part part
;
3838 *kbp
= current_kboard
;
3839 /* Note that this uses F to determine which display to look at.
3840 If there is no valid info, it does not store anything
3841 so x remains nil. */
3843 (*mouse_position_hook
) (&f
, 0, &bar_window
, &part
, &x
, &y
, &time
);
3847 /* Decide if we should generate a switch-frame event. Don't
3848 generate switch-frame events for motion outside of all Emacs
3854 frame
= FRAME_FOCUS_FRAME (f
);
3856 XSETFRAME (frame
, f
);
3858 if (! EQ (frame
, internal_last_event_frame
)
3859 && !EQ (frame
, selected_frame
))
3860 obj
= make_lispy_switch_frame (frame
);
3861 internal_last_event_frame
= frame
;
3864 /* If we didn't decide to make a switch-frame event, go ahead and
3865 return a mouse-motion event. */
3866 if (!NILP (x
) && NILP (obj
))
3867 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, time
);
3869 #endif /* HAVE_MOUSE */
3871 /* We were promised by the above while loop that there was
3872 something for us to read! */
3875 input_pending
= readable_events (0);
3877 Vlast_event_frame
= internal_last_event_frame
;
3882 /* Process any events that are not user-visible,
3883 then return, without reading any user-visible events. */
3886 swallow_events (do_display
)
3891 while (kbd_fetch_ptr
!= kbd_store_ptr
)
3893 struct input_event
*event
;
3895 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3899 last_event_timestamp
= event
->timestamp
;
3901 /* These two kinds of events get special handling
3902 and don't actually appear to the command loop. */
3903 if (event
->kind
== selection_request_event
)
3906 struct input_event copy
;
3908 /* Remove it from the buffer before processing it,
3909 since otherwise swallow_events called recursively could see it
3910 and process it again. */
3912 kbd_fetch_ptr
= event
+ 1;
3913 input_pending
= readable_events (0);
3914 x_handle_selection_request (©
);
3916 /* We're getting selection request events, but we don't have
3922 else if (event
->kind
== selection_clear_event
)
3925 struct input_event copy
;
3927 /* Remove it from the buffer before processing it, */
3930 kbd_fetch_ptr
= event
+ 1;
3931 input_pending
= readable_events (0);
3932 x_handle_selection_clear (©
);
3934 /* We're getting selection request events, but we don't have
3943 old_timers_run
= timers_run
;
3944 get_input_pending (&input_pending
, 1);
3946 if (timers_run
!= old_timers_run
&& do_display
)
3947 redisplay_preserve_echo_area (7);
3950 /* Record the start of when Emacs is idle,
3951 for the sake of running idle-time timers. */
3958 /* If we are already in the idle state, do nothing. */
3959 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
3962 EMACS_GET_TIME (timer_idleness_start_time
);
3964 /* Mark all idle-time timers as once again candidates for running. */
3965 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
3969 timer
= XCAR (timers
);
3971 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
3973 XVECTOR (timer
)->contents
[0] = Qnil
;
3977 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
3982 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
3985 /* This is only for debugging. */
3986 struct input_event last_timer_event
;
3988 /* Check whether a timer has fired. To prevent larger problems we simply
3989 disregard elements that are not proper timers. Do not make a circular
3990 timer list for the time being.
3992 Returns the number of seconds to wait until the next timer fires. If a
3993 timer is triggering now, return zero seconds.
3994 If no timer is active, return -1 seconds.
3996 If a timer is ripe, we run it, with quitting turned off.
3998 DO_IT_NOW is now ignored. It used to mean that we should
3999 run the timer directly instead of queueing a timer-event.
4000 Now we always run timers directly. */
4003 timer_check (do_it_now
)
4006 EMACS_TIME nexttime
;
4007 EMACS_TIME now
, idleness_now
;
4008 Lisp_Object timers
, idle_timers
, chosen_timer
;
4009 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4011 EMACS_SET_SECS (nexttime
, -1);
4012 EMACS_SET_USECS (nexttime
, -1);
4014 /* Always consider the ordinary timers. */
4015 timers
= Vtimer_list
;
4016 /* Consider the idle timers only if Emacs is idle. */
4017 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4018 idle_timers
= Vtimer_idle_list
;
4021 chosen_timer
= Qnil
;
4022 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4024 if (CONSP (timers
) || CONSP (idle_timers
))
4026 EMACS_GET_TIME (now
);
4027 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4028 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4031 while (CONSP (timers
) || CONSP (idle_timers
))
4033 Lisp_Object
*vector
;
4034 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4035 EMACS_TIME timer_time
, idle_timer_time
;
4036 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4038 /* Skip past invalid timers and timers already handled. */
4041 timer
= XCAR (timers
);
4042 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4044 timers
= XCDR (timers
);
4047 vector
= XVECTOR (timer
)->contents
;
4049 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4050 || !INTEGERP (vector
[3])
4051 || ! NILP (vector
[0]))
4053 timers
= XCDR (timers
);
4057 if (!NILP (idle_timers
))
4059 timer
= XCAR (idle_timers
);
4060 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4062 idle_timers
= XCDR (idle_timers
);
4065 vector
= XVECTOR (timer
)->contents
;
4067 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4068 || !INTEGERP (vector
[3])
4069 || ! NILP (vector
[0]))
4071 idle_timers
= XCDR (idle_timers
);
4076 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4077 based on the next ordinary timer.
4078 TIMER_DIFFERENCE is the distance in time from NOW to when
4079 this timer becomes ripe (negative if it's already ripe). */
4082 timer
= XCAR (timers
);
4083 vector
= XVECTOR (timer
)->contents
;
4084 EMACS_SET_SECS (timer_time
,
4085 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4086 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4087 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4090 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4091 based on the next idle timer. */
4092 if (!NILP (idle_timers
))
4094 idle_timer
= XCAR (idle_timers
);
4095 vector
= XVECTOR (idle_timer
)->contents
;
4096 EMACS_SET_SECS (idle_timer_time
,
4097 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4098 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4099 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4102 /* Decide which timer is the next timer,
4103 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4104 Also step down the list where we found that timer. */
4106 if (! NILP (timers
) && ! NILP (idle_timers
))
4109 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4110 if (EMACS_TIME_NEG_P (temp
))
4112 chosen_timer
= timer
;
4113 timers
= XCDR (timers
);
4114 difference
= timer_difference
;
4118 chosen_timer
= idle_timer
;
4119 idle_timers
= XCDR (idle_timers
);
4120 difference
= idle_timer_difference
;
4123 else if (! NILP (timers
))
4125 chosen_timer
= timer
;
4126 timers
= XCDR (timers
);
4127 difference
= timer_difference
;
4131 chosen_timer
= idle_timer
;
4132 idle_timers
= XCDR (idle_timers
);
4133 difference
= idle_timer_difference
;
4135 vector
= XVECTOR (chosen_timer
)->contents
;
4137 /* If timer is ripe, run it if it hasn't been run. */
4138 if (EMACS_TIME_NEG_P (difference
)
4139 || (EMACS_SECS (difference
) == 0
4140 && EMACS_USECS (difference
) == 0))
4142 if (NILP (vector
[0]))
4144 int was_locked
= single_kboard
;
4145 int count
= BINDING_STACK_SIZE ();
4146 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4148 /* Mark the timer as triggered to prevent problems if the lisp
4149 code fails to reschedule it right. */
4152 specbind (Qinhibit_quit
, Qt
);
4154 call1 (Qtimer_event_handler
, chosen_timer
);
4155 Vdeactivate_mark
= old_deactivate_mark
;
4157 unbind_to (count
, Qnil
);
4159 /* Resume allowing input from any kboard, if that was true before. */
4161 any_kboard_state ();
4163 /* Since we have handled the event,
4164 we don't need to tell the caller to wake up and do it. */
4168 /* When we encounter a timer that is still waiting,
4169 return the amount of time to wait before it is ripe. */
4176 /* No timers are pending in the future. */
4177 /* Return 0 if we generated an event, and -1 if not. */
4182 /* Caches for modify_event_symbol. */
4183 static Lisp_Object accent_key_syms
;
4184 static Lisp_Object func_key_syms
;
4185 static Lisp_Object mouse_syms
;
4187 static Lisp_Object mouse_wheel_syms
;
4189 static Lisp_Object drag_n_drop_syms
;
4191 /* This is a list of keysym codes for special "accent" characters.
4192 It parallels lispy_accent_keys. */
4194 static int lispy_accent_codes
[] =
4196 #ifdef XK_dead_circumflex
4201 #ifdef XK_dead_grave
4206 #ifdef XK_dead_tilde
4211 #ifdef XK_dead_diaeresis
4216 #ifdef XK_dead_macron
4221 #ifdef XK_dead_degree
4226 #ifdef XK_dead_acute
4231 #ifdef XK_dead_cedilla
4236 #ifdef XK_dead_breve
4241 #ifdef XK_dead_ogonek
4246 #ifdef XK_dead_caron
4251 #ifdef XK_dead_doubleacute
4252 XK_dead_doubleacute
,
4256 #ifdef XK_dead_abovedot
4263 /* This is a list of Lisp names for special "accent" characters.
4264 It parallels lispy_accent_codes. */
4266 static char *lispy_accent_keys
[] =
4284 #define FUNCTION_KEY_OFFSET 0x0
4286 char *lispy_function_keys
[] =
4290 0, /* VK_LBUTTON 0x01 */
4291 0, /* VK_RBUTTON 0x02 */
4292 "cancel", /* VK_CANCEL 0x03 */
4293 0, /* VK_MBUTTON 0x04 */
4295 0, 0, 0, /* 0x05 .. 0x07 */
4297 "backspace", /* VK_BACK 0x08 */
4298 "tab", /* VK_TAB 0x09 */
4300 0, 0, /* 0x0A .. 0x0B */
4302 "clear", /* VK_CLEAR 0x0C */
4303 "return", /* VK_RETURN 0x0D */
4305 0, 0, /* 0x0E .. 0x0F */
4307 0, /* VK_SHIFT 0x10 */
4308 0, /* VK_CONTROL 0x11 */
4309 0, /* VK_MENU 0x12 */
4310 "pause", /* VK_PAUSE 0x13 */
4311 "capslock", /* VK_CAPITAL 0x14 */
4313 0, 0, 0, 0, 0, 0, /* 0x15 .. 0x1A */
4315 "escape", /* VK_ESCAPE 0x1B */
4317 0, 0, 0, 0, /* 0x1C .. 0x1F */
4319 0, /* VK_SPACE 0x20 */
4320 "prior", /* VK_PRIOR 0x21 */
4321 "next", /* VK_NEXT 0x22 */
4322 "end", /* VK_END 0x23 */
4323 "home", /* VK_HOME 0x24 */
4324 "left", /* VK_LEFT 0x25 */
4325 "up", /* VK_UP 0x26 */
4326 "right", /* VK_RIGHT 0x27 */
4327 "down", /* VK_DOWN 0x28 */
4328 "select", /* VK_SELECT 0x29 */
4329 "print", /* VK_PRINT 0x2A */
4330 "execute", /* VK_EXECUTE 0x2B */
4331 "snapshot", /* VK_SNAPSHOT 0x2C */
4332 "insert", /* VK_INSERT 0x2D */
4333 "delete", /* VK_DELETE 0x2E */
4334 "help", /* VK_HELP 0x2F */
4336 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4338 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4340 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4342 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4344 0, 0, 0, 0, 0, 0, 0, 0, 0,
4345 0, 0, 0, 0, 0, 0, 0, 0, 0,
4346 0, 0, 0, 0, 0, 0, 0, 0,
4348 "lwindow", /* VK_LWIN 0x5B */
4349 "rwindow", /* VK_RWIN 0x5C */
4350 "apps", /* VK_APPS 0x5D */
4352 0, 0, /* 0x5E .. 0x5F */
4354 "kp-0", /* VK_NUMPAD0 0x60 */
4355 "kp-1", /* VK_NUMPAD1 0x61 */
4356 "kp-2", /* VK_NUMPAD2 0x62 */
4357 "kp-3", /* VK_NUMPAD3 0x63 */
4358 "kp-4", /* VK_NUMPAD4 0x64 */
4359 "kp-5", /* VK_NUMPAD5 0x65 */
4360 "kp-6", /* VK_NUMPAD6 0x66 */
4361 "kp-7", /* VK_NUMPAD7 0x67 */
4362 "kp-8", /* VK_NUMPAD8 0x68 */
4363 "kp-9", /* VK_NUMPAD9 0x69 */
4364 "kp-multiply", /* VK_MULTIPLY 0x6A */
4365 "kp-add", /* VK_ADD 0x6B */
4366 "kp-separator", /* VK_SEPARATOR 0x6C */
4367 "kp-subtract", /* VK_SUBTRACT 0x6D */
4368 "kp-decimal", /* VK_DECIMAL 0x6E */
4369 "kp-divide", /* VK_DIVIDE 0x6F */
4370 "f1", /* VK_F1 0x70 */
4371 "f2", /* VK_F2 0x71 */
4372 "f3", /* VK_F3 0x72 */
4373 "f4", /* VK_F4 0x73 */
4374 "f5", /* VK_F5 0x74 */
4375 "f6", /* VK_F6 0x75 */
4376 "f7", /* VK_F7 0x76 */
4377 "f8", /* VK_F8 0x77 */
4378 "f9", /* VK_F9 0x78 */
4379 "f10", /* VK_F10 0x79 */
4380 "f11", /* VK_F11 0x7A */
4381 "f12", /* VK_F12 0x7B */
4382 "f13", /* VK_F13 0x7C */
4383 "f14", /* VK_F14 0x7D */
4384 "f15", /* VK_F15 0x7E */
4385 "f16", /* VK_F16 0x7F */
4386 "f17", /* VK_F17 0x80 */
4387 "f18", /* VK_F18 0x81 */
4388 "f19", /* VK_F19 0x82 */
4389 "f20", /* VK_F20 0x83 */
4390 "f21", /* VK_F21 0x84 */
4391 "f22", /* VK_F22 0x85 */
4392 "f23", /* VK_F23 0x86 */
4393 "f24", /* VK_F24 0x87 */
4395 0, 0, 0, 0, /* 0x88 .. 0x8B */
4396 0, 0, 0, 0, /* 0x8C .. 0x8F */
4398 "kp-numlock", /* VK_NUMLOCK 0x90 */
4399 "scroll", /* VK_SCROLL 0x91 */
4401 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4402 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4403 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4404 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4405 "kp-end", /* VK_NUMPAD_END 0x96 */
4406 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4407 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4408 "kp-up", /* VK_NUMPAD_UP 0x99 */
4409 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4410 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4411 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4412 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4414 0, 0, /* 0x9E .. 0x9F */
4417 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4418 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4419 * No other API or message will distinguish left and right keys this way.
4423 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4424 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4425 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4426 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4427 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4433 "attn", /* VK_ATTN 0xF6 */
4434 "crsel", /* VK_CRSEL 0xF7 */
4435 "exsel", /* VK_EXSEL 0xF8 */
4436 "ereof", /* VK_EREOF 0xF9 */
4437 "play", /* VK_PLAY 0xFA */
4438 "zoom", /* VK_ZOOM 0xFB */
4439 "noname", /* VK_NONAME 0xFC */
4440 "pa1", /* VK_PA1 0xFD */
4441 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4445 #else /* not HAVE_NTGUI */
4448 static char *lispy_kana_keys
[] =
4450 /* X Keysym value */
4451 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4452 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4453 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4454 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4455 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4456 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4457 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4458 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4459 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4460 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4461 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4462 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4463 "kana-i", "kana-u", "kana-e", "kana-o",
4464 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4465 "prolongedsound", "kana-A", "kana-I", "kana-U",
4466 "kana-E", "kana-O", "kana-KA", "kana-KI",
4467 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4468 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4469 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4470 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4471 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4472 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4473 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4474 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4475 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4476 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4477 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4478 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4480 #endif /* XK_kana_A */
4482 #define FUNCTION_KEY_OFFSET 0xff00
4484 /* You'll notice that this table is arranged to be conveniently
4485 indexed by X Windows keysym values. */
4486 static char *lispy_function_keys
[] =
4488 /* X Keysym value */
4490 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4491 "backspace", "tab", "linefeed", "clear",
4493 0, 0, 0, "pause", /* 0xff10...1f */
4494 0, 0, 0, 0, 0, 0, 0, "escape",
4496 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4497 "romaji", "hiragana", "katakana", "hiragana-katakana",
4498 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4499 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4500 "eisu-toggle", /* 0xff30...3f */
4501 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4502 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4504 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4505 "down", "prior", "next", "end",
4506 "begin", 0, 0, 0, 0, 0, 0, 0,
4507 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4518 "break", /* 0xff6b */
4521 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4522 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4523 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4524 0, 0, 0, 0, 0, 0, 0, 0,
4525 "kp-tab", /* 0xff89 */
4527 "kp-enter", /* 0xff8d */
4529 "kp-f1", /* 0xff91 */
4533 "kp-home", /* 0xff95 */
4538 "kp-prior", /* kp-page-up */
4539 "kp-next", /* kp-page-down */
4545 0, 0, 0, 0, 0, 0, 0, 0, 0,
4546 "kp-multiply", /* 0xffaa */
4551 "kp-divide", /* 0xffaf */
4552 "kp-0", /* 0xffb0 */
4553 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4556 "kp-equal", /* 0xffbd */
4557 "f1", /* 0xffbe */ /* IsFunctionKey */
4559 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4560 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4561 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4562 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4563 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4564 0, 0, 0, 0, 0, 0, 0, 0,
4565 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4566 0, 0, 0, 0, 0, 0, 0, "delete"
4569 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4570 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4572 static char *iso_lispy_function_keys
[] =
4574 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4575 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4576 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4577 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4578 "iso-lefttab", /* 0xfe20 */
4579 "iso-move-line-up", "iso-move-line-down",
4580 "iso-partial-line-up", "iso-partial-line-down",
4581 "iso-partial-space-left", "iso-partial-space-right",
4582 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4583 "iso-release-margin-left", "iso-release-margin-right",
4584 "iso-release-both-margins",
4585 "iso-fast-cursor-left", "iso-fast-cursor-right",
4586 "iso-fast-cursor-up", "iso-fast-cursor-down",
4587 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4588 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4591 #endif /* not HAVE_NTGUI */
4593 Lisp_Object Vlispy_mouse_stem
;
4596 /* mouse-wheel events are generated by the wheel on devices such as
4597 the MS Intellimouse. The wheel sits in between the left and right
4598 mouse buttons, and is typically used to scroll or zoom the window
4599 underneath the pointer. mouse-wheel events specify the object on
4600 which they operate, and a delta corresponding to the amount and
4601 direction that the wheel is rotated. Clicking the mouse-wheel
4602 generates a mouse-2 event. */
4603 static char *lispy_mouse_wheel_names
[] =
4608 #endif /* WINDOWSNT */
4610 /* drag-n-drop events are generated when a set of selected files are
4611 dragged from another application and dropped onto an Emacs window. */
4612 static char *lispy_drag_n_drop_names
[] =
4617 /* Scroll bar parts. */
4618 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
4619 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
4620 Lisp_Object Qtop
, Qratio
;
4622 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
4623 Lisp_Object
*scroll_bar_parts
[] = {
4624 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
4625 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
4628 /* User signal events. */
4629 Lisp_Object Qusr1_signal
, Qusr2_signal
;
4631 Lisp_Object
*lispy_user_signals
[] =
4633 &Qusr1_signal
, &Qusr2_signal
4637 /* A vector, indexed by button number, giving the down-going location
4638 of currently depressed buttons, both scroll bar and non-scroll bar.
4640 The elements have the form
4641 (BUTTON-NUMBER MODIFIER-MASK . REST)
4642 where REST is the cdr of a position as it would be reported in the event.
4644 The make_lispy_event function stores positions here to tell the
4645 difference between click and drag events, and to store the starting
4646 location to be included in drag events. */
4648 static Lisp_Object button_down_location
;
4650 /* Information about the most recent up-going button event: Which
4651 button, what location, and what time. */
4653 static int last_mouse_button
;
4654 static int last_mouse_x
;
4655 static int last_mouse_y
;
4656 static unsigned long button_down_time
;
4658 /* The maximum time between clicks to make a double-click, or Qnil to
4659 disable double-click detection, or Qt for no time limit. */
4661 Lisp_Object Vdouble_click_time
;
4663 /* Maximum number of pixels the mouse may be moved between clicks
4664 to make a double-click. */
4666 int double_click_fuzz
;
4668 /* The number of clicks in this multiple-click. */
4670 int double_click_count
;
4672 /* Given a struct input_event, build the lisp event which represents
4673 it. If EVENT is 0, build a mouse movement event from the mouse
4674 movement buffer, which should have a movement event in it.
4676 Note that events must be passed to this function in the order they
4677 are received; this function stores the location of button presses
4678 in order to build drag events when the button is released. */
4681 make_lispy_event (event
)
4682 struct input_event
*event
;
4686 switch (SWITCH_ENUM_CAST (event
->kind
))
4688 /* A simple keystroke. */
4689 case ascii_keystroke
:
4691 Lisp_Object lispy_c
;
4692 int c
= event
->code
& 0377;
4693 /* Turn ASCII characters into control characters
4695 if (event
->modifiers
& ctrl_modifier
)
4696 c
= make_ctrl_char (c
);
4698 /* Add in the other modifier bits. We took care of ctrl_modifier
4699 just above, and the shift key was taken care of by the X code,
4700 and applied to control characters by make_ctrl_char. */
4701 c
|= (event
->modifiers
4702 & (meta_modifier
| alt_modifier
4703 | hyper_modifier
| super_modifier
));
4704 /* Distinguish Shift-SPC from SPC. */
4705 if ((event
->code
& 0377) == 040
4706 && event
->modifiers
& shift_modifier
)
4707 c
|= shift_modifier
;
4708 button_down_time
= 0;
4709 XSETFASTINT (lispy_c
, c
);
4713 case multibyte_char_keystroke
:
4715 Lisp_Object lispy_c
;
4717 XSETFASTINT (lispy_c
, event
->code
);
4721 /* A function key. The symbol may need to have modifier prefixes
4723 case non_ascii_keystroke
:
4724 button_down_time
= 0;
4726 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
4727 if (event
->code
== lispy_accent_codes
[i
])
4728 return modify_event_symbol (i
,
4730 Qfunction_key
, Qnil
,
4731 lispy_accent_keys
, &accent_key_syms
,
4732 (sizeof (lispy_accent_keys
)
4733 / sizeof (lispy_accent_keys
[0])));
4735 /* Handle system-specific keysyms. */
4736 if (event
->code
& (1 << 28))
4738 /* We need to use an alist rather than a vector as the cache
4739 since we can't make a vector long enuf. */
4740 if (NILP (current_kboard
->system_key_syms
))
4741 current_kboard
->system_key_syms
= Fcons (Qnil
, Qnil
);
4742 return modify_event_symbol (event
->code
,
4745 current_kboard
->Vsystem_key_alist
,
4746 0, ¤t_kboard
->system_key_syms
,
4751 if (event
->code
>= 0x400 && event
->code
< 0x500)
4752 return modify_event_symbol (event
->code
- 0x400,
4753 event
->modifiers
& ~shift_modifier
,
4754 Qfunction_key
, Qnil
,
4755 lispy_kana_keys
, &func_key_syms
,
4756 (sizeof (lispy_kana_keys
)
4757 / sizeof (lispy_kana_keys
[0])));
4758 #endif /* XK_kana_A */
4760 #ifdef ISO_FUNCTION_KEY_OFFSET
4761 if (event
->code
< FUNCTION_KEY_OFFSET
4762 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
4763 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
4765 Qfunction_key
, Qnil
,
4766 iso_lispy_function_keys
, &func_key_syms
,
4767 (sizeof (iso_lispy_function_keys
)
4768 / sizeof (iso_lispy_function_keys
[0])));
4772 #ifdef HAVE_X_WINDOWS
4773 if (event
->code
- FUNCTION_KEY_OFFSET
< 0
4774 || (event
->code
- FUNCTION_KEY_OFFSET
4775 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
))
4777 /* EVENT->code is an unknown keysym, for example someone
4778 assigned `ccaron' to a key in a locale where
4779 XmbLookupString doesn't return a translation for it. */
4784 /* This returns a pointer to a static area. Don't free it. */
4785 name
= XKeysymToString (event
->code
);
4786 symbol
= name
? intern (name
) : Qnil
;
4790 return apply_modifiers (event
->modifiers
, symbol
);
4792 #endif /* HAVE_X_WINDOWS */
4794 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
4796 Qfunction_key
, Qnil
,
4797 lispy_function_keys
, &func_key_syms
,
4798 (sizeof (lispy_function_keys
)
4799 / sizeof (lispy_function_keys
[0])));
4802 /* A mouse click. Figure out where it is, decide whether it's
4803 a press, click or drag, and build the appropriate structure. */
4805 #ifndef USE_TOOLKIT_SCROLL_BARS
4806 case scroll_bar_click
:
4809 int button
= event
->code
;
4811 Lisp_Object position
;
4812 Lisp_Object
*start_pos_ptr
;
4813 Lisp_Object start_pos
;
4818 /* Build the position as appropriate for this mouse click. */
4819 if (event
->kind
== mouse_click
)
4822 struct frame
*f
= XFRAME (event
->frame_or_window
);
4824 Lisp_Object string_info
= Qnil
;
4827 /* Ignore mouse events that were made on frame that
4828 have been deleted. */
4829 if (! FRAME_LIVE_P (f
))
4832 /* EVENT->x and EVENT->y are frame-relative pixel
4833 coordinates at this place. Under old redisplay, COLUMN
4834 and ROW are set to frame relative glyph coordinates
4835 which are then used to determine whether this click is
4836 in a menu (non-toolkit version). */
4837 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
4838 &column
, &row
, NULL
, 1);
4840 #ifndef USE_X_TOOLKIT
4841 /* In the non-toolkit version, clicks on the menu bar
4842 are ordinary button events in the event buffer.
4843 Distinguish them, and invoke the menu.
4845 (In the toolkit version, the toolkit handles the menu bar
4846 and Emacs doesn't know about it until after the user
4847 makes a selection.) */
4848 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
4849 && (event
->modifiers
& down_modifier
))
4851 Lisp_Object items
, item
;
4856 /* Activate the menu bar on the down event. If the
4857 up event comes in before the menu code can deal with it,
4859 if (! (event
->modifiers
& down_modifier
))
4863 /* Find the menu bar item under `column'. */
4865 items
= FRAME_MENU_BAR_ITEMS (f
);
4866 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
4868 Lisp_Object pos
, string
;
4869 string
= AREF (items
, i
+ 1);
4870 pos
= AREF (items
, i
+ 3);
4873 if (column
>= XINT (pos
)
4874 && column
< XINT (pos
) + XSTRING (string
)->size
)
4876 item
= AREF (items
, i
);
4881 /* ELisp manual 2.4b says (x y) are window relative but
4882 code says they are frame-relative. */
4884 = Fcons (event
->frame_or_window
,
4886 Fcons (Fcons (event
->x
, event
->y
),
4887 Fcons (make_number (event
->timestamp
),
4890 return Fcons (item
, Fcons (position
, Qnil
));
4892 #endif /* not USE_X_TOOLKIT */
4894 /* Set `window' to the window under frame pixel coordinates
4895 event->x/event->y. */
4896 window
= window_from_coordinates (f
, XINT (event
->x
),
4897 XINT (event
->y
), &part
, 0);
4899 if (!WINDOWP (window
))
4901 window
= event
->frame_or_window
;
4906 /* It's a click in window window at frame coordinates
4907 event->x/ event->y. */
4908 struct window
*w
= XWINDOW (window
);
4910 /* Get window relative coordinates. Original code
4911 `rounded' this to glyph boundaries. */
4912 int wx
= FRAME_TO_WINDOW_PIXEL_X (w
, XINT (event
->x
));
4913 int wy
= FRAME_TO_WINDOW_PIXEL_Y (w
, XINT (event
->y
));
4915 /* Set event coordinates to window-relative coordinates
4916 for constructing the Lisp event below. */
4917 XSETINT (event
->x
, wx
);
4918 XSETINT (event
->y
, wy
);
4920 if (part
== 1 || part
== 3)
4922 /* Mode line or header line. Look for a string under
4923 the mouse that may have a `local-map' property. */
4927 posn
= part
== 1 ? Qmode_line
: Qheader_line
;
4928 string
= mode_line_string (w
, wx
, wy
, part
== 1, &charpos
);
4929 if (STRINGP (string
))
4930 string_info
= Fcons (string
, make_number (charpos
));
4933 posn
= Qvertical_line
;
4937 struct display_pos p
;
4938 buffer_posn_from_coords (w
, &wx
, &wy
, &object
, &p
);
4939 posn
= make_number (CHARPOS (p
.pos
));
4940 if (STRINGP (object
))
4943 make_number (CHARPOS (p
.string_pos
)));
4950 Fcons (Fcons (event
->x
, event
->y
),
4951 Fcons (make_number (event
->timestamp
),
4954 : Fcons (string_info
, Qnil
))))));
4956 #ifndef USE_TOOLKIT_SCROLL_BARS
4959 /* It's a scrollbar click. */
4960 Lisp_Object portion_whole
;
4963 window
= event
->frame_or_window
;
4964 portion_whole
= Fcons (event
->x
, event
->y
);
4965 part
= *scroll_bar_parts
[(int) event
->part
];
4969 Fcons (Qvertical_scroll_bar
,
4970 Fcons (portion_whole
,
4971 Fcons (make_number (event
->timestamp
),
4972 Fcons (part
, Qnil
)))));
4974 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4976 if (button
>= ASIZE (button_down_location
))
4978 button_down_location
= larger_vector (button_down_location
,
4980 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
4983 start_pos_ptr
= &AREF (button_down_location
, button
);
4984 start_pos
= *start_pos_ptr
;
4985 *start_pos_ptr
= Qnil
;
4988 /* On window-system frames, use the value of
4989 double-click-fuzz as is. On other frames, interpret it
4990 as a multiple of 1/8 characters. */
4994 if (WINDOWP (event
->frame_or_window
))
4995 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
4996 else if (FRAMEP (event
->frame_or_window
))
4997 f
= XFRAME (event
->frame_or_window
);
5001 if (FRAME_WINDOW_P (f
))
5002 fuzz
= double_click_fuzz
;
5004 fuzz
= double_click_fuzz
/ 8;
5006 is_double
= (button
== last_mouse_button
5007 && (abs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5008 && (abs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5009 && button_down_time
!= 0
5010 && (EQ (Vdouble_click_time
, Qt
)
5011 || (INTEGERP (Vdouble_click_time
)
5012 && ((int)(event
->timestamp
- button_down_time
)
5013 < XINT (Vdouble_click_time
)))));
5016 last_mouse_button
= button
;
5017 last_mouse_x
= XINT (event
->x
);
5018 last_mouse_y
= XINT (event
->y
);
5020 /* If this is a button press, squirrel away the location, so
5021 we can decide later whether it was a click or a drag. */
5022 if (event
->modifiers
& down_modifier
)
5026 double_click_count
++;
5027 event
->modifiers
|= ((double_click_count
> 2)
5032 double_click_count
= 1;
5033 button_down_time
= event
->timestamp
;
5034 *start_pos_ptr
= Fcopy_alist (position
);
5037 /* Now we're releasing a button - check the co-ordinates to
5038 see if this was a click or a drag. */
5039 else if (event
->modifiers
& up_modifier
)
5041 /* If we did not see a down before this up, ignore the up.
5042 Probably this happened because the down event chose a
5043 menu item. It would be an annoyance to treat the
5044 release of the button that chose the menu item as a
5047 if (!CONSP (start_pos
))
5050 event
->modifiers
&= ~up_modifier
;
5051 #if 0 /* Formerly we treated an up with no down as a click event. */
5052 if (!CONSP (start_pos
))
5053 event
->modifiers
|= click_modifier
;
5058 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5060 /* The third element of every position
5061 should be the (x,y) pair. */
5062 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5064 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5066 xdiff
= XFASTINT (event
->x
) - XFASTINT (XCAR (down
));
5067 ydiff
= XFASTINT (event
->y
) - XFASTINT (XCDR (down
));
5070 if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5071 && ydiff
< double_click_fuzz
5072 && ydiff
> - double_click_fuzz
)
5073 /* Mouse hasn't moved (much). */
5074 event
->modifiers
|= click_modifier
;
5077 button_down_time
= 0;
5078 event
->modifiers
|= drag_modifier
;
5081 /* Don't check is_double; treat this as multiple
5082 if the down-event was multiple. */
5083 if (double_click_count
> 1)
5084 event
->modifiers
|= ((double_click_count
> 2)
5090 /* Every mouse event should either have the down_modifier or
5091 the up_modifier set. */
5095 /* Get the symbol we should use for the mouse click. */
5098 head
= modify_event_symbol (button
,
5100 Qmouse_click
, Vlispy_mouse_stem
,
5103 XVECTOR (mouse_syms
)->size
);
5104 if (event
->modifiers
& drag_modifier
)
5109 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5112 Fcons (make_number (double_click_count
),
5121 #if USE_TOOLKIT_SCROLL_BARS
5123 /* We don't have down and up events if using toolkit scroll bars,
5124 so make this always a click event. Store in the `part' of
5125 the Lisp event a symbol which maps to the following actions:
5127 `above_handle' page up
5128 `below_handle' page down
5132 `bottom' bottom of buffer
5133 `handle' thumb has been dragged.
5134 `end-scroll' end of interaction with scroll bar
5136 The incoming input_event contains in its `part' member an
5137 index of type `enum scroll_bar_part' which we can use as an
5138 index in scroll_bar_parts to get the appropriate symbol. */
5140 case scroll_bar_click
:
5142 Lisp_Object position
, head
, window
, portion_whole
, part
;
5144 window
= event
->frame_or_window
;
5145 portion_whole
= Fcons (event
->x
, event
->y
);
5146 part
= *scroll_bar_parts
[(int) event
->part
];
5150 Fcons (Qvertical_scroll_bar
,
5151 Fcons (portion_whole
,
5152 Fcons (make_number (event
->timestamp
),
5153 Fcons (part
, Qnil
)))));
5155 /* Always treat scroll bar events as clicks. */
5156 event
->modifiers
|= click_modifier
;
5158 /* Get the symbol we should use for the mouse click. */
5159 head
= modify_event_symbol (event
->code
,
5164 XVECTOR (mouse_syms
)->size
);
5165 return Fcons (head
, Fcons (position
, Qnil
));
5168 #endif /* USE_TOOLKIT_SCROLL_BARS */
5171 case w32_scroll_bar_click
:
5173 int button
= event
->code
;
5175 Lisp_Object position
;
5176 Lisp_Object
*start_pos_ptr
;
5177 Lisp_Object start_pos
;
5181 Lisp_Object portion_whole
;
5184 window
= event
->frame_or_window
;
5185 portion_whole
= Fcons (event
->x
, event
->y
);
5186 part
= *scroll_bar_parts
[(int) event
->part
];
5190 Fcons (Qvertical_scroll_bar
,
5191 Fcons (portion_whole
,
5192 Fcons (make_number (event
->timestamp
),
5193 Fcons (part
, Qnil
)))));
5196 /* Always treat W32 scroll bar events as clicks. */
5197 event
->modifiers
|= click_modifier
;
5200 /* Get the symbol we should use for the mouse click. */
5203 head
= modify_event_symbol (button
,
5208 XVECTOR (mouse_syms
)->size
);
5217 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
5220 Lisp_Object head
, position
;
5223 /* Ignore mouse events that were made on frame that
5224 have been deleted. */
5225 if (! FRAME_LIVE_P (f
))
5227 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5228 &column
, &row
, NULL
, 1);
5229 window
= window_from_coordinates (f
, XINT (event
->x
),
5230 XINT (event
->y
), &part
, 0);
5232 if (!WINDOWP (window
))
5234 window
= event
->frame_or_window
;
5239 int pixcolumn
, pixrow
;
5240 column
-= XINT (XWINDOW (window
)->left
);
5241 row
-= XINT (XWINDOW (window
)->top
);
5242 glyph_to_pixel_coords (XWINDOW(window
), column
, row
,
5243 &pixcolumn
, &pixrow
);
5244 XSETINT (event
->x
, pixcolumn
);
5245 XSETINT (event
->y
, pixrow
);
5250 posn
= Qvertical_line
;
5252 posn
= Qheader_line
;
5256 struct display_pos p
;
5257 buffer_posn_from_coords (XWINDOW (window
), &column
, &row
,
5259 posn
= make_number (CHARPOS (p
.pos
));
5264 Lisp_Object head
, position
;
5269 Fcons (Fcons (event
->x
, event
->y
),
5270 Fcons (make_number (event
->timestamp
),
5273 head
= modify_event_symbol (0, event
->modifiers
,
5275 lispy_mouse_wheel_names
,
5276 &mouse_wheel_syms
, 1);
5279 Fcons (make_number (event
->code
),
5283 #endif /* WINDOWSNT */
5293 /* The frame_or_window field should be a cons of the frame in
5294 which the event occurred and a list of the filenames
5296 if (! CONSP (event
->frame_or_window
))
5299 f
= XFRAME (XCAR (event
->frame_or_window
));
5300 files
= XCDR (event
->frame_or_window
);
5302 /* Ignore mouse events that were made on frames that
5303 have been deleted. */
5304 if (! FRAME_LIVE_P (f
))
5307 window
= window_from_coordinates (f
, XINT (event
->x
),
5308 XINT (event
->y
), &part
, 0);
5310 if (!WINDOWP (window
))
5312 window
= XCAR (event
->frame_or_window
);
5317 /* It's an event in window `window' at frame coordinates
5318 event->x/ event->y. */
5319 struct window
*w
= XWINDOW (window
);
5321 /* Get window relative coordinates. */
5322 int wx
= FRAME_TO_WINDOW_PIXEL_X (w
, XINT (event
->x
));
5323 int wy
= FRAME_TO_WINDOW_PIXEL_Y (w
, XINT (event
->y
));
5325 /* Set event coordinates to window-relative coordinates
5326 for constructing the Lisp event below. */
5327 XSETINT (event
->x
, wx
);
5328 XSETINT (event
->y
, wy
);
5333 posn
= Qvertical_line
;
5335 posn
= Qheader_line
;
5339 struct display_pos p
;
5340 buffer_posn_from_coords (w
, &wx
, &wy
, &object
, &p
);
5341 posn
= make_number (CHARPOS (p
.pos
));
5346 Lisp_Object head
, position
;
5351 Fcons (Fcons (event
->x
, event
->y
),
5352 Fcons (make_number (event
->timestamp
),
5355 head
= modify_event_symbol (0, event
->modifiers
,
5357 lispy_drag_n_drop_names
,
5358 &drag_n_drop_syms
, 1);
5365 #endif /* HAVE_MOUSE */
5367 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) || defined (macintosh)
5368 case MENU_BAR_EVENT
:
5369 if (EQ (event
->arg
, event
->frame_or_window
))
5370 /* This is the prefix key. We translate this to
5371 `(menu_bar)' because the code in keyboard.c for menu
5372 events, which we use, relies on this. */
5373 return Fcons (Qmenu_bar
, Qnil
);
5377 case TOOL_BAR_EVENT
:
5378 if (EQ (event
->arg
, event
->frame_or_window
))
5379 /* This is the prefix key. We translate this to
5380 `(tool_bar)' because the code in keyboard.c for menu
5381 events, which we use, relies on this. */
5382 return Fcons (Qtool_bar
, Qnil
);
5383 else if (SYMBOLP (event
->arg
))
5384 return apply_modifiers (event
->modifiers
, event
->arg
);
5387 case USER_SIGNAL_EVENT
:
5388 /* A user signal. */
5389 return *lispy_user_signals
[event
->code
];
5391 /* The 'kind' field of the event is something we don't recognize. */
5400 make_lispy_movement (frame
, bar_window
, part
, x
, y
, time
)
5402 Lisp_Object bar_window
;
5403 enum scroll_bar_part part
;
5407 /* Is it a scroll bar movement? */
5408 if (frame
&& ! NILP (bar_window
))
5410 Lisp_Object part_sym
;
5412 part_sym
= *scroll_bar_parts
[(int) part
];
5413 return Fcons (Qscroll_bar_movement
,
5414 (Fcons (Fcons (bar_window
,
5415 Fcons (Qvertical_scroll_bar
,
5416 Fcons (Fcons (x
, y
),
5417 Fcons (make_number (time
),
5423 /* Or is it an ordinary mouse movement? */
5431 /* It's in a frame; which window on that frame? */
5432 window
= window_from_coordinates (frame
, XINT (x
), XINT (y
), &area
, 0);
5436 if (WINDOWP (window
))
5438 struct window
*w
= XWINDOW (window
);
5441 /* Get window relative coordinates. */
5442 wx
= FRAME_TO_WINDOW_PIXEL_X (w
, XINT (x
));
5443 wy
= FRAME_TO_WINDOW_PIXEL_Y (w
, XINT (y
));
5450 posn
= Qvertical_line
;
5452 posn
= Qheader_line
;
5456 struct display_pos p
;
5457 buffer_posn_from_coords (w
, &wx
, &wy
, &object
, &p
);
5458 posn
= make_number (CHARPOS (p
.pos
));
5461 else if (frame
!= 0)
5463 XSETFRAME (window
, frame
);
5474 return Fcons (Qmouse_movement
,
5475 Fcons (Fcons (window
,
5477 Fcons (Fcons (x
, y
),
5478 Fcons (make_number (time
),
5484 #endif /* HAVE_MOUSE */
5486 /* Construct a switch frame event. */
5488 make_lispy_switch_frame (frame
)
5491 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
5494 /* Manipulating modifiers. */
5496 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5498 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5499 SYMBOL's name of the end of the modifiers; the string from this
5500 position is the unmodified symbol name.
5502 This doesn't use any caches. */
5505 parse_modifiers_uncached (symbol
, modifier_end
)
5509 struct Lisp_String
*name
;
5513 CHECK_SYMBOL (symbol
);
5516 name
= XSYMBOL (symbol
)->name
;
5518 for (i
= 0; i
+2 <= STRING_BYTES (name
); )
5520 int this_mod_end
= 0;
5523 /* See if the name continues with a modifier word.
5524 Check that the word appears, but don't check what follows it.
5525 Set this_mod and this_mod_end to record what we find. */
5527 switch (name
->data
[i
])
5529 #define SINGLE_LETTER_MOD(BIT) \
5530 (this_mod_end = i + 1, this_mod = BIT)
5533 SINGLE_LETTER_MOD (alt_modifier
);
5537 SINGLE_LETTER_MOD (ctrl_modifier
);
5541 SINGLE_LETTER_MOD (hyper_modifier
);
5545 SINGLE_LETTER_MOD (meta_modifier
);
5549 SINGLE_LETTER_MOD (shift_modifier
);
5553 SINGLE_LETTER_MOD (super_modifier
);
5556 #undef SINGLE_LETTER_MOD
5559 /* If we found no modifier, stop looking for them. */
5560 if (this_mod_end
== 0)
5563 /* Check there is a dash after the modifier, so that it
5564 really is a modifier. */
5565 if (this_mod_end
>= STRING_BYTES (name
)
5566 || name
->data
[this_mod_end
] != '-')
5569 /* This modifier is real; look for another. */
5570 modifiers
|= this_mod
;
5571 i
= this_mod_end
+ 1;
5574 /* Should we include the `click' modifier? */
5575 if (! (modifiers
& (down_modifier
| drag_modifier
5576 | double_modifier
| triple_modifier
))
5577 && i
+ 7 == STRING_BYTES (name
)
5578 && strncmp (name
->data
+ i
, "mouse-", 6) == 0
5579 && ('0' <= name
->data
[i
+ 6] && name
->data
[i
+ 6] <= '9'))
5580 modifiers
|= click_modifier
;
5588 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
5589 prepended to the string BASE[0..BASE_LEN-1].
5590 This doesn't use any caches. */
5592 apply_modifiers_uncached (modifiers
, base
, base_len
, base_len_byte
)
5595 int base_len
, base_len_byte
;
5597 /* Since BASE could contain nulls, we can't use intern here; we have
5598 to use Fintern, which expects a genuine Lisp_String, and keeps a
5601 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
5607 /* Only the event queue may use the `up' modifier; it should always
5608 be turned into a click or drag event before presented to lisp code. */
5609 if (modifiers
& up_modifier
)
5612 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
5613 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
5614 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
5615 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
5616 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
5617 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
5618 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
5619 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
5620 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
5621 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
5622 /* The click modifier is denoted by the absence of other modifiers. */
5626 mod_len
= p
- new_mods
;
5630 Lisp_Object new_name
;
5632 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
5633 mod_len
+ base_len_byte
);
5634 bcopy (new_mods
, XSTRING (new_name
)->data
, mod_len
);
5635 bcopy (base
, XSTRING (new_name
)->data
+ mod_len
, base_len_byte
);
5637 return Fintern (new_name
, Qnil
);
5642 static char *modifier_names
[] =
5644 "up", "down", "drag", "click", "double", "triple", 0, 0,
5645 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
5646 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
5648 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
5650 static Lisp_Object modifier_symbols
;
5652 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
5654 lispy_modifier_list (modifiers
)
5657 Lisp_Object modifier_list
;
5660 modifier_list
= Qnil
;
5661 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
5662 if (modifiers
& (1<<i
))
5663 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
5666 return modifier_list
;
5670 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
5671 where UNMODIFIED is the unmodified form of SYMBOL,
5672 MASK is the set of modifiers present in SYMBOL's name.
5673 This is similar to parse_modifiers_uncached, but uses the cache in
5674 SYMBOL's Qevent_symbol_element_mask property, and maintains the
5675 Qevent_symbol_elements property. */
5678 parse_modifiers (symbol
)
5681 Lisp_Object elements
;
5683 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
5684 if (CONSP (elements
))
5689 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
5690 Lisp_Object unmodified
;
5693 unmodified
= Fintern (make_string (XSYMBOL (symbol
)->name
->data
+ end
,
5694 STRING_BYTES (XSYMBOL (symbol
)->name
) - end
),
5697 if (modifiers
& ~VALMASK
)
5699 XSETFASTINT (mask
, modifiers
);
5700 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
5702 /* Cache the parsing results on SYMBOL. */
5703 Fput (symbol
, Qevent_symbol_element_mask
,
5705 Fput (symbol
, Qevent_symbol_elements
,
5706 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
5708 /* Since we know that SYMBOL is modifiers applied to unmodified,
5709 it would be nice to put that in unmodified's cache.
5710 But we can't, since we're not sure that parse_modifiers is
5717 /* Apply the modifiers MODIFIERS to the symbol BASE.
5718 BASE must be unmodified.
5720 This is like apply_modifiers_uncached, but uses BASE's
5721 Qmodifier_cache property, if present. It also builds
5722 Qevent_symbol_elements properties, since it has that info anyway.
5724 apply_modifiers copies the value of BASE's Qevent_kind property to
5725 the modified symbol. */
5727 apply_modifiers (modifiers
, base
)
5731 Lisp_Object cache
, index
, entry
, new_symbol
;
5733 /* Mask out upper bits. We don't know where this value's been. */
5734 modifiers
&= VALMASK
;
5736 /* The click modifier never figures into cache indices. */
5737 cache
= Fget (base
, Qmodifier_cache
);
5738 XSETFASTINT (index
, (modifiers
& ~click_modifier
));
5739 entry
= assq_no_quit (index
, cache
);
5742 new_symbol
= XCDR (entry
);
5745 /* We have to create the symbol ourselves. */
5746 new_symbol
= apply_modifiers_uncached (modifiers
,
5747 XSYMBOL (base
)->name
->data
,
5748 XSYMBOL (base
)->name
->size
,
5749 STRING_BYTES (XSYMBOL (base
)->name
));
5751 /* Add the new symbol to the base's cache. */
5752 entry
= Fcons (index
, new_symbol
);
5753 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
5755 /* We have the parsing info now for free, so add it to the caches. */
5756 XSETFASTINT (index
, modifiers
);
5757 Fput (new_symbol
, Qevent_symbol_element_mask
,
5758 Fcons (base
, Fcons (index
, Qnil
)));
5759 Fput (new_symbol
, Qevent_symbol_elements
,
5760 Fcons (base
, lispy_modifier_list (modifiers
)));
5763 /* Make sure this symbol is of the same kind as BASE.
5765 You'd think we could just set this once and for all when we
5766 intern the symbol above, but reorder_modifiers may call us when
5767 BASE's property isn't set right; we can't assume that just
5768 because it has a Qmodifier_cache property it must have its
5769 Qevent_kind set right as well. */
5770 if (NILP (Fget (new_symbol
, Qevent_kind
)))
5774 kind
= Fget (base
, Qevent_kind
);
5776 Fput (new_symbol
, Qevent_kind
, kind
);
5783 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
5784 return a symbol with the modifiers placed in the canonical order.
5785 Canonical order is alphabetical, except for down and drag, which
5786 always come last. The 'click' modifier is never written out.
5788 Fdefine_key calls this to make sure that (for example) C-M-foo
5789 and M-C-foo end up being equivalent in the keymap. */
5792 reorder_modifiers (symbol
)
5795 /* It's hopefully okay to write the code this way, since everything
5796 will soon be in caches, and no consing will be done at all. */
5799 parsed
= parse_modifiers (symbol
);
5800 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
5805 /* For handling events, we often want to produce a symbol whose name
5806 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
5807 to some base, like the name of a function key or mouse button.
5808 modify_event_symbol produces symbols of this sort.
5810 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
5811 is the name of the i'th symbol. TABLE_SIZE is the number of elements
5814 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
5815 into symbol names, or a string specifying a name stem used to
5816 construct a symbol name or the form `STEM-N', where N is the decimal
5817 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
5818 non-nil; otherwise NAME_TABLE is used.
5820 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
5821 persist between calls to modify_event_symbol that it can use to
5822 store a cache of the symbols it's generated for this NAME_TABLE
5823 before. The object stored there may be a vector or an alist.
5825 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
5827 MODIFIERS is a set of modifier bits (as given in struct input_events)
5828 whose prefixes should be applied to the symbol name.
5830 SYMBOL_KIND is the value to be placed in the event_kind property of
5831 the returned symbol.
5833 The symbols we create are supposed to have an
5834 `event-symbol-elements' property, which lists the modifiers present
5835 in the symbol's name. */
5838 modify_event_symbol (symbol_num
, modifiers
, symbol_kind
, name_alist_or_stem
,
5839 name_table
, symbol_table
, table_size
)
5842 Lisp_Object symbol_kind
;
5843 Lisp_Object name_alist_or_stem
;
5845 Lisp_Object
*symbol_table
;
5846 unsigned int table_size
;
5849 Lisp_Object symbol_int
;
5851 /* Get rid of the "vendor-specific" bit here. */
5852 XSETINT (symbol_int
, symbol_num
& 0xffffff);
5854 /* Is this a request for a valid symbol? */
5855 if (symbol_num
< 0 || symbol_num
>= table_size
)
5858 if (CONSP (*symbol_table
))
5859 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
5861 /* If *symbol_table doesn't seem to be initialized properly, fix that.
5862 *symbol_table should be a lisp vector TABLE_SIZE elements long,
5863 where the Nth element is the symbol for NAME_TABLE[N], or nil if
5864 we've never used that symbol before. */
5867 if (! VECTORP (*symbol_table
)
5868 || XVECTOR (*symbol_table
)->size
!= table_size
)
5872 XSETFASTINT (size
, table_size
);
5873 *symbol_table
= Fmake_vector (size
, Qnil
);
5876 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
5879 /* Have we already used this symbol before? */
5882 /* No; let's create it. */
5883 if (CONSP (name_alist_or_stem
))
5884 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
5885 else if (STRINGP (name_alist_or_stem
))
5887 int len
= STRING_BYTES (XSTRING (name_alist_or_stem
));
5888 char *buf
= (char *) alloca (len
+ 50);
5890 if (sizeof (int) == sizeof (EMACS_INT
))
5891 sprintf (buf
, "%s-%d", XSTRING (name_alist_or_stem
)->data
,
5892 XINT (symbol_int
) + 1);
5893 else if (sizeof (long) == sizeof (EMACS_INT
))
5894 sprintf (buf
, "%s-%ld", XSTRING (name_alist_or_stem
)->data
,
5895 XINT (symbol_int
) + 1);
5898 value
= intern (buf
);
5900 else if (name_table
!= 0 && name_table
[symbol_num
])
5901 value
= intern (name_table
[symbol_num
]);
5903 #ifdef HAVE_WINDOW_SYSTEM
5906 char *name
= x_get_keysym_name (symbol_num
);
5908 value
= intern (name
);
5915 sprintf (buf
, "key-%d", symbol_num
);
5916 value
= intern (buf
);
5919 if (CONSP (*symbol_table
))
5920 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
5922 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
5924 /* Fill in the cache entries for this symbol; this also
5925 builds the Qevent_symbol_elements property, which the user
5927 apply_modifiers (modifiers
& click_modifier
, value
);
5928 Fput (value
, Qevent_kind
, symbol_kind
);
5931 /* Apply modifiers to that symbol. */
5932 return apply_modifiers (modifiers
, value
);
5935 /* Convert a list that represents an event type,
5936 such as (ctrl meta backspace), into the usual representation of that
5937 event type as a number or a symbol. */
5939 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
5940 doc
: /* Convert the event description list EVENT-DESC to an event type.
5941 EVENT-DESC should contain one base event type (a character or symbol)
5942 and zero or more modifier names (control, meta, hyper, super, shift, alt,
5943 drag, down, double or triple). The base must be last.
5944 The return value is an event type (a character or symbol) which
5945 has the same base event type and all the specified modifiers. */)
5947 Lisp_Object event_desc
;
5955 while (CONSP (rest
))
5963 /* Given a symbol, see if it is a modifier name. */
5964 if (SYMBOLP (elt
) && CONSP (rest
))
5965 this = parse_solitary_modifier (elt
);
5969 else if (!NILP (base
))
5970 error ("Two bases given in one event");
5976 /* Let the symbol A refer to the character A. */
5977 if (SYMBOLP (base
) && XSYMBOL (base
)->name
->size
== 1)
5978 XSETINT (base
, XSYMBOL (base
)->name
->data
[0]);
5980 if (INTEGERP (base
))
5982 /* Turn (shift a) into A. */
5983 if ((modifiers
& shift_modifier
) != 0
5984 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
5986 XSETINT (base
, XINT (base
) - ('a' - 'A'));
5987 modifiers
&= ~shift_modifier
;
5990 /* Turn (control a) into C-a. */
5991 if (modifiers
& ctrl_modifier
)
5992 return make_number ((modifiers
& ~ctrl_modifier
)
5993 | make_ctrl_char (XINT (base
)));
5995 return make_number (modifiers
| XINT (base
));
5997 else if (SYMBOLP (base
))
5998 return apply_modifiers (modifiers
, base
);
6001 error ("Invalid base event");
6006 /* Try to recognize SYMBOL as a modifier name.
6007 Return the modifier flag bit, or 0 if not recognized. */
6010 parse_solitary_modifier (symbol
)
6013 struct Lisp_String
*name
= XSYMBOL (symbol
)->name
;
6015 switch (name
->data
[0])
6017 #define SINGLE_LETTER_MOD(BIT) \
6018 if (STRING_BYTES (name) == 1) \
6021 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6022 if (LEN == STRING_BYTES (name) \
6023 && ! strncmp (name->data, NAME, LEN)) \
6027 SINGLE_LETTER_MOD (alt_modifier
);
6031 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6035 SINGLE_LETTER_MOD (ctrl_modifier
);
6039 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6040 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6044 SINGLE_LETTER_MOD (hyper_modifier
);
6048 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6052 SINGLE_LETTER_MOD (meta_modifier
);
6056 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6060 SINGLE_LETTER_MOD (shift_modifier
);
6064 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6065 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6066 SINGLE_LETTER_MOD (super_modifier
);
6070 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6071 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6072 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6076 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6079 #undef SINGLE_LETTER_MOD
6080 #undef MULTI_LETTER_MOD
6086 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6087 Such a list is not valid as an event,
6088 but it can be a Lucid-style event type list. */
6091 lucid_event_type_list_p (object
)
6096 if (! CONSP (object
))
6099 if (EQ (XCAR (object
), Qhelp_echo
)
6100 || EQ (XCAR (object
), Qvertical_line
)
6101 || EQ (XCAR (object
), Qmode_line
)
6102 || EQ (XCAR (object
), Qheader_line
))
6105 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6109 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6116 /* Store into *addr a value nonzero if terminal input chars are available.
6117 Serves the purpose of ioctl (0, FIONREAD, addr)
6118 but works even if FIONREAD does not exist.
6119 (In fact, this may actually read some input.)
6121 If DO_TIMERS_NOW is nonzero, actually run timer events that are ripe. */
6124 get_input_pending (addr
, do_timers_now
)
6128 /* First of all, have we already counted some input? */
6129 *addr
= !NILP (Vquit_flag
) || readable_events (do_timers_now
);
6131 /* If input is being read as it arrives, and we have none, there is none. */
6132 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6135 /* Try to read some input and see how much we get. */
6137 *addr
= !NILP (Vquit_flag
) || readable_events (do_timers_now
);
6140 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6143 gobble_input (expected
)
6148 if (interrupt_input
)
6151 mask
= sigblock (sigmask (SIGIO
));
6152 read_avail_input (expected
);
6156 #ifdef POLL_FOR_INPUT
6157 if (read_socket_hook
&& !interrupt_input
&& poll_suppress_count
== 0)
6160 mask
= sigblock (sigmask (SIGALRM
));
6161 read_avail_input (expected
);
6167 read_avail_input (expected
);
6171 /* Put a buffer_switch_event in the buffer
6172 so that read_key_sequence will notice the new current buffer. */
6175 record_asynch_buffer_change ()
6177 struct input_event event
;
6180 event
.kind
= buffer_switch_event
;
6181 event
.frame_or_window
= Qnil
;
6185 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6186 The purpose of the event is to make read_key_sequence look up the
6187 keymaps again. If we aren't in read_key_sequence, we don't need one,
6188 and the event could cause trouble by messing up (input-pending-p). */
6189 tem
= Fwaiting_for_user_input_p ();
6193 /* We never need these events if we have no asynchronous subprocesses. */
6197 /* Make sure no interrupt happens while storing the event. */
6199 if (interrupt_input
)
6202 mask
= sigblock (sigmask (SIGIO
));
6203 kbd_buffer_store_event (&event
);
6210 kbd_buffer_store_event (&event
);
6217 /* Read any terminal input already buffered up by the system
6218 into the kbd_buffer, but do not wait.
6220 EXPECTED should be nonzero if the caller knows there is some input.
6222 Except on VMS, all input is read by this function.
6223 If interrupt_input is nonzero, this function MUST be called
6224 only when SIGIO is blocked.
6226 Returns the number of keyboard chars read, or -1 meaning
6227 this is a bad time to try to read input. */
6230 read_avail_input (expected
)
6233 struct input_event buf
[KBD_BUFFER_SIZE
];
6237 if (read_socket_hook
)
6238 /* No need for FIONREAD or fcntl; just say don't wait. */
6239 nread
= (*read_socket_hook
) (input_fd
, buf
, KBD_BUFFER_SIZE
, expected
);
6242 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6243 the kbd_buffer can really hold. That may prevent loss
6244 of characters on some systems when input is stuffed at us. */
6245 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6248 /* Determine how many characters we should *try* to read. */
6251 #else /* not WINDOWSNT */
6253 n_to_read
= dos_keysns ();
6256 #else /* not MSDOS */
6258 /* Find out how much input is available. */
6259 if (ioctl (input_fd
, FIONREAD
, &n_to_read
) < 0)
6260 /* Formerly simply reported no input, but that sometimes led to
6261 a failure of Emacs to terminate.
6262 SIGHUP seems appropriate if we can't reach the terminal. */
6263 /* ??? Is it really right to send the signal just to this process
6264 rather than to the whole process group?
6265 Perhaps on systems with FIONREAD Emacs is alone in its group. */
6266 kill (getpid (), SIGHUP
);
6269 if (n_to_read
> sizeof cbuf
)
6270 n_to_read
= sizeof cbuf
;
6271 #else /* no FIONREAD */
6272 #if defined (USG) || defined (DGUX)
6273 /* Read some input if available, but don't wait. */
6274 n_to_read
= sizeof cbuf
;
6275 fcntl (input_fd
, F_SETFL
, O_NDELAY
);
6280 #endif /* not MSDOS */
6281 #endif /* not WINDOWSNT */
6283 /* Now read; for one reason or another, this will not block.
6284 NREAD is set to the number of chars read. */
6288 cbuf
[0] = dos_keyread ();
6291 nread
= emacs_read (input_fd
, cbuf
, n_to_read
);
6293 /* POSIX infers that processes which are not in the session leader's
6294 process group won't get SIGHUP's at logout time. BSDI adheres to
6295 this part standard and returns -1 from read (0) with errno==EIO
6296 when the control tty is taken away.
6297 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6298 if (nread
== -1 && errno
== EIO
)
6300 #if defined (AIX) && (! defined (aix386) && defined (_BSD))
6301 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6302 This looks incorrect, but it isn't, because _BSD causes
6303 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6304 and that causes a value other than 0 when there is no input. */
6310 /* We used to retry the read if it was interrupted.
6311 But this does the wrong thing when O_NDELAY causes
6312 an EAGAIN error. Does anybody know of a situation
6313 where a retry is actually needed? */
6315 nread
< 0 && (errno
== EAGAIN
6329 #if defined (USG) || defined (DGUX)
6330 fcntl (input_fd
, F_SETFL
, 0);
6331 #endif /* USG or DGUX */
6332 #endif /* no FIONREAD */
6333 for (i
= 0; i
< nread
; i
++)
6335 buf
[i
].kind
= ascii_keystroke
;
6336 buf
[i
].modifiers
= 0;
6337 if (meta_key
== 1 && (cbuf
[i
] & 0x80))
6338 buf
[i
].modifiers
= meta_modifier
;
6342 buf
[i
].code
= cbuf
[i
];
6343 buf
[i
].frame_or_window
= selected_frame
;
6348 /* Scan the chars for C-g and store them in kbd_buffer. */
6349 for (i
= 0; i
< nread
; i
++)
6351 kbd_buffer_store_event (&buf
[i
]);
6352 /* Don't look at input that follows a C-g too closely.
6353 This reduces lossage due to autorepeat on C-g. */
6354 if (buf
[i
].kind
== ascii_keystroke
6355 && buf
[i
].code
== quit_char
)
6361 #endif /* not VMS */
6363 #ifdef SIGIO /* for entire page */
6364 /* Note SIGIO has been undef'd if FIONREAD is missing. */
6367 input_available_signal (signo
)
6370 /* Must preserve main program's value of errno. */
6371 int old_errno
= errno
;
6373 extern int select_alarmed
;
6376 #if defined (USG) && !defined (POSIX_SIGNALS)
6377 /* USG systems forget handlers when they are used;
6378 must reestablish each time */
6379 signal (signo
, input_available_signal
);
6386 if (input_available_clear_time
)
6387 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
6392 nread
= read_avail_input (1);
6393 /* -1 means it's not ok to read the input now.
6394 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
6395 0 means there was no keyboard input available. */
6400 select_alarmed
= 1; /* Force the select emulator back to life */
6411 /* Send ourselves a SIGIO.
6413 This function exists so that the UNBLOCK_INPUT macro in
6414 blockinput.h can have some way to take care of input we put off
6415 dealing with, without assuming that every file which uses
6416 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
6418 reinvoke_input_signal ()
6421 kill (getpid (), SIGIO
);
6427 static void menu_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
6428 static void menu_bar_one_keymap
P_ ((Lisp_Object
));
6430 /* These variables hold the vector under construction within
6431 menu_bar_items and its subroutines, and the current index
6432 for storing into that vector. */
6433 static Lisp_Object menu_bar_items_vector
;
6434 static int menu_bar_items_index
;
6436 /* Return a vector of menu items for a menu bar, appropriate
6437 to the current buffer. Each item has three elements in the vector:
6440 OLD is an old vector we can optionally reuse, or nil. */
6443 menu_bar_items (old
)
6446 /* The number of keymaps we're scanning right now, and the number of
6447 keymaps we have allocated space for. */
6450 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
6451 in the current keymaps, or nil where it is not a prefix. */
6454 Lisp_Object def
, tail
;
6463 struct gcpro gcpro1
;
6465 /* In order to build the menus, we need to call the keymap
6466 accessors. They all call QUIT. But this function is called
6467 during redisplay, during which a quit is fatal. So inhibit
6468 quitting while building the menus.
6469 We do this instead of specbind because (1) errors will clear it anyway
6470 and (2) this avoids risk of specpdl overflow. */
6471 oquit
= Vinhibit_quit
;
6475 menu_bar_items_vector
= old
;
6477 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
6478 menu_bar_items_index
= 0;
6480 GCPRO1 (menu_bar_items_vector
);
6482 /* Build our list of keymaps.
6483 If we recognize a function key and replace its escape sequence in
6484 keybuf with its symbol, or if the sequence starts with a mouse
6485 click and we need to switch buffers, we jump back here to rebuild
6486 the initial keymaps from the current buffer. */
6490 /* Should overriding-terminal-local-map and overriding-local-map apply? */
6491 if (!NILP (Voverriding_local_map_menu_flag
))
6493 /* Yes, use them (if non-nil) as well as the global map. */
6494 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
6496 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
6497 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
6498 if (!NILP (Voverriding_local_map
))
6499 maps
[nmaps
++] = Voverriding_local_map
;
6503 /* No, so use major and minor mode keymaps.
6504 Don't include local-map or keymap properties, as menu-bar
6505 bindings are not supported in those maps (that would require
6506 checking for menu-bar updates after every command). */
6507 nmaps
= current_minor_maps (NULL
, &tmaps
);
6508 maps
= (Lisp_Object
*) alloca ((nmaps
+ 2) * sizeof (maps
[0]));
6509 bcopy (tmaps
, maps
, nmaps
* sizeof (maps
[0]));
6510 maps
[nmaps
++] = current_buffer
->keymap
;
6512 maps
[nmaps
++] = current_global_map
;
6515 /* Look up in each map the dummy prefix key `menu-bar'. */
6519 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
6520 if (!NILP (maps
[mapno
]))
6522 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
6525 menu_bar_one_keymap (def
);
6528 /* Move to the end those items that should be at the end. */
6530 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
6533 int end
= menu_bar_items_index
;
6535 for (i
= 0; i
< end
; i
+= 4)
6536 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6538 Lisp_Object tem0
, tem1
, tem2
, tem3
;
6539 /* Move the item at index I to the end,
6540 shifting all the others forward. */
6541 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
6542 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
6543 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
6544 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
6546 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
6547 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
6548 (end
- i
- 4) * sizeof (Lisp_Object
));
6549 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
6550 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
6551 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
6552 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
6557 /* Add nil, nil, nil, nil at the end. */
6558 i
= menu_bar_items_index
;
6559 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
6562 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
6563 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
6564 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
6565 menu_bar_items_vector
= tem
;
6567 /* Add this item. */
6568 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6569 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6570 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6571 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
6572 menu_bar_items_index
= i
;
6574 Vinhibit_quit
= oquit
;
6576 return menu_bar_items_vector
;
6579 /* Scan one map KEYMAP, accumulating any menu items it defines
6580 in menu_bar_items_vector. */
6582 static Lisp_Object menu_bar_one_keymap_changed_items
;
6585 menu_bar_one_keymap (keymap
)
6588 Lisp_Object tail
, item
;
6590 menu_bar_one_keymap_changed_items
= Qnil
;
6592 /* Loop over all keymap entries that have menu strings. */
6593 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
6597 menu_bar_item (XCAR (item
), XCDR (item
));
6598 else if (VECTORP (item
))
6600 /* Loop over the char values represented in the vector. */
6601 int len
= XVECTOR (item
)->size
;
6603 for (c
= 0; c
< len
; c
++)
6605 Lisp_Object character
;
6606 XSETFASTINT (character
, c
);
6607 menu_bar_item (character
, XVECTOR (item
)->contents
[c
]);
6613 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
6614 If there's already an item for KEY, add this DEF to it. */
6616 Lisp_Object item_properties
;
6619 menu_bar_item (key
, item
)
6620 Lisp_Object key
, item
;
6622 struct gcpro gcpro1
;
6626 if (EQ (item
, Qundefined
))
6628 /* If a map has an explicit `undefined' as definition,
6629 discard any previously made menu bar item. */
6631 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
6632 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6634 if (menu_bar_items_index
> i
+ 4)
6635 bcopy (&XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
6636 &XVECTOR (menu_bar_items_vector
)->contents
[i
],
6637 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
6638 menu_bar_items_index
-= 4;
6642 /* If this keymap has already contributed to this KEY,
6643 don't contribute to it a second time. */
6644 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
6645 if (!NILP (tem
) || NILP (item
))
6648 menu_bar_one_keymap_changed_items
6649 = Fcons (key
, menu_bar_one_keymap_changed_items
);
6651 /* We add to menu_bar_one_keymap_changed_items before doing the
6652 parse_menu_item, so that if it turns out it wasn't a menu item,
6653 it still correctly hides any further menu item. */
6655 i
= parse_menu_item (item
, 0, 1);
6660 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
6662 /* Find any existing item for this KEY. */
6663 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
6664 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
6667 /* If we did not find this KEY, add it at the end. */
6668 if (i
== menu_bar_items_index
)
6670 /* If vector is too small, get a bigger one. */
6671 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
6674 tem
= Fmake_vector (make_number (2 * i
), Qnil
);
6675 bcopy (XVECTOR (menu_bar_items_vector
)->contents
,
6676 XVECTOR (tem
)->contents
, i
* sizeof (Lisp_Object
));
6677 menu_bar_items_vector
= tem
;
6680 /* Add this item. */
6681 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
6682 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
6683 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
6684 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
6685 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
6686 menu_bar_items_index
= i
;
6688 /* We did find an item for this KEY. Add ITEM to its list of maps. */
6692 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
6693 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = Fcons (item
, old
);
6697 /* This is used as the handler when calling menu_item_eval_property. */
6699 menu_item_eval_property_1 (arg
)
6702 /* If we got a quit from within the menu computation,
6703 quit all the way out of it. This takes care of C-] in the debugger. */
6704 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
6705 Fsignal (Qquit
, Qnil
);
6710 /* Evaluate an expression and return the result (or nil if something
6711 went wrong). Used to evaluate dynamic parts of menu items. */
6713 menu_item_eval_property (sexpr
)
6716 int count
= specpdl_ptr
- specpdl
;
6718 specbind (Qinhibit_redisplay
, Qt
);
6719 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
6720 menu_item_eval_property_1
);
6721 return unbind_to (count
, val
);
6724 /* This function parses a menu item and leaves the result in the
6725 vector item_properties.
6726 ITEM is a key binding, a possible menu item.
6727 If NOTREAL is nonzero, only check for equivalent key bindings, don't
6728 evaluate dynamic expressions in the menu item.
6729 INMENUBAR is > 0 when this is considered for an entry in a menu bar
6731 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
6732 parse_menu_item returns true if the item is a menu item and false
6736 parse_menu_item (item
, notreal
, inmenubar
)
6738 int notreal
, inmenubar
;
6740 Lisp_Object def
, tem
, item_string
, start
;
6741 Lisp_Object cachelist
;
6743 Lisp_Object keyhint
;
6754 /* Create item_properties vector if necessary. */
6755 if (NILP (item_properties
))
6757 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
6759 /* Initialize optional entries. */
6760 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
6761 AREF (item_properties
, i
) = Qnil
;
6762 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = Qt
;
6764 /* Save the item here to protect it from GC. */
6765 AREF (item_properties
, ITEM_PROPERTY_ITEM
) = item
;
6767 item_string
= XCAR (item
);
6771 if (STRINGP (item_string
))
6773 /* Old format menu item. */
6774 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
6776 /* Maybe help string. */
6777 if (CONSP (item
) && STRINGP (XCAR (item
)))
6779 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
6784 /* Maybe key binding cache. */
6785 if (CONSP (item
) && CONSP (XCAR (item
))
6786 && (NILP (XCAR (XCAR (item
)))
6787 || VECTORP (XCAR (XCAR (item
)))))
6789 cachelist
= XCAR (item
);
6793 /* This is the real definition--the function to run. */
6794 AREF (item_properties
, ITEM_PROPERTY_DEF
) = item
;
6796 /* Get enable property, if any. */
6799 tem
= Fget (item
, Qmenu_enable
);
6801 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
6804 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
6806 /* New format menu item. */
6807 AREF (item_properties
, ITEM_PROPERTY_NAME
) = XCAR (item
);
6808 start
= XCDR (item
);
6811 /* We have a real binding. */
6812 AREF (item_properties
, ITEM_PROPERTY_DEF
) = XCAR (start
);
6814 item
= XCDR (start
);
6815 /* Is there a cache list with key equivalences. */
6816 if (CONSP (item
) && CONSP (XCAR (item
)))
6818 cachelist
= XCAR (item
);
6822 /* Parse properties. */
6823 while (CONSP (item
) && CONSP (XCDR (item
)))
6828 if (EQ (tem
, QCenable
))
6829 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = XCAR (item
);
6830 else if (EQ (tem
, QCvisible
) && !notreal
)
6832 /* If got a visible property and that evaluates to nil
6833 then ignore this item. */
6834 tem
= menu_item_eval_property (XCAR (item
));
6838 else if (EQ (tem
, QChelp
))
6839 AREF (item_properties
, ITEM_PROPERTY_HELP
) = XCAR (item
);
6840 else if (EQ (tem
, QCfilter
))
6842 else if (EQ (tem
, QCkey_sequence
))
6845 if (NILP (cachelist
)
6846 && (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
)))
6847 /* Be GC protected. Set keyhint to item instead of tem. */
6850 else if (EQ (tem
, QCkeys
))
6853 if (CONSP (tem
) || (STRINGP (tem
) && NILP (cachelist
)))
6854 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
6856 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
6861 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
6863 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
6865 AREF (item_properties
, ITEM_PROPERTY_TYPE
)
6872 else if (inmenubar
|| !NILP (start
))
6876 return 0; /* not a menu item */
6878 /* If item string is not a string, evaluate it to get string.
6879 If we don't get a string, skip this item. */
6880 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
6881 if (!(STRINGP (item_string
) || notreal
))
6883 item_string
= menu_item_eval_property (item_string
);
6884 if (!STRINGP (item_string
))
6886 AREF (item_properties
, ITEM_PROPERTY_NAME
) = item_string
;
6889 /* If got a filter apply it on definition. */
6890 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
6893 def
= menu_item_eval_property (list2 (XCAR (filter
),
6894 list2 (Qquote
, def
)));
6896 AREF (item_properties
, ITEM_PROPERTY_DEF
) = def
;
6899 /* Enable or disable selection of item. */
6900 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
6906 tem
= menu_item_eval_property (tem
);
6907 if (inmenubar
&& NILP (tem
))
6908 return 0; /* Ignore disabled items in menu bar. */
6909 AREF (item_properties
, ITEM_PROPERTY_ENABLE
) = tem
;
6912 /* If we got no definition, this item is just unselectable text which
6913 is OK in a submenu but not in the menubar. */
6915 return (inmenubar
? 0 : 1);
6917 /* See if this is a separate pane or a submenu. */
6918 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
6919 tem
= get_keymap (def
, 0, 1);
6920 /* For a subkeymap, just record its details and exit. */
6923 AREF (item_properties
, ITEM_PROPERTY_MAP
) = tem
;
6924 AREF (item_properties
, ITEM_PROPERTY_DEF
) = tem
;
6928 /* At the top level in the menu bar, do likewise for commands also.
6929 The menu bar does not display equivalent key bindings anyway.
6930 ITEM_PROPERTY_DEF is already set up properly. */
6934 /* This is a command. See if there is an equivalent key binding. */
6935 if (NILP (cachelist
))
6937 /* We have to create a cachelist. */
6938 CHECK_IMPURE (start
);
6939 XSETCDR (start
, Fcons (Fcons (Qnil
, Qnil
), XCDR (start
)));
6940 cachelist
= XCAR (XCDR (start
));
6942 tem
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
6943 if (!NILP (keyhint
))
6945 XSETCAR (cachelist
, XCAR (keyhint
));
6948 else if (STRINGP (tem
))
6950 XSETCDR (cachelist
, Fsubstitute_command_keys (tem
));
6951 XSETCAR (cachelist
, Qt
);
6955 tem
= XCAR (cachelist
);
6962 tem
= Fkey_binding (tem
, Qnil
, Qnil
);
6964 prefix
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
6967 def
= XCAR (prefix
);
6968 prefix
= XCDR (prefix
);
6971 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
6973 if (!update_menu_bindings
)
6975 else if (NILP (XCAR (cachelist
))) /* Have no saved key. */
6977 if (newcache
/* Always check first time. */
6978 /* Should we check everything when precomputing key
6980 /* If something had no key binding before, don't recheck it
6981 because that is too slow--except if we have a list of
6982 rebound commands in Vdefine_key_rebound_commands, do
6983 recheck any command that appears in that list. */
6984 || (CONSP (Vdefine_key_rebound_commands
)
6985 && !NILP (Fmemq (def
, Vdefine_key_rebound_commands
))))
6988 /* We had a saved key. Is it still bound to the command? */
6991 /* If the command is an alias for another
6992 (such as lmenu.el set it up), check if the
6993 original command matches the cached command. */
6994 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
6995 chkcache
= 1; /* Need to recompute key binding. */
6999 /* Recompute equivalent key binding. If the command is an alias
7000 for another (such as lmenu.el set it up), see if the original
7001 command name has equivalent keys. Otherwise look up the
7002 specified command itself. We don't try both, because that
7003 makes lmenu menus slow. */
7005 && SYMBOLP (XSYMBOL (def
)->function
)
7006 && ! NILP (Fget (def
, Qmenu_alias
)))
7007 def
= XSYMBOL (def
)->function
;
7008 tem
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qt
);
7009 XSETCAR (cachelist
, tem
);
7012 XSETCDR (cachelist
, Qnil
);
7016 else if (!NILP (keyhint
) && !NILP (XCAR (cachelist
)))
7018 tem
= XCAR (cachelist
);
7022 newcache
= chkcache
;
7025 tem
= Fkey_description (tem
);
7028 if (STRINGP (XCAR (prefix
)))
7029 tem
= concat2 (XCAR (prefix
), tem
);
7030 if (STRINGP (XCDR (prefix
)))
7031 tem
= concat2 (tem
, XCDR (prefix
));
7033 XSETCDR (cachelist
, tem
);
7037 tem
= XCDR (cachelist
);
7038 if (newcache
&& !NILP (tem
))
7040 tem
= concat3 (build_string (" ("), tem
, build_string (")"));
7041 XSETCDR (cachelist
, tem
);
7044 /* If we only want to precompute equivalent key bindings, stop here. */
7048 /* If we have an equivalent key binding, use that. */
7049 AREF (item_properties
, ITEM_PROPERTY_KEYEQ
) = tem
;
7051 /* Include this when menu help is implemented.
7052 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7053 if (!(NILP (tem) || STRINGP (tem)))
7055 tem = menu_item_eval_property (tem);
7058 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7062 /* Handle radio buttons or toggle boxes. */
7063 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7065 AREF (item_properties
, ITEM_PROPERTY_SELECTED
)
7066 = menu_item_eval_property (tem
);
7073 /***********************************************************************
7075 ***********************************************************************/
7077 /* A vector holding tool bar items while they are parsed in function
7078 tool_bar_items runs Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7081 static Lisp_Object tool_bar_items_vector
;
7083 /* A vector holding the result of parse_tool_bar_item. Layout is like
7084 the one for a single item in tool_bar_items_vector. */
7086 static Lisp_Object tool_bar_item_properties
;
7088 /* Next free index in tool_bar_items_vector. */
7090 static int ntool_bar_items
;
7092 /* The symbols `tool-bar', and `:image'. */
7094 extern Lisp_Object Qtool_bar
;
7095 Lisp_Object QCimage
;
7097 /* Function prototypes. */
7099 static void init_tool_bar_items
P_ ((Lisp_Object
));
7100 static void process_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7101 static int parse_tool_bar_item
P_ ((Lisp_Object
, Lisp_Object
));
7102 static void append_tool_bar_item
P_ ((void));
7105 /* Return a vector of tool bar items for keymaps currently in effect.
7106 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7107 tool bar items found. */
7110 tool_bar_items (reuse
, nitems
)
7118 extern Lisp_Object Voverriding_local_map_menu_flag
;
7119 extern Lisp_Object Voverriding_local_map
;
7123 /* In order to build the menus, we need to call the keymap
7124 accessors. They all call QUIT. But this function is called
7125 during redisplay, during which a quit is fatal. So inhibit
7126 quitting while building the menus. We do this instead of
7127 specbind because (1) errors will clear it anyway and (2) this
7128 avoids risk of specpdl overflow. */
7129 oquit
= Vinhibit_quit
;
7132 /* Initialize tool_bar_items_vector and protect it from GC. */
7133 init_tool_bar_items (reuse
);
7135 /* Build list of keymaps in maps. Set nmaps to the number of maps
7138 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7139 if (!NILP (Voverriding_local_map_menu_flag
))
7141 /* Yes, use them (if non-nil) as well as the global map. */
7142 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7144 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
7145 maps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
7146 if (!NILP (Voverriding_local_map
))
7147 maps
[nmaps
++] = Voverriding_local_map
;
7151 /* No, so use major and minor mode keymaps.
7152 Don't include local-map or keymap properties, as tool-bar
7153 bindings are not supported in those maps (that would require
7154 checking for tool-bar updates after every command). */
7155 nmaps
= current_minor_maps (NULL
, &tmaps
);
7156 maps
= (Lisp_Object
*) alloca ((nmaps
+ 2) * sizeof (maps
[0]));
7157 bcopy (tmaps
, maps
, nmaps
* sizeof (maps
[0]));
7158 maps
[nmaps
++] = current_buffer
->keymap
;
7161 /* Add global keymap at the end. */
7162 maps
[nmaps
++] = current_global_map
;
7164 /* Process maps in reverse order and look up in each map the prefix
7166 for (i
= nmaps
- 1; i
>= 0; --i
)
7167 if (!NILP (maps
[i
]))
7171 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7176 /* KEYMAP is a list `(keymap (KEY . BINDING) ...)'. */
7177 for (tail
= keymap
; CONSP (tail
); tail
= XCDR (tail
))
7179 Lisp_Object keydef
= XCAR (tail
);
7181 process_tool_bar_item (XCAR (keydef
), XCDR (keydef
));
7186 Vinhibit_quit
= oquit
;
7187 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7188 return tool_bar_items_vector
;
7192 /* Process the definition of KEY which is DEF. */
7195 process_tool_bar_item (key
, def
)
7196 Lisp_Object key
, def
;
7199 extern Lisp_Object Qundefined
;
7200 struct gcpro gcpro1
, gcpro2
;
7202 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7206 if (EQ (def
, Qundefined
))
7208 /* If a map has an explicit `undefined' as definition,
7209 discard any previously made item. */
7210 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
7212 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
7214 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
7216 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
7217 bcopy (v
+ TOOL_BAR_ITEM_NSLOTS
, v
,
7218 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
7219 * sizeof (Lisp_Object
)));
7220 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
7225 else if (parse_tool_bar_item (key
, def
))
7226 /* Append a new tool bar item to tool_bar_items_vector. Accept
7227 more than one definition for the same key. */
7228 append_tool_bar_item ();
7234 /* Parse a tool bar item specification ITEM for key KEY and return the
7235 result in tool_bar_item_properties. Value is zero if ITEM is
7238 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7240 CAPTION is the caption of the item, If it's not a string, it is
7241 evaluated to get a string.
7243 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7244 as binding are currently ignored.
7246 The following properties are recognized:
7250 FORM is evaluated and specifies whether the tool bar item is
7251 enabled or disabled.
7255 FORM is evaluated and specifies whether the tool bar item is visible.
7257 - `:filter FUNCTION'
7259 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
7260 result is stored as the new binding.
7262 - `:button (TYPE SELECTED)'
7264 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
7265 and specifies whether the button is selected (pressed) or not.
7269 IMAGES is either a single image specification or a vector of four
7270 image specifications. See enum tool_bar_item_images.
7272 - `:help HELP-STRING'.
7274 Gives a help string to display for the tool bar item. */
7277 parse_tool_bar_item (key
, item
)
7278 Lisp_Object key
, item
;
7280 /* Access slot with index IDX of vector tool_bar_item_properties. */
7281 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
7283 Lisp_Object filter
= Qnil
;
7284 Lisp_Object caption
;
7287 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
7288 Rule out items that aren't lists, don't start with
7289 `menu-item' or whose rest following `tool-bar-item' is not a
7292 || !EQ (XCAR (item
), Qmenu_item
)
7293 || (item
= XCDR (item
),
7297 /* Create tool_bar_item_properties vector if necessary. Reset it to
7299 if (VECTORP (tool_bar_item_properties
))
7301 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
7305 tool_bar_item_properties
7306 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
7309 PROP (TOOL_BAR_ITEM_KEY
) = key
;
7310 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
7312 /* Get the caption of the item. If the caption is not a string,
7313 evaluate it to get a string. If we don't get a string, skip this
7315 caption
= XCAR (item
);
7316 if (!STRINGP (caption
))
7318 caption
= menu_item_eval_property (caption
);
7319 if (!STRINGP (caption
))
7322 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
7324 /* Give up if rest following the caption is not a list. */
7329 /* Store the binding. */
7330 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
7333 /* Ignore cached key binding, if any. */
7334 if (CONSP (item
) && CONSP (XCAR (item
)))
7337 /* Process the rest of the properties. */
7338 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
7340 Lisp_Object key
, value
;
7343 value
= XCAR (XCDR (item
));
7345 if (EQ (key
, QCenable
))
7346 /* `:enable FORM'. */
7347 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
7348 else if (EQ (key
, QCvisible
))
7350 /* `:visible FORM'. If got a visible property and that
7351 evaluates to nil then ignore this item. */
7352 if (NILP (menu_item_eval_property (value
)))
7355 else if (EQ (key
, QChelp
))
7356 /* `:help HELP-STRING'. */
7357 PROP (TOOL_BAR_ITEM_HELP
) = value
;
7358 else if (EQ (key
, QCfilter
))
7359 /* ':filter FORM'. */
7361 else if (EQ (key
, QCbutton
) && CONSP (value
))
7363 /* `:button (TYPE . SELECTED)'. */
7364 Lisp_Object type
, selected
;
7366 type
= XCAR (value
);
7367 selected
= XCDR (value
);
7368 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7370 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
7371 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
7374 else if (EQ (key
, QCimage
)
7376 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
7377 /* Value is either a single image specification or a vector
7378 of 4 such specifications for the different buttion states. */
7379 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
7382 /* If got a filter apply it on binding. */
7384 PROP (TOOL_BAR_ITEM_BINDING
)
7385 = menu_item_eval_property (list2 (filter
,
7387 PROP (TOOL_BAR_ITEM_BINDING
))));
7389 /* See if the binding is a keymap. Give up if it is. */
7390 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
7393 /* Enable or disable selection of item. */
7394 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
7395 PROP (TOOL_BAR_ITEM_ENABLED_P
)
7396 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
7398 /* Handle radio buttons or toggle boxes. */
7399 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
7400 PROP (TOOL_BAR_ITEM_SELECTED_P
)
7401 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
7409 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
7410 that can be reused. */
7413 init_tool_bar_items (reuse
)
7416 if (VECTORP (reuse
))
7417 tool_bar_items_vector
= reuse
;
7419 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
7420 ntool_bar_items
= 0;
7424 /* Append parsed tool bar item properties from
7425 tool_bar_item_properties */
7428 append_tool_bar_item ()
7430 Lisp_Object
*to
, *from
;
7432 /* Enlarge tool_bar_items_vector if necessary. */
7433 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
7434 >= XVECTOR (tool_bar_items_vector
)->size
)
7436 Lisp_Object new_vector
;
7437 int old_size
= XVECTOR (tool_bar_items_vector
)->size
;
7439 new_vector
= Fmake_vector (make_number (2 * old_size
), Qnil
);
7440 bcopy (XVECTOR (tool_bar_items_vector
)->contents
,
7441 XVECTOR (new_vector
)->contents
,
7442 old_size
* sizeof (Lisp_Object
));
7443 tool_bar_items_vector
= new_vector
;
7446 /* Append entries from tool_bar_item_properties to the end of
7447 tool_bar_items_vector. */
7448 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
7449 from
= XVECTOR (tool_bar_item_properties
)->contents
;
7450 bcopy (from
, to
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
7451 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
7458 /* Read a character using menus based on maps in the array MAPS.
7459 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
7460 Return t if we displayed a menu but the user rejected it.
7462 PREV_EVENT is the previous input event, or nil if we are reading
7463 the first event of a key sequence.
7465 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
7466 if we used a mouse menu to read the input, or zero otherwise. If
7467 USED_MOUSE_MENU is null, we don't dereference it.
7469 The prompting is done based on the prompt-string of the map
7470 and the strings associated with various map elements.
7472 This can be done with X menus or with menus put in the minibuf.
7473 These are done in different ways, depending on how the input will be read.
7474 Menus using X are done after auto-saving in read-char, getting the input
7475 event from Fx_popup_menu; menus using the minibuf use read_char recursively
7476 and do auto-saving in the inner call of read_char. */
7479 read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
)
7482 Lisp_Object prev_event
;
7483 int *used_mouse_menu
;
7486 register Lisp_Object name
;
7488 if (used_mouse_menu
)
7489 *used_mouse_menu
= 0;
7491 /* Use local over global Menu maps */
7493 if (! menu_prompting
)
7496 /* Optionally disregard all but the global map. */
7497 if (inhibit_local_menu_bar_menus
)
7499 maps
+= (nmaps
- 1);
7503 /* Get the menu name from the first map that has one (a prompt string). */
7504 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7506 name
= Fkeymap_prompt (maps
[mapno
]);
7511 /* If we don't have any menus, just read a character normally. */
7516 /* If we got to this point via a mouse click,
7517 use a real menu for mouse selection. */
7518 if (EVENT_HAS_PARAMETERS (prev_event
)
7519 && !EQ (XCAR (prev_event
), Qmenu_bar
)
7520 && !EQ (XCAR (prev_event
), Qtool_bar
))
7522 /* Display the menu and get the selection. */
7523 Lisp_Object
*realmaps
7524 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
7528 /* Use the maps that are not nil. */
7529 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7530 if (!NILP (maps
[mapno
]))
7531 realmaps
[nmaps1
++] = maps
[mapno
];
7533 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
7538 record_menu_key (XCAR (value
));
7540 /* If we got multiple events, unread all but
7542 There is no way to prevent those unread events
7543 from showing up later in last_nonmenu_event.
7544 So turn symbol and integer events into lists,
7545 to indicate that they came from a mouse menu,
7546 so that when present in last_nonmenu_event
7547 they won't confuse things. */
7548 for (tem
= XCDR (value
); !NILP (tem
); tem
= XCDR (tem
))
7550 record_menu_key (XCAR (tem
));
7551 if (SYMBOLP (XCAR (tem
))
7552 || INTEGERP (XCAR (tem
)))
7553 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
7556 /* If we got more than one event, put all but the first
7557 onto this list to be read later.
7558 Return just the first event now. */
7559 Vunread_command_events
7560 = nconc2 (XCDR (value
), Vunread_command_events
);
7561 value
= XCAR (value
);
7563 else if (NILP (value
))
7565 if (used_mouse_menu
)
7566 *used_mouse_menu
= 1;
7569 #endif /* HAVE_MENUS */
7573 /* Buffer in use so far for the minibuf prompts for menu keymaps.
7574 We make this bigger when necessary, and never free it. */
7575 static char *read_char_minibuf_menu_text
;
7576 /* Size of that buffer. */
7577 static int read_char_minibuf_menu_width
;
7580 read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
)
7586 register Lisp_Object name
;
7588 int width
= FRAME_WIDTH (SELECTED_FRAME ()) - 4;
7591 Lisp_Object rest
, vector
;
7597 if (! menu_prompting
)
7600 /* Make sure we have a big enough buffer for the menu text. */
7601 if (read_char_minibuf_menu_text
== 0)
7603 read_char_minibuf_menu_width
= width
+ 4;
7604 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
7606 else if (width
+ 4 > read_char_minibuf_menu_width
)
7608 read_char_minibuf_menu_width
= width
+ 4;
7609 read_char_minibuf_menu_text
7610 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
7612 menu
= read_char_minibuf_menu_text
;
7614 /* Get the menu name from the first map that has one (a prompt string). */
7615 for (mapno
= 0; mapno
< nmaps
; mapno
++)
7617 name
= Fkeymap_prompt (maps
[mapno
]);
7622 /* If we don't have any menus, just read a character normally. */
7623 if (!STRINGP (name
));
7626 /* Prompt string always starts with map's prompt, and a space. */
7627 strcpy (menu
, XSTRING (name
)->data
);
7628 nlength
= STRING_BYTES (XSTRING (name
));
7629 menu
[nlength
++] = ':';
7630 menu
[nlength
++] = ' ';
7633 /* Start prompting at start of first map. */
7637 /* Present the documented bindings, a line at a time. */
7644 Lisp_Object orig_defn_macro
;
7646 /* Loop over elements of map. */
7651 /* If reached end of map, start at beginning of next map. */
7655 /* At end of last map, wrap around to first map if just starting,
7656 or end this line if already have something on it. */
7660 if (notfirst
|| nobindings
) break;
7665 /* Look at the next element of the map. */
7667 elt
= XVECTOR (vector
)->contents
[idx
];
7669 elt
= Fcar_safe (rest
);
7671 if (idx
< 0 && VECTORP (elt
))
7673 /* If we found a dense table in the keymap,
7674 advanced past it, but start scanning its contents. */
7675 rest
= Fcdr_safe (rest
);
7681 /* An ordinary element. */
7682 Lisp_Object event
, tem
;
7686 event
= Fcar_safe (elt
); /* alist */
7687 elt
= Fcdr_safe (elt
);
7691 XSETINT (event
, idx
); /* vector */
7694 /* Ignore the element if it has no prompt string. */
7695 if (INTEGERP (event
) && parse_menu_item (elt
, 0, -1))
7697 /* 1 if the char to type matches the string. */
7699 Lisp_Object upcased_event
, downcased_event
;
7700 Lisp_Object desc
= Qnil
;
7702 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7704 upcased_event
= Fupcase (event
);
7705 downcased_event
= Fdowncase (event
);
7706 char_matches
= (XINT (upcased_event
) == XSTRING (s
)->data
[0]
7707 || XINT (downcased_event
) == XSTRING (s
)->data
[0]);
7709 desc
= Fsingle_key_description (event
, Qnil
);
7712 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
7714 /* Insert equivalent keybinding. */
7715 s
= concat2 (s
, tem
);
7718 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
7719 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
7721 /* Insert button prefix. */
7722 Lisp_Object selected
7723 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
7724 if (EQ (tem
, QCradio
))
7725 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
7727 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
7728 s
= concat2 (tem
, s
);
7732 /* If we have room for the prompt string, add it to this line.
7733 If this is the first on the line, always add it. */
7734 if ((XSTRING (s
)->size
+ i
+ 2
7735 + (char_matches
? 0 : XSTRING (desc
)->size
+ 3))
7741 /* Punctuate between strings. */
7744 strcpy (menu
+ i
, ", ");
7750 /* If the char to type doesn't match the string's
7751 first char, explicitly show what char to type. */
7754 /* Add as much of string as fits. */
7755 thiswidth
= XSTRING (desc
)->size
;
7756 if (thiswidth
+ i
> width
)
7757 thiswidth
= width
- i
;
7758 bcopy (XSTRING (desc
)->data
, menu
+ i
, thiswidth
);
7760 strcpy (menu
+ i
, " = ");
7764 /* Add as much of string as fits. */
7765 thiswidth
= XSTRING (s
)->size
;
7766 if (thiswidth
+ i
> width
)
7767 thiswidth
= width
- i
;
7768 bcopy (XSTRING (s
)->data
, menu
+ i
, thiswidth
);
7774 /* If this element does not fit, end the line now,
7775 and save the element for the next line. */
7776 strcpy (menu
+ i
, "...");
7781 /* Move past this element. */
7782 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
7783 /* Handle reaching end of dense table. */
7788 rest
= Fcdr_safe (rest
);
7792 /* Prompt with that and read response. */
7793 message2_nolog (menu
, strlen (menu
),
7794 ! NILP (current_buffer
->enable_multibyte_characters
));
7796 /* Make believe its not a keyboard macro in case the help char
7797 is pressed. Help characters are not recorded because menu prompting
7798 is not used on replay.
7800 orig_defn_macro
= current_kboard
->defining_kbd_macro
;
7801 current_kboard
->defining_kbd_macro
= Qnil
;
7803 obj
= read_char (commandflag
, 0, 0, Qt
, 0);
7804 while (BUFFERP (obj
));
7805 current_kboard
->defining_kbd_macro
= orig_defn_macro
;
7807 if (!INTEGERP (obj
))
7812 if (! EQ (obj
, menu_prompt_more_char
)
7813 && (!INTEGERP (menu_prompt_more_char
)
7814 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
7816 if (!NILP (current_kboard
->defining_kbd_macro
))
7817 store_kbd_macro_char (obj
);
7820 /* Help char - go round again */
7824 /* Reading key sequences. */
7826 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
7827 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
7828 keymap, or nil otherwise. Return the index of the first keymap in
7829 which KEY has any binding, or NMAPS if no map has a binding.
7831 If KEY is a meta ASCII character, treat it like meta-prefix-char
7832 followed by the corresponding non-meta character. Keymaps in
7833 CURRENT with non-prefix bindings for meta-prefix-char become nil in
7836 If KEY has no bindings in any of the CURRENT maps, NEXT is left
7839 NEXT may be the same array as CURRENT. */
7842 follow_key (key
, nmaps
, current
, defs
, next
)
7844 Lisp_Object
*current
, *defs
, *next
;
7847 int i
, first_binding
;
7850 first_binding
= nmaps
;
7851 for (i
= nmaps
- 1; i
>= 0; i
--)
7853 if (! NILP (current
[i
]))
7861 defs
[i
] = access_keymap (map
, key
, 1, 0, 1);
7862 if (! NILP (defs
[i
]))
7869 /* Given the set of bindings we've found, produce the next set of maps. */
7870 if (first_binding
< nmaps
)
7871 for (i
= 0; i
< nmaps
; i
++)
7872 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
7874 return first_binding
;
7877 /* Read a sequence of keys that ends with a non prefix character,
7878 storing it in KEYBUF, a buffer of size BUFSIZE.
7880 Return the length of the key sequence stored.
7881 Return -1 if the user rejected a command menu.
7883 Echo starting immediately unless `prompt' is 0.
7885 Where a key sequence ends depends on the currently active keymaps.
7886 These include any minor mode keymaps active in the current buffer,
7887 the current buffer's local map, and the global map.
7889 If a key sequence has no other bindings, we check Vfunction_key_map
7890 to see if some trailing subsequence might be the beginning of a
7891 function key's sequence. If so, we try to read the whole function
7892 key, and substitute its symbolic name into the key sequence.
7894 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
7895 `double-' events into similar click events, if that would make them
7896 bound. We try to turn `triple-' events first into `double-' events,
7899 If we get a mouse click in a mode line, vertical divider, or other
7900 non-text area, we treat the click as if it were prefixed by the
7901 symbol denoting that area - `mode-line', `vertical-line', or
7904 If the sequence starts with a mouse click, we read the key sequence
7905 with respect to the buffer clicked on, not the current buffer.
7907 If the user switches frames in the midst of a key sequence, we put
7908 off the switch-frame event until later; the next call to
7909 read_char will return it.
7911 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
7912 from the selected window's buffer. */
7915 read_key_sequence (keybuf
, bufsize
, prompt
, dont_downcase_last
,
7916 can_return_switch_frame
, fix_current_buffer
)
7917 Lisp_Object
*keybuf
;
7920 int dont_downcase_last
;
7921 int can_return_switch_frame
;
7922 int fix_current_buffer
;
7924 volatile Lisp_Object from_string
;
7925 volatile int count
= specpdl_ptr
- specpdl
;
7927 /* How many keys there are in the current key sequence. */
7930 /* The length of the echo buffer when we started reading, and
7931 the length of this_command_keys when we started reading. */
7932 volatile int echo_start
;
7933 volatile int keys_start
;
7935 /* The number of keymaps we're scanning right now, and the number of
7936 keymaps we have allocated space for. */
7938 volatile int nmaps_allocated
= 0;
7940 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
7941 the current keymaps. */
7942 Lisp_Object
*volatile defs
= NULL
;
7944 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7945 in the current keymaps, or nil where it is not a prefix. */
7946 Lisp_Object
*volatile submaps
= NULL
;
7948 /* The local map to start out with at start of key sequence. */
7949 volatile Lisp_Object orig_local_map
;
7951 /* The map from the `keymap' property to start out with at start of
7953 volatile Lisp_Object orig_keymap
;
7955 /* 1 if we have already considered switching to the local-map property
7956 of the place where a mouse click occurred. */
7957 volatile int localized_local_map
= 0;
7959 /* The index in defs[] of the first keymap that has a binding for
7960 this key sequence. In other words, the lowest i such that
7961 defs[i] is non-nil. */
7962 volatile int first_binding
;
7963 /* Index of the first key that has no binding.
7964 It is useless to try fkey_start larger than that. */
7965 volatile int first_unbound
;
7967 /* If t < mock_input, then KEYBUF[t] should be read as the next
7970 We use this to recover after recognizing a function key. Once we
7971 realize that a suffix of the current key sequence is actually a
7972 function key's escape sequence, we replace the suffix with the
7973 function key's binding from Vfunction_key_map. Now keybuf
7974 contains a new and different key sequence, so the echo area,
7975 this_command_keys, and the submaps and defs arrays are wrong. In
7976 this situation, we set mock_input to t, set t to 0, and jump to
7977 restart_sequence; the loop will read keys from keybuf up until
7978 mock_input, thus rebuilding the state; and then it will resume
7979 reading characters from the keyboard. */
7980 volatile int mock_input
= 0;
7982 /* If the sequence is unbound in submaps[], then
7983 keybuf[fkey_start..fkey_end-1] is a prefix in Vfunction_key_map,
7984 and fkey_map is its binding.
7986 These might be > t, indicating that all function key scanning
7987 should hold off until t reaches them. We do this when we've just
7988 recognized a function key, to avoid searching for the function
7989 key's again in Vfunction_key_map. */
7990 volatile int fkey_start
= 0, fkey_end
= 0;
7991 volatile Lisp_Object fkey_map
;
7993 /* Likewise, for key_translation_map. */
7994 volatile int keytran_start
= 0, keytran_end
= 0;
7995 volatile Lisp_Object keytran_map
;
7997 /* If we receive a ``switch-frame'' event in the middle of a key sequence,
7998 we put it off for later. While we're reading, we keep the event here. */
7999 volatile Lisp_Object delayed_switch_frame
;
8001 /* See the comment below... */
8002 #if defined (GOBBLE_FIRST_EVENT)
8003 Lisp_Object first_event
;
8006 volatile Lisp_Object original_uppercase
;
8007 volatile int original_uppercase_position
= -1;
8009 /* Gets around Microsoft compiler limitations. */
8012 struct buffer
*starting_buffer
;
8014 /* Nonzero if we seem to have got the beginning of a binding
8015 in function_key_map. */
8016 volatile int function_key_possible
= 0;
8017 volatile int key_translation_possible
= 0;
8019 /* List of events for which a fake prefix key has been generated. */
8020 volatile Lisp_Object fake_prefixed_keys
= Qnil
;
8022 /* Save the status of key translation before each step,
8023 so that we can restore this after downcasing. */
8024 Lisp_Object prev_fkey_map
;
8025 int prev_fkey_start
;
8028 Lisp_Object prev_keytran_map
;
8029 int prev_keytran_start
;
8030 int prev_keytran_end
;
8032 #if defined (GOBBLE_FIRST_EVENT)
8036 struct gcpro gcpro1
;
8038 GCPRO1 (fake_prefixed_keys
);
8039 raw_keybuf_count
= 0;
8041 last_nonmenu_event
= Qnil
;
8043 delayed_switch_frame
= Qnil
;
8044 fkey_map
= Vfunction_key_map
;
8045 keytran_map
= Vkey_translation_map
;
8047 /* If there is no function-key-map, turn off function key scanning. */
8048 if (!KEYMAPP (Vfunction_key_map
))
8049 fkey_start
= fkey_end
= bufsize
+ 1;
8051 /* If there is no key-translation-map, turn off scanning. */
8052 if (!KEYMAPP (Vkey_translation_map
))
8053 keytran_start
= keytran_end
= bufsize
+ 1;
8058 echo_prompt (prompt
);
8059 else if (cursor_in_echo_area
8060 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8061 && NILP (Fzerop (Vecho_keystrokes
)))
8062 /* This doesn't put in a dash if the echo buffer is empty, so
8063 you don't always see a dash hanging out in the minibuffer. */
8067 /* Record the initial state of the echo area and this_command_keys;
8068 we will need to restore them if we replay a key sequence. */
8070 echo_start
= echo_length ();
8071 keys_start
= this_command_key_count
;
8072 this_single_command_key_start
= keys_start
;
8074 #if defined (GOBBLE_FIRST_EVENT)
8075 /* This doesn't quite work, because some of the things that read_char
8076 does cannot safely be bypassed. It seems too risky to try to make
8079 /* Read the first char of the sequence specially, before setting
8080 up any keymaps, in case a filter runs and switches buffers on us. */
8081 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
8083 #endif /* GOBBLE_FIRST_EVENT */
8085 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8086 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8089 /* We jump here when the key sequence has been thoroughly changed, and
8090 we need to rescan it starting from the beginning. When we jump here,
8091 keybuf[0..mock_input] holds the sequence we should reread. */
8094 starting_buffer
= current_buffer
;
8095 function_key_possible
= 0;
8096 key_translation_possible
= 0;
8097 first_unbound
= bufsize
+ 1;
8099 /* Build our list of keymaps.
8100 If we recognize a function key and replace its escape sequence in
8101 keybuf with its symbol, or if the sequence starts with a mouse
8102 click and we need to switch buffers, we jump back here to rebuild
8103 the initial keymaps from the current buffer. */
8106 if (!NILP (current_kboard
->Voverriding_terminal_local_map
)
8107 || !NILP (Voverriding_local_map
))
8109 if (3 > nmaps_allocated
)
8111 submaps
= (Lisp_Object
*) alloca (3 * sizeof (submaps
[0]));
8112 defs
= (Lisp_Object
*) alloca (3 * sizeof (defs
[0]));
8113 nmaps_allocated
= 3;
8115 if (!NILP (current_kboard
->Voverriding_terminal_local_map
))
8116 submaps
[nmaps
++] = current_kboard
->Voverriding_terminal_local_map
;
8117 if (!NILP (Voverriding_local_map
))
8118 submaps
[nmaps
++] = Voverriding_local_map
;
8126 nminor
= current_minor_maps (0, &maps
);
8127 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
8129 if (total
> nmaps_allocated
)
8131 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
8132 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
8133 nmaps_allocated
= total
;
8136 if (!NILP (orig_keymap
))
8137 submaps
[nmaps
++] = orig_keymap
;
8139 bcopy (maps
, (void *) (submaps
+ nmaps
),
8140 nminor
* sizeof (submaps
[0]));
8144 submaps
[nmaps
++] = orig_local_map
;
8146 submaps
[nmaps
++] = current_global_map
;
8148 /* Find an accurate initial value for first_binding. */
8149 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
8150 if (! NILP (submaps
[first_binding
]))
8153 /* Start from the beginning in keybuf. */
8156 /* These are no-ops the first time through, but if we restart, they
8157 revert the echo area and this_command_keys to their original state. */
8158 this_command_key_count
= keys_start
;
8159 if (INTERACTIVE
&& t
< mock_input
)
8160 echo_truncate (echo_start
);
8162 /* If the best binding for the current key sequence is a keymap, or
8163 we may be looking at a function key's escape sequence, keep on
8165 while ((first_binding
< nmaps
&& ! NILP (submaps
[first_binding
]))
8166 || (first_binding
>= nmaps
8168 || (first_binding
>= nmaps
8169 && keytran_start
< t
&& key_translation_possible
)
8170 /* Don't return in the middle of a possible function key sequence,
8171 if the only bindings we found were via case conversion.
8172 Thus, if ESC O a has a function-key-map translation
8173 and ESC o has a binding, don't return after ESC O,
8174 so that we can translate ESC O plus the next character. */
8178 int used_mouse_menu
= 0;
8180 /* Where the last real key started. If we need to throw away a
8181 key that has expanded into more than one element of keybuf
8182 (say, a mouse click on the mode line which is being treated
8183 as [mode-line (mouse-...)], then we backtrack to this point
8185 volatile int last_real_key_start
;
8187 /* These variables are analogous to echo_start and keys_start;
8188 while those allow us to restart the entire key sequence,
8189 echo_local_start and keys_local_start allow us to throw away
8191 volatile int echo_local_start
, keys_local_start
, local_first_binding
;
8194 if (first_unbound
< fkey_start
&& first_unbound
< keytran_start
)
8195 { /* The prefix upto first_unbound has no binding and has
8196 no translation left to do either, so we know it's unbound.
8197 If we don't stop now, we risk staying here indefinitely
8198 (if the user keeps entering fkey or keytran prefixes
8199 like C-c ESC ESC ESC ESC ...) */
8201 for (i
= first_unbound
+ 1; i
< t
; i
++)
8202 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
8203 mock_input
= t
- first_unbound
- 1;
8204 fkey_end
= fkey_start
-= first_unbound
+ 1;
8205 fkey_map
= Vfunction_key_map
;
8206 keytran_end
= keytran_start
-= first_unbound
+ 1;
8207 keytran_map
= Vkey_translation_map
;
8208 goto replay_sequence
;
8212 error ("Key sequence too long");
8215 echo_local_start
= echo_length ();
8216 keys_local_start
= this_command_key_count
;
8217 local_first_binding
= first_binding
;
8220 /* These are no-ops, unless we throw away a keystroke below and
8221 jumped back up to replay_key; in that case, these restore the
8222 variables to their original state, allowing us to replay the
8224 if (INTERACTIVE
&& t
< mock_input
)
8225 echo_truncate (echo_local_start
);
8226 this_command_key_count
= keys_local_start
;
8227 first_binding
= local_first_binding
;
8229 /* By default, assume each event is "real". */
8230 last_real_key_start
= t
;
8232 /* Does mock_input indicate that we are re-reading a key sequence? */
8236 add_command_key (key
);
8237 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8238 && NILP (Fzerop (Vecho_keystrokes
)))
8242 /* If not, we should actually read a character. */
8247 KBOARD
*interrupted_kboard
= current_kboard
;
8248 struct frame
*interrupted_frame
= SELECTED_FRAME ();
8249 if (setjmp (wrong_kboard_jmpbuf
))
8251 if (!NILP (delayed_switch_frame
))
8253 interrupted_kboard
->kbd_queue
8254 = Fcons (delayed_switch_frame
,
8255 interrupted_kboard
->kbd_queue
);
8256 delayed_switch_frame
= Qnil
;
8259 interrupted_kboard
->kbd_queue
8260 = Fcons (keybuf
[--t
], interrupted_kboard
->kbd_queue
);
8262 /* If the side queue is non-empty, ensure it begins with a
8263 switch-frame, so we'll replay it in the right context. */
8264 if (CONSP (interrupted_kboard
->kbd_queue
)
8265 && (key
= XCAR (interrupted_kboard
->kbd_queue
),
8266 !(EVENT_HAS_PARAMETERS (key
)
8267 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
8271 XSETFRAME (frame
, interrupted_frame
);
8272 interrupted_kboard
->kbd_queue
8273 = Fcons (make_lispy_switch_frame (frame
),
8274 interrupted_kboard
->kbd_queue
);
8277 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8278 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8279 goto replay_sequence
;
8282 key
= read_char (NILP (prompt
), nmaps
,
8283 (Lisp_Object
*) submaps
, last_nonmenu_event
,
8287 /* read_char returns t when it shows a menu and the user rejects it.
8291 unbind_to (count
, Qnil
);
8296 /* read_char returns -1 at the end of a macro.
8297 Emacs 18 handles this by returning immediately with a
8298 zero, so that's what we'll do. */
8299 if (INTEGERP (key
) && XINT (key
) == -1)
8302 /* The Microsoft C compiler can't handle the goto that
8308 /* If the current buffer has been changed from under us, the
8309 keymap may have changed, so replay the sequence. */
8313 /* Reset the current buffer from the selected window
8314 in case something changed the former and not the latter.
8315 This is to be more consistent with the behavior
8316 of the command_loop_1. */
8317 if (fix_current_buffer
)
8319 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8321 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
8322 Fset_buffer (XWINDOW (selected_window
)->buffer
);
8325 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8326 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8327 goto replay_sequence
;
8330 /* If we have a quit that was typed in another frame, and
8331 quit_throw_to_read_char switched buffers,
8332 replay to get the right keymap. */
8334 && XINT (key
) == quit_char
8335 && current_buffer
!= starting_buffer
)
8338 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8342 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
8343 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8344 goto replay_sequence
;
8349 if (EVENT_HAS_PARAMETERS (key
)
8350 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
8352 /* If we're at the beginning of a key sequence, and the caller
8353 says it's okay, go ahead and return this event. If we're
8354 in the midst of a key sequence, delay it until the end. */
8355 if (t
> 0 || !can_return_switch_frame
)
8357 delayed_switch_frame
= key
;
8363 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8366 /* Clicks in non-text areas get prefixed by the symbol
8367 in their CHAR-ADDRESS field. For example, a click on
8368 the mode line is prefixed by the symbol `mode-line'.
8370 Furthermore, key sequences beginning with mouse clicks
8371 are read using the keymaps of the buffer clicked on, not
8372 the current buffer. So we may have to switch the buffer
8375 When we turn one event into two events, we must make sure
8376 that neither of the two looks like the original--so that,
8377 if we replay the events, they won't be expanded again.
8378 If not for this, such reexpansion could happen either here
8379 or when user programs play with this-command-keys. */
8380 if (EVENT_HAS_PARAMETERS (key
))
8384 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
8385 if (EQ (kind
, Qmouse_click
))
8387 Lisp_Object window
, posn
;
8389 window
= POSN_WINDOW (EVENT_START (key
));
8390 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
8393 || (!NILP (fake_prefixed_keys
)
8394 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
8396 /* We're looking a second time at an event for which
8397 we generated a fake prefix key. Set
8398 last_real_key_start appropriately. */
8400 last_real_key_start
= t
- 1;
8403 /* Key sequences beginning with mouse clicks are
8404 read using the keymaps in the buffer clicked on,
8405 not the current buffer. If we're at the
8406 beginning of a key sequence, switch buffers. */
8407 if (last_real_key_start
== 0
8409 && BUFFERP (XWINDOW (window
)->buffer
)
8410 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
8412 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
8416 /* Arrange to go back to the original buffer once we're
8417 done reading the key sequence. Note that we can't
8418 use save_excursion_{save,restore} here, because they
8419 save point as well as the current buffer; we don't
8420 want to save point, because redisplay may change it,
8421 to accommodate a Fset_window_start or something. We
8422 don't want to do this at the top of the function,
8423 because we may get input from a subprocess which
8424 wants to change the selected window and stuff (say,
8426 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
8428 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
8430 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
8431 orig_local_map
= get_local_map (PT
, current_buffer
,
8433 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
8434 goto replay_sequence
;
8437 /* For a mouse click, get the local text-property keymap
8438 of the place clicked on, rather than point. */
8439 if (last_real_key_start
== 0
8440 && CONSP (XCDR (key
))
8441 && ! localized_local_map
)
8443 Lisp_Object map_here
, start
, pos
;
8445 localized_local_map
= 1;
8446 start
= EVENT_START (key
);
8448 if (CONSP (start
) && CONSP (XCDR (start
)))
8450 pos
= POSN_BUFFER_POSN (start
);
8452 && XINT (pos
) >= BEG
&& XINT (pos
) <= Z
)
8454 map_here
= get_local_map (XINT (pos
),
8455 current_buffer
, Qlocal_map
);
8456 if (!EQ (map_here
, orig_local_map
))
8458 orig_local_map
= map_here
;
8462 goto replay_sequence
;
8464 map_here
= get_local_map (XINT (pos
),
8465 current_buffer
, Qkeymap
);
8466 if (!EQ (map_here
, orig_keymap
))
8468 orig_keymap
= map_here
;
8472 goto replay_sequence
;
8478 /* Expand mode-line and scroll-bar events into two events:
8479 use posn as a fake prefix key. */
8481 && (NILP (fake_prefixed_keys
)
8482 || NILP (Fmemq (key
, fake_prefixed_keys
))))
8484 if (t
+ 1 >= bufsize
)
8485 error ("Key sequence too long");
8488 keybuf
[t
+ 1] = key
;
8491 /* Record that a fake prefix key has been generated
8492 for KEY. Don't modify the event; this would
8493 prevent proper action when the event is pushed
8494 back tino unread-command-events. */
8495 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
8497 /* If on a mode line string with a local keymap,
8498 reconsider the key sequence with that keymap. */
8499 if (CONSP (POSN_STRING (EVENT_START (key
))))
8501 Lisp_Object string
, pos
, map
, map2
;
8503 string
= POSN_STRING (EVENT_START (key
));
8504 pos
= XCDR (string
);
8505 string
= XCAR (string
);
8507 && XINT (pos
) < XSTRING (string
)->size
)
8509 map
= Fget_text_property (pos
, Qlocal_map
, string
);
8511 orig_local_map
= map
;
8512 map2
= Fget_text_property (pos
, Qkeymap
, string
);
8515 if (!NILP (map
) || !NILP (map2
))
8516 goto replay_sequence
;
8522 else if (CONSP (POSN_STRING (EVENT_START (key
)))
8523 && NILP (from_string
))
8525 /* For a click on a string, i.e. overlay string or a
8526 string displayed via the `display' property,
8527 consider `local-map' and `keymap' properties of
8529 Lisp_Object string
, pos
, map
, map2
;
8531 string
= POSN_STRING (EVENT_START (key
));
8532 pos
= XCDR (string
);
8533 string
= XCAR (string
);
8535 && XINT (pos
) < XSTRING (string
)->size
)
8537 map
= Fget_text_property (pos
, Qlocal_map
, string
);
8539 orig_local_map
= map
;
8540 map2
= Fget_text_property (pos
, Qkeymap
, string
);
8544 if (!NILP (map
) || !NILP (map2
))
8546 from_string
= string
;
8547 goto replay_sequence
;
8552 else if (CONSP (XCDR (key
))
8553 && CONSP (EVENT_START (key
))
8554 && CONSP (XCDR (EVENT_START (key
))))
8558 posn
= POSN_BUFFER_POSN (EVENT_START (key
));
8559 /* Handle menu-bar events:
8560 insert the dummy prefix event `menu-bar'. */
8561 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
8563 if (t
+ 1 >= bufsize
)
8564 error ("Key sequence too long");
8568 /* Zap the position in key, so we know that we've
8569 expanded it, and don't try to do so again. */
8570 POSN_BUFFER_SET_POSN (EVENT_START (key
),
8571 Fcons (posn
, Qnil
));
8574 goto replay_sequence
;
8576 else if (CONSP (posn
))
8578 /* We're looking at the second event of a
8579 sequence which we expanded before. Set
8580 last_real_key_start appropriately. */
8581 if (last_real_key_start
== t
&& t
> 0)
8582 last_real_key_start
= t
- 1;
8587 /* We have finally decided that KEY is something we might want
8589 first_binding
= (follow_key (key
,
8590 nmaps
- first_binding
,
8591 submaps
+ first_binding
,
8592 defs
+ first_binding
,
8593 submaps
+ first_binding
)
8596 /* If KEY wasn't bound, we'll try some fallbacks. */
8597 if (first_binding
>= nmaps
)
8601 /* Remember the position to put an upper bound on fkey_start. */
8602 first_unbound
= min (t
, first_unbound
);
8604 head
= EVENT_HEAD (key
);
8605 if (help_char_p (head
) && t
> 0)
8607 read_key_sequence_cmd
= Vprefix_help_command
;
8609 last_nonmenu_event
= key
;
8610 /* The Microsoft C compiler can't handle the goto that
8618 Lisp_Object breakdown
;
8621 breakdown
= parse_modifiers (head
);
8622 modifiers
= XINT (XCAR (XCDR (breakdown
)));
8623 /* Attempt to reduce an unbound mouse event to a simpler
8624 event that is bound:
8625 Drags reduce to clicks.
8626 Double-clicks reduce to clicks.
8627 Triple-clicks reduce to double-clicks, then to clicks.
8628 Down-clicks are eliminated.
8629 Double-downs reduce to downs, then are eliminated.
8630 Triple-downs reduce to double-downs, then to downs,
8631 then are eliminated. */
8632 if (modifiers
& (down_modifier
| drag_modifier
8633 | double_modifier
| triple_modifier
))
8635 while (modifiers
& (down_modifier
| drag_modifier
8636 | double_modifier
| triple_modifier
))
8638 Lisp_Object new_head
, new_click
;
8639 if (modifiers
& triple_modifier
)
8640 modifiers
^= (double_modifier
| triple_modifier
);
8641 else if (modifiers
& double_modifier
)
8642 modifiers
&= ~double_modifier
;
8643 else if (modifiers
& drag_modifier
)
8644 modifiers
&= ~drag_modifier
;
8647 /* Dispose of this `down' event by simply jumping
8648 back to replay_key, to get another event.
8650 Note that if this event came from mock input,
8651 then just jumping back to replay_key will just
8652 hand it to us again. So we have to wipe out any
8655 We could delete keybuf[t] and shift everything
8656 after that to the left by one spot, but we'd also
8657 have to fix up any variable that points into
8658 keybuf, and shifting isn't really necessary
8661 Adding prefixes for non-textual mouse clicks
8662 creates two characters of mock input, and both
8663 must be thrown away. If we're only looking at
8664 the prefix now, we can just jump back to
8665 replay_key. On the other hand, if we've already
8666 processed the prefix, and now the actual click
8667 itself is giving us trouble, then we've lost the
8668 state of the keymaps we want to backtrack to, and
8669 we need to replay the whole sequence to rebuild
8672 Beyond that, only function key expansion could
8673 create more than two keys, but that should never
8674 generate mouse events, so it's okay to zero
8675 mock_input in that case too.
8677 Isn't this just the most wonderful code ever? */
8678 if (t
== last_real_key_start
)
8685 mock_input
= last_real_key_start
;
8686 goto replay_sequence
;
8691 = apply_modifiers (modifiers
, XCAR (breakdown
));
8693 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
8695 /* Look for a binding for this new key. follow_key
8696 promises that it didn't munge submaps the
8697 last time we called it, since key was unbound. */
8699 = (follow_key (new_click
,
8700 nmaps
- local_first_binding
,
8701 submaps
+ local_first_binding
,
8702 defs
+ local_first_binding
,
8703 submaps
+ local_first_binding
)
8704 + local_first_binding
);
8706 /* If that click is bound, go for it. */
8707 if (first_binding
< nmaps
)
8712 /* Otherwise, we'll leave key set to the drag event. */
8719 /* Normally, last_nonmenu_event gets the previous key we read.
8720 But when a mouse popup menu is being used,
8721 we don't update last_nonmenu_event; it continues to hold the mouse
8722 event that preceded the first level of menu. */
8723 if (!used_mouse_menu
)
8724 last_nonmenu_event
= key
;
8726 /* Record what part of this_command_keys is the current key sequence. */
8727 this_single_command_key_start
= this_command_key_count
- t
;
8729 prev_fkey_map
= fkey_map
;
8730 prev_fkey_start
= fkey_start
;
8731 prev_fkey_end
= fkey_end
;
8733 prev_keytran_map
= keytran_map
;
8734 prev_keytran_start
= keytran_start
;
8735 prev_keytran_end
= keytran_end
;
8737 /* If the sequence is unbound, see if we can hang a function key
8738 off the end of it. We only want to scan real keyboard input
8739 for function key sequences, so if mock_input says that we're
8740 re-reading old events, don't examine it. */
8741 if (first_binding
>= nmaps
8744 Lisp_Object fkey_next
;
8746 /* Continue scan from fkey_end until we find a bound suffix.
8747 If we fail, increment fkey_start
8748 and start fkey_end from there. */
8749 while (fkey_end
< t
)
8753 key
= keybuf
[fkey_end
++];
8755 = access_keymap (fkey_map
, key
, 1, 0, 1);
8757 /* Handle symbol with autoload definition. */
8758 if (SYMBOLP (fkey_next
) && ! NILP (Ffboundp (fkey_next
))
8759 && CONSP (XSYMBOL (fkey_next
)->function
)
8760 && EQ (XCAR (XSYMBOL (fkey_next
)->function
), Qautoload
))
8761 do_autoload (XSYMBOL (fkey_next
)->function
,
8764 /* Handle a symbol whose function definition is a keymap
8766 if (SYMBOLP (fkey_next
) && ! NILP (Ffboundp (fkey_next
))
8767 && (!NILP (Farrayp (XSYMBOL (fkey_next
)->function
))
8768 || KEYMAPP (XSYMBOL (fkey_next
)->function
)))
8769 fkey_next
= XSYMBOL (fkey_next
)->function
;
8771 #if 0 /* I didn't turn this on, because it might cause trouble
8772 for the mapping of return into C-m and tab into C-i. */
8773 /* Optionally don't map function keys into other things.
8774 This enables the user to redefine kp- keys easily. */
8775 if (SYMBOLP (key
) && !NILP (Vinhibit_function_key_mapping
))
8779 /* If the function key map gives a function, not an
8780 array, then call the function with no args and use
8781 its value instead. */
8782 if (SYMBOLP (fkey_next
) && ! NILP (Ffboundp (fkey_next
))
8785 struct gcpro gcpro1
, gcpro2
, gcpro3
;
8789 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
8790 fkey_next
= call1 (fkey_next
, prompt
);
8792 /* If the function returned something invalid,
8793 barf--don't ignore it.
8794 (To ignore it safely, we would need to gcpro a bunch of
8795 other variables.) */
8796 if (! (VECTORP (fkey_next
) || STRINGP (fkey_next
)))
8797 error ("Function in key-translation-map returns invalid key sequence");
8800 function_key_possible
= ! NILP (fkey_next
);
8802 /* If keybuf[fkey_start..fkey_end] is bound in the
8803 function key map and it's a suffix of the current
8804 sequence (i.e. fkey_end == t), replace it with
8805 the binding and restart with fkey_start at the end. */
8806 if ((VECTORP (fkey_next
) || STRINGP (fkey_next
))
8809 int len
= XFASTINT (Flength (fkey_next
));
8811 t
= fkey_start
+ len
;
8813 error ("Key sequence too long");
8815 if (VECTORP (fkey_next
))
8816 bcopy (XVECTOR (fkey_next
)->contents
,
8817 keybuf
+ fkey_start
,
8818 (t
- fkey_start
) * sizeof (keybuf
[0]));
8819 else if (STRINGP (fkey_next
))
8823 for (i
= 0; i
< len
; i
++)
8824 XSETFASTINT (keybuf
[fkey_start
+ i
],
8825 XSTRING (fkey_next
)->data
[i
]);
8829 fkey_start
= fkey_end
= t
;
8830 fkey_map
= Vfunction_key_map
;
8832 /* Do pass the results through key-translation-map.
8833 But don't retranslate what key-translation-map
8834 has already translated. */
8835 keytran_end
= keytran_start
;
8836 keytran_map
= Vkey_translation_map
;
8838 goto replay_sequence
;
8841 fkey_map
= get_keymap (fkey_next
, 0, 1);
8843 /* If we no longer have a bound suffix, try a new positions for
8845 if (!CONSP (fkey_map
))
8847 fkey_end
= ++fkey_start
;
8848 fkey_map
= Vfunction_key_map
;
8849 function_key_possible
= 0;
8854 /* Look for this sequence in key-translation-map. */
8856 Lisp_Object keytran_next
;
8858 /* Scan from keytran_end until we find a bound suffix. */
8859 while (keytran_end
< t
)
8863 key
= keybuf
[keytran_end
++];
8865 = access_keymap (keytran_map
, key
, 1, 0, 1);
8867 /* Handle symbol with autoload definition. */
8868 if (SYMBOLP (keytran_next
) && ! NILP (Ffboundp (keytran_next
))
8869 && CONSP (XSYMBOL (keytran_next
)->function
)
8870 && EQ (XCAR (XSYMBOL (keytran_next
)->function
), Qautoload
))
8871 do_autoload (XSYMBOL (keytran_next
)->function
,
8874 /* Handle a symbol whose function definition is a keymap
8876 if (SYMBOLP (keytran_next
) && ! NILP (Ffboundp (keytran_next
))
8877 && (!NILP (Farrayp (XSYMBOL (keytran_next
)->function
))
8878 || KEYMAPP (XSYMBOL (keytran_next
)->function
)))
8879 keytran_next
= XSYMBOL (keytran_next
)->function
;
8881 /* If the key translation map gives a function, not an
8882 array, then call the function with one arg and use
8883 its value instead. */
8884 if (SYMBOLP (keytran_next
) && ! NILP (Ffboundp (keytran_next
))
8885 && keytran_end
== t
)
8887 struct gcpro gcpro1
, gcpro2
, gcpro3
;
8891 GCPRO3 (fkey_map
, keytran_map
, delayed_switch_frame
);
8892 keytran_next
= call1 (keytran_next
, prompt
);
8894 /* If the function returned something invalid,
8895 barf--don't ignore it.
8896 (To ignore it safely, we would need to gcpro a bunch of
8897 other variables.) */
8898 if (! (VECTORP (keytran_next
) || STRINGP (keytran_next
)))
8899 error ("Function in key-translation-map returns invalid key sequence");
8902 key_translation_possible
= ! NILP (keytran_next
);
8904 /* If keybuf[keytran_start..keytran_end] is bound in the
8905 key translation map and it's a suffix of the current
8906 sequence (i.e. keytran_end == t), replace it with
8907 the binding and restart with keytran_start at the end. */
8908 if ((VECTORP (keytran_next
) || STRINGP (keytran_next
))
8909 && keytran_end
== t
)
8911 int len
= XFASTINT (Flength (keytran_next
));
8913 t
= keytran_start
+ len
;
8915 error ("Key sequence too long");
8917 if (VECTORP (keytran_next
))
8918 bcopy (XVECTOR (keytran_next
)->contents
,
8919 keybuf
+ keytran_start
,
8920 (t
- keytran_start
) * sizeof (keybuf
[0]));
8921 else if (STRINGP (keytran_next
))
8925 for (i
= 0; i
< len
; i
++)
8926 XSETFASTINT (keybuf
[keytran_start
+ i
],
8927 XSTRING (keytran_next
)->data
[i
]);
8931 keytran_start
= keytran_end
= t
;
8932 keytran_map
= Vkey_translation_map
;
8934 /* Don't pass the results of key-translation-map
8935 through function-key-map. */
8936 fkey_start
= fkey_end
= t
;
8937 fkey_map
= Vfunction_key_map
;
8939 goto replay_sequence
;
8942 keytran_map
= get_keymap (keytran_next
, 0, 1);
8944 /* If we no longer have a bound suffix, try a new positions for
8946 if (!CONSP (keytran_map
))
8948 keytran_end
= ++keytran_start
;
8949 keytran_map
= Vkey_translation_map
;
8950 key_translation_possible
= 0;
8955 /* If KEY is not defined in any of the keymaps,
8956 and cannot be part of a function key or translation,
8957 and is an upper case letter
8958 use the corresponding lower-case letter instead. */
8959 if (first_binding
== nmaps
&& ! function_key_possible
8960 && ! key_translation_possible
8962 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
8963 && UPPERCASEP (XINT (key
) & ~CHAR_MODIFIER_MASK
))
8964 || (XINT (key
) & shift_modifier
)))
8966 Lisp_Object new_key
;
8968 original_uppercase
= key
;
8969 original_uppercase_position
= t
- 1;
8971 if (XINT (key
) & shift_modifier
)
8972 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
8974 XSETINT (new_key
, (DOWNCASE (XINT (key
) & ~CHAR_MODIFIER_MASK
)
8975 | (XINT (key
) & CHAR_MODIFIER_MASK
)));
8977 /* We have to do this unconditionally, regardless of whether
8978 the lower-case char is defined in the keymaps, because they
8979 might get translated through function-key-map. */
8980 keybuf
[t
- 1] = new_key
;
8983 fkey_map
= prev_fkey_map
;
8984 fkey_start
= prev_fkey_start
;
8985 fkey_end
= prev_fkey_end
;
8987 keytran_map
= prev_keytran_map
;
8988 keytran_start
= prev_keytran_start
;
8989 keytran_end
= prev_keytran_end
;
8991 goto replay_sequence
;
8993 /* If KEY is not defined in any of the keymaps,
8994 and cannot be part of a function key or translation,
8995 and is a shifted function key,
8996 use the corresponding unshifted function key instead. */
8997 if (first_binding
== nmaps
&& ! function_key_possible
8998 && ! key_translation_possible
9001 Lisp_Object breakdown
;
9004 breakdown
= parse_modifiers (key
);
9005 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9006 if (modifiers
& shift_modifier
)
9008 Lisp_Object new_key
;
9010 original_uppercase
= key
;
9011 original_uppercase_position
= t
- 1;
9013 modifiers
&= ~shift_modifier
;
9014 new_key
= apply_modifiers (modifiers
,
9017 keybuf
[t
- 1] = new_key
;
9020 fkey_map
= prev_fkey_map
;
9021 fkey_start
= prev_fkey_start
;
9022 fkey_end
= prev_fkey_end
;
9024 keytran_map
= prev_keytran_map
;
9025 keytran_start
= prev_keytran_start
;
9026 keytran_end
= prev_keytran_end
;
9028 goto replay_sequence
;
9034 read_key_sequence_cmd
= (first_binding
< nmaps
9035 ? defs
[first_binding
]
9038 unread_switch_frame
= delayed_switch_frame
;
9039 unbind_to (count
, Qnil
);
9041 /* Don't downcase the last character if the caller says don't.
9042 Don't downcase it if the result is undefined, either. */
9043 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9044 && t
- 1 == original_uppercase_position
)
9045 keybuf
[t
- 1] = original_uppercase
;
9047 /* Occasionally we fabricate events, perhaps by expanding something
9048 according to function-key-map, or by adding a prefix symbol to a
9049 mouse click in the scroll bar or modeline. In this cases, return
9050 the entire generated key sequence, even if we hit an unbound
9051 prefix or a definition before the end. This means that you will
9052 be able to push back the event properly, and also means that
9053 read-key-sequence will always return a logical unit.
9056 for (; t
< mock_input
; t
++)
9058 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9059 && NILP (Fzerop (Vecho_keystrokes
)))
9060 echo_char (keybuf
[t
]);
9061 add_command_key (keybuf
[t
]);
9070 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9071 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9072 The sequence is sufficient to specify a non-prefix command in the
9073 current local and global maps.
9075 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9076 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9077 as a continuation of the previous key.
9079 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9080 convert the last event to lower case. (Normally any upper case event
9081 is converted to lower case if the original event is undefined and the lower
9082 case equivalent is defined.) A non-nil value is appropriate for reading
9083 a key sequence to be defined.
9085 A C-g typed while in this function is treated like any other character,
9086 and `quit-flag' is not set.
9088 If the key sequence starts with a mouse click, then the sequence is read
9089 using the keymaps of the buffer of the window clicked in, not the buffer
9090 of the selected window as normal.
9092 `read-key-sequence' drops unbound button-down events, since you normally
9093 only care about the click or drag events which follow them. If a drag
9094 or multi-click event is unbound, but the corresponding click event would
9095 be bound, `read-key-sequence' turns the event into a click event at the
9096 drag's starting position. This means that you don't have to distinguish
9097 between click and drag, double, or triple events unless you want to.
9099 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9100 lines separating windows, and scroll bars with imaginary keys
9101 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9103 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9104 function will process a switch-frame event if the user switches frames
9105 before typing anything. If the user switches frames in the middle of a
9106 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9107 is nil, then the event will be put off until after the current key sequence.
9109 `read-key-sequence' checks `function-key-map' for function key
9110 sequences, where they wouldn't conflict with ordinary bindings. See
9111 `function-key-map' for more details.
9113 The optional fifth argument COMMAND-LOOP, if non-nil, means
9114 that this key sequence is being read by something that will
9115 read commands one after another. It should be nil if the caller
9116 will read just one key sequence. */)
9117 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9119 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9120 Lisp_Object can_return_switch_frame
, command_loop
;
9122 Lisp_Object keybuf
[30];
9124 struct gcpro gcpro1
;
9125 int count
= specpdl_ptr
- specpdl
;
9128 CHECK_STRING (prompt
);
9131 specbind (Qinput_method_exit_on_first_char
,
9132 (NILP (command_loop
) ? Qt
: Qnil
));
9133 specbind (Qinput_method_use_echo_area
,
9134 (NILP (command_loop
) ? Qt
: Qnil
));
9136 bzero (keybuf
, sizeof keybuf
);
9138 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9140 if (NILP (continue_echo
))
9142 this_command_key_count
= 0;
9143 this_single_command_key_start
= 0;
9146 #ifdef HAVE_X_WINDOWS
9147 if (display_hourglass_p
)
9148 cancel_hourglass ();
9151 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9152 prompt
, ! NILP (dont_downcase_last
),
9153 ! NILP (can_return_switch_frame
), 0);
9155 #if 0 /* The following is fine for code reading a key sequence and
9156 then proceeding with a lenghty computation, but it's not good
9157 for code reading keys in a loop, like an input method. */
9158 #ifdef HAVE_X_WINDOWS
9159 if (display_hourglass_p
)
9170 return unbind_to (count
, make_event_array (i
, keybuf
));
9173 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
9174 Sread_key_sequence_vector
, 1, 5, 0,
9175 doc
: /* Like `read-key-sequence' but always return a vector. */)
9176 (prompt
, continue_echo
, dont_downcase_last
, can_return_switch_frame
,
9178 Lisp_Object prompt
, continue_echo
, dont_downcase_last
;
9179 Lisp_Object can_return_switch_frame
, command_loop
;
9181 Lisp_Object keybuf
[30];
9183 struct gcpro gcpro1
;
9184 int count
= specpdl_ptr
- specpdl
;
9187 CHECK_STRING (prompt
);
9190 specbind (Qinput_method_exit_on_first_char
,
9191 (NILP (command_loop
) ? Qt
: Qnil
));
9192 specbind (Qinput_method_use_echo_area
,
9193 (NILP (command_loop
) ? Qt
: Qnil
));
9195 bzero (keybuf
, sizeof keybuf
);
9197 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
9199 if (NILP (continue_echo
))
9201 this_command_key_count
= 0;
9202 this_single_command_key_start
= 0;
9205 #ifdef HAVE_X_WINDOWS
9206 if (display_hourglass_p
)
9207 cancel_hourglass ();
9210 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
9211 prompt
, ! NILP (dont_downcase_last
),
9212 ! NILP (can_return_switch_frame
), 0);
9214 #ifdef HAVE_X_WINDOWS
9215 if (display_hourglass_p
)
9225 return unbind_to (count
, Fvector (i
, keybuf
));
9228 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
9229 doc
: /* Execute CMD as an editor command.
9230 CMD must be a symbol that satisfies the `commandp' predicate.
9231 Optional second arg RECORD-FLAG non-nil
9232 means unconditionally put this command in `command-history'.
9233 Otherwise, that is done only if an arg is read using the minibuffer.
9234 The argument KEYS specifies the value to use instead of (this-command-keys)
9235 when reading the arguments; if it is nil, (this-command-keys) is used.
9236 The argument SPECIAL, if non-nil, means that this command is executing
9237 a special event, so ignore the prefix argument and don't clear it. */)
9238 (cmd
, record_flag
, keys
, special
)
9239 Lisp_Object cmd
, record_flag
, keys
, special
;
9241 register Lisp_Object final
;
9242 register Lisp_Object tem
;
9243 Lisp_Object prefixarg
;
9244 struct backtrace backtrace
;
9245 extern int debug_on_next_call
;
9247 debug_on_next_call
= 0;
9251 prefixarg
= current_kboard
->Vprefix_arg
;
9252 Vcurrent_prefix_arg
= prefixarg
;
9253 current_kboard
->Vprefix_arg
= Qnil
;
9260 tem
= Fget (cmd
, Qdisabled
);
9261 if (!NILP (tem
) && !NILP (Vrun_hooks
))
9263 tem
= Fsymbol_value (Qdisabled_command_hook
);
9265 return call1 (Vrun_hooks
, Qdisabled_command_hook
);
9271 final
= Findirect_function (cmd
);
9273 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
9275 struct gcpro gcpro1
, gcpro2
;
9277 GCPRO2 (cmd
, prefixarg
);
9278 do_autoload (final
, cmd
);
9285 if (STRINGP (final
) || VECTORP (final
))
9287 /* If requested, place the macro in the command history. For
9288 other sorts of commands, call-interactively takes care of
9290 if (!NILP (record_flag
))
9293 = Fcons (Fcons (Qexecute_kbd_macro
,
9294 Fcons (final
, Fcons (prefixarg
, Qnil
))),
9297 /* Don't keep command history around forever. */
9298 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
9300 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
9302 XSETCDR (tem
, Qnil
);
9306 return Fexecute_kbd_macro (final
, prefixarg
);
9309 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
9311 backtrace
.next
= backtrace_list
;
9312 backtrace_list
= &backtrace
;
9313 backtrace
.function
= &Qcall_interactively
;
9314 backtrace
.args
= &cmd
;
9315 backtrace
.nargs
= 1;
9316 backtrace
.evalargs
= 0;
9318 tem
= Fcall_interactively (cmd
, record_flag
, keys
);
9320 backtrace_list
= backtrace
.next
;
9328 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
9330 doc
: /* Read function name, then read its arguments and call it. */)
9332 Lisp_Object prefixarg
;
9334 Lisp_Object function
;
9336 Lisp_Object saved_keys
;
9337 Lisp_Object bindings
, value
;
9338 struct gcpro gcpro1
, gcpro2
;
9340 saved_keys
= Fvector (this_command_key_count
,
9341 XVECTOR (this_command_keys
)->contents
);
9343 GCPRO2 (saved_keys
, prefixarg
);
9345 if (EQ (prefixarg
, Qminus
))
9347 else if (CONSP (prefixarg
) && XINT (XCAR (prefixarg
)) == 4)
9348 strcpy (buf
, "C-u ");
9349 else if (CONSP (prefixarg
) && INTEGERP (XCAR (prefixarg
)))
9351 if (sizeof (int) == sizeof (EMACS_INT
))
9352 sprintf (buf
, "%d ", XINT (XCAR (prefixarg
)));
9353 else if (sizeof (long) == sizeof (EMACS_INT
))
9354 sprintf (buf
, "%ld ", (long) XINT (XCAR (prefixarg
)));
9358 else if (INTEGERP (prefixarg
))
9360 if (sizeof (int) == sizeof (EMACS_INT
))
9361 sprintf (buf
, "%d ", XINT (prefixarg
));
9362 else if (sizeof (long) == sizeof (EMACS_INT
))
9363 sprintf (buf
, "%ld ", (long) XINT (prefixarg
));
9368 /* This isn't strictly correct if execute-extended-command
9369 is bound to anything else. Perhaps it should use
9370 this_command_keys? */
9371 strcat (buf
, "M-x ");
9373 /* Prompt with buf, and then read a string, completing from and
9374 restricting to the set of all defined commands. Don't provide
9375 any initial input. Save the command read on the extended-command
9377 function
= Fcompleting_read (build_string (buf
),
9378 Vobarray
, Qcommandp
,
9379 Qt
, Qnil
, Qextended_command_history
, Qnil
,
9382 if (STRINGP (function
) && XSTRING (function
)->size
== 0)
9383 error ("No command name given");
9385 /* Set this_command_keys to the concatenation of saved_keys and
9386 function, followed by a RET. */
9388 struct Lisp_String
*str
;
9392 this_command_key_count
= 0;
9393 this_single_command_key_start
= 0;
9395 keys
= XVECTOR (saved_keys
)->contents
;
9396 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
9397 add_command_key (keys
[i
]);
9399 str
= XSTRING (function
);
9400 for (i
= 0; i
< str
->size
; i
++)
9401 add_command_key (Faref (function
, make_number (i
)));
9403 add_command_key (make_number ('\015'));
9408 function
= Fintern (function
, Qnil
);
9409 current_kboard
->Vprefix_arg
= prefixarg
;
9410 Vthis_command
= function
;
9411 real_this_command
= function
;
9413 /* If enabled, show which key runs this command. */
9414 if (!NILP (Vsuggest_key_bindings
)
9415 && NILP (Vexecuting_macro
)
9416 && SYMBOLP (function
))
9417 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
9423 GCPRO2 (bindings
, value
);
9424 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
9426 /* If the command has a key binding, print it now. */
9427 if (!NILP (bindings
)
9428 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
9431 /* But first wait, and skip the message if there is input. */
9433 if (!NILP (echo_area_buffer
[0]))
9434 /* This command displayed something in the echo area;
9435 so wait a few seconds, then display our suggestion message. */
9436 delay_time
= (NUMBERP (Vsuggest_key_bindings
)
9437 ? XINT (Vsuggest_key_bindings
) : 2);
9439 /* This command left the echo area empty,
9440 so display our message immediately. */
9443 if (!NILP (Fsit_for (make_number (delay_time
), Qnil
, Qnil
))
9444 && ! CONSP (Vunread_command_events
))
9446 Lisp_Object binding
;
9448 int message_p
= push_message ();
9449 int count
= BINDING_STACK_SIZE ();
9451 record_unwind_protect (push_message_unwind
, Qnil
);
9452 binding
= Fkey_description (bindings
);
9455 = (char *) alloca (XSYMBOL (function
)->name
->size
9456 + STRING_BYTES (XSTRING (binding
))
9458 sprintf (newmessage
, "You can run the command `%s' with %s",
9459 XSYMBOL (function
)->name
->data
,
9460 XSTRING (binding
)->data
);
9461 message2_nolog (newmessage
,
9462 strlen (newmessage
),
9463 STRING_MULTIBYTE (binding
));
9464 if (!NILP (Fsit_for ((NUMBERP (Vsuggest_key_bindings
)
9465 ? Vsuggest_key_bindings
: make_number (2)),
9470 unbind_to (count
, Qnil
);
9474 RETURN_UNGCPRO (value
);
9478 /* Return nonzero if input events are pending. */
9481 detect_input_pending ()
9484 get_input_pending (&input_pending
, 0);
9486 return input_pending
;
9489 /* Return nonzero if input events are pending, and run any pending timers. */
9492 detect_input_pending_run_timers (do_display
)
9495 int old_timers_run
= timers_run
;
9498 get_input_pending (&input_pending
, 1);
9500 if (old_timers_run
!= timers_run
&& do_display
)
9502 redisplay_preserve_echo_area (8);
9503 /* The following fixes a bug when using lazy-lock with
9504 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
9505 from an idle timer function. The symptom of the bug is that
9506 the cursor sometimes doesn't become visible until the next X
9507 event is processed. --gerd. */
9509 rif
->flush_display (NULL
);
9512 return input_pending
;
9515 /* This is called in some cases before a possible quit.
9516 It cases the next call to detect_input_pending to recompute input_pending.
9517 So calling this function unnecessarily can't do any harm. */
9520 clear_input_pending ()
9525 /* Return nonzero if there are pending requeued events.
9526 This isn't used yet. The hope is to make wait_reading_process_input
9527 call it, and return return if it runs Lisp code that unreads something.
9528 The problem is, kbd_buffer_get_event needs to be fixed to know what
9529 to do in that case. It isn't trivial. */
9532 requeued_events_pending_p ()
9534 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
9538 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
9539 doc
: /* Return t if command input is currently available with no wait.
9540 Actually, the value is nil only if we can be sure that no input is available;
9541 if there is a doubt, the value is t. */)
9544 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1)
9547 get_input_pending (&input_pending
, 1);
9548 return input_pending
> 0 ? Qt
: Qnil
;
9551 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
9552 doc
: /* Return vector of last 100 events, not counting those from keyboard macros. */)
9555 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
9558 if (total_keys
< NUM_RECENT_KEYS
)
9559 return Fvector (total_keys
, keys
);
9562 val
= Fvector (NUM_RECENT_KEYS
, keys
);
9563 bcopy (keys
+ recent_keys_index
,
9564 XVECTOR (val
)->contents
,
9565 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
9567 XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
9568 recent_keys_index
* sizeof (Lisp_Object
));
9573 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
9574 doc
: /* Return the key sequence that invoked this command.
9575 However, if the command has called `read-key-sequence', it returns
9576 the the last key sequence that has been read.
9577 The value is a string or a vector. */)
9580 return make_event_array (this_command_key_count
,
9581 XVECTOR (this_command_keys
)->contents
);
9584 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
9585 doc
: /* Return the key sequence that invoked this command, as a vector.
9586 However, if the command has called `read-key-sequence', it returns
9587 the the last key sequence that has been read. */)
9590 return Fvector (this_command_key_count
,
9591 XVECTOR (this_command_keys
)->contents
);
9594 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
9595 Sthis_single_command_keys
, 0, 0, 0,
9596 doc
: /* Return the key sequence that invoked this command.
9597 More generally, it returns the last key sequence read, either by
9598 the command loop or by `read-key-sequence'.
9599 Unlike `this-command-keys', this function's value
9600 does not include prefix arguments.
9601 The value is always a vector. */)
9604 return Fvector (this_command_key_count
9605 - this_single_command_key_start
,
9606 (XVECTOR (this_command_keys
)->contents
9607 + this_single_command_key_start
));
9610 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
9611 Sthis_single_command_raw_keys
, 0, 0, 0,
9612 doc
: /* Return the raw events that were read for this command.
9613 More generally, it returns the last key sequence read, either by
9614 the command loop or by `read-key-sequence'.
9615 Unlike `this-single-command-keys', this function's value
9616 shows the events before all translations (except for input methods).
9617 The value is always a vector. */)
9620 return Fvector (raw_keybuf_count
,
9621 (XVECTOR (raw_keybuf
)->contents
));
9624 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
9625 Sreset_this_command_lengths
, 0, 0, 0,
9626 doc
: /* Used for complicated reasons in `universal-argument-other-key'.
9628 `universal-argument-other-key' rereads the event just typed.
9629 It then gets translated through `function-key-map'.
9630 The translated event gets included in the echo area and in
9631 the value of `this-command-keys' in addition to the raw original event.
9634 Calling this function directs the translated event to replace
9635 the original event, so that only one version of the event actually
9636 appears in the echo area and in the value of `this-command-keys'. */)
9639 before_command_restore_flag
= 1;
9640 before_command_key_count_1
= before_command_key_count
;
9641 before_command_echo_length_1
= before_command_echo_length
;
9645 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
9646 Sclear_this_command_keys
, 0, 0, 0,
9647 doc
: /* Clear out the vector that `this-command-keys' returns.
9648 Also clear the record of the last 100 events. */)
9653 this_command_key_count
= 0;
9655 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
9656 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
9658 recent_keys_index
= 0;
9662 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
9663 doc
: /* Return the current depth in recursive edits. */)
9667 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
9671 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
9672 "FOpen dribble file: ",
9673 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
9674 If FILE is nil, close any open dribble file. */)
9685 file
= Fexpand_file_name (file
, Qnil
);
9686 dribble
= fopen (XSTRING (file
)->data
, "w");
9688 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
9693 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
9694 doc
: /* Discard the contents of the terminal input buffer.
9695 Also cancel any kbd macro being defined. */)
9698 current_kboard
->defining_kbd_macro
= Qnil
;
9699 update_mode_lines
++;
9701 Vunread_command_events
= Qnil
;
9702 unread_command_char
= -1;
9704 discard_tty_input ();
9706 kbd_fetch_ptr
= kbd_store_ptr
;
9707 Ffillarray (kbd_buffer_gcpro
, Qnil
);
9713 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
9714 doc
: /* Stop Emacs and return to superior process. You can resume later.
9715 If `cannot-suspend' is non-nil, or if the system doesn't support job
9716 control, run a subshell instead.
9718 If optional arg STUFFSTRING is non-nil, its characters are stuffed
9719 to be read as terminal input by Emacs's parent, after suspension.
9721 Before suspending, run the normal hook `suspend-hook'.
9722 After resumption run the normal hook `suspend-resume-hook'.
9724 Some operating systems cannot stop the Emacs process and resume it later.
9725 On such systems, Emacs starts a subshell instead of suspending. */)
9727 Lisp_Object stuffstring
;
9729 int count
= specpdl_ptr
- specpdl
;
9730 int old_height
, old_width
;
9732 struct gcpro gcpro1
;
9734 if (!NILP (stuffstring
))
9735 CHECK_STRING (stuffstring
);
9737 /* Run the functions in suspend-hook. */
9738 if (!NILP (Vrun_hooks
))
9739 call1 (Vrun_hooks
, intern ("suspend-hook"));
9741 GCPRO1 (stuffstring
);
9742 get_frame_size (&old_width
, &old_height
);
9744 /* sys_suspend can get an error if it tries to fork a subshell
9745 and the system resources aren't available for that. */
9746 record_unwind_protect ((Lisp_Object (*) P_ ((Lisp_Object
))) init_sys_modes
,
9748 stuff_buffered_input (stuffstring
);
9753 unbind_to (count
, Qnil
);
9755 /* Check if terminal/window size has changed.
9756 Note that this is not useful when we are running directly
9757 with a window system; but suspend should be disabled in that case. */
9758 get_frame_size (&width
, &height
);
9759 if (width
!= old_width
|| height
!= old_height
)
9760 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
9762 /* Run suspend-resume-hook. */
9763 if (!NILP (Vrun_hooks
))
9764 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
9770 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
9771 Then in any case stuff anything Emacs has read ahead and not used. */
9774 stuff_buffered_input (stuffstring
)
9775 Lisp_Object stuffstring
;
9777 /* stuff_char works only in BSD, versions 4.2 and up. */
9780 register unsigned char *p
;
9782 if (STRINGP (stuffstring
))
9786 p
= XSTRING (stuffstring
)->data
;
9787 count
= STRING_BYTES (XSTRING (stuffstring
));
9793 /* Anything we have read ahead, put back for the shell to read. */
9794 /* ?? What should this do when we have multiple keyboards??
9795 Should we ignore anything that was typed in at the "wrong" kboard? */
9796 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
9800 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
9801 kbd_fetch_ptr
= kbd_buffer
;
9802 if (kbd_fetch_ptr
->kind
== ascii_keystroke
)
9803 stuff_char (kbd_fetch_ptr
->code
);
9805 kbd_fetch_ptr
->kind
= no_event
;
9806 idx
= 2 * (kbd_fetch_ptr
- kbd_buffer
);
9807 ASET (kbd_buffer_gcpro
, idx
, Qnil
);
9808 ASET (kbd_buffer_gcpro
, idx
+ 1, Qnil
);
9813 #endif /* BSD_SYSTEM and not BSD4_1 */
9817 set_waiting_for_input (time_to_clear
)
9818 EMACS_TIME
*time_to_clear
;
9820 input_available_clear_time
= time_to_clear
;
9822 /* Tell interrupt_signal to throw back to read_char, */
9823 waiting_for_input
= 1;
9825 /* If interrupt_signal was called before and buffered a C-g,
9826 make it run again now, to avoid timing error. */
9827 if (!NILP (Vquit_flag
))
9828 quit_throw_to_read_char ();
9832 clear_waiting_for_input ()
9834 /* Tell interrupt_signal not to throw back to read_char, */
9835 waiting_for_input
= 0;
9836 input_available_clear_time
= 0;
9839 /* This routine is called at interrupt level in response to C-G.
9841 If interrupt_input, this is the handler for SIGINT. Otherwise, it
9842 is called from kbd_buffer_store_event, in handling SIGIO or
9845 If `waiting_for_input' is non zero, then unless `echoing' is
9846 nonzero, immediately throw back to read_char.
9848 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
9849 eval to throw, when it gets a chance. If quit-flag is already
9850 non-nil, it stops the job right away. */
9853 interrupt_signal (signalnum
) /* If we don't have an argument, */
9854 int signalnum
; /* some compilers complain in signal calls. */
9857 /* Must preserve main program's value of errno. */
9858 int old_errno
= errno
;
9859 struct frame
*sf
= SELECTED_FRAME ();
9861 #if defined (USG) && !defined (POSIX_SIGNALS)
9862 if (!read_socket_hook
&& NILP (Vwindow_system
))
9864 /* USG systems forget handlers when they are used;
9865 must reestablish each time */
9866 signal (SIGINT
, interrupt_signal
);
9867 signal (SIGQUIT
, interrupt_signal
);
9873 if (!NILP (Vquit_flag
)
9874 && (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
)))
9876 /* If SIGINT isn't blocked, don't let us be interrupted by
9877 another SIGINT, it might be harmful due to non-reentrancy
9878 in I/O functions. */
9879 sigblock (sigmask (SIGINT
));
9884 #ifdef SIGTSTP /* Support possible in later USG versions */
9886 * On systems which can suspend the current process and return to the original
9887 * shell, this command causes the user to end up back at the shell.
9888 * The "Auto-save" and "Abort" questions are not asked until
9889 * the user elects to return to emacs, at which point he can save the current
9890 * job and either dump core or continue.
9895 if (sys_suspend () == -1)
9897 printf ("Not running as a subprocess;\n");
9898 printf ("you can continue or abort.\n");
9901 /* Perhaps should really fork an inferior shell?
9902 But that would not provide any way to get back
9903 to the original shell, ever. */
9904 printf ("No support for stopping a process on this operating system;\n");
9905 printf ("you can continue or abort.\n");
9906 #endif /* not VMS */
9907 #endif /* not SIGTSTP */
9909 /* We must remain inside the screen area when the internal terminal
9910 is used. Note that [Enter] is not echoed by dos. */
9913 /* It doesn't work to autosave while GC is in progress;
9914 the code used for auto-saving doesn't cope with the mark bit. */
9915 if (!gc_in_progress
)
9917 printf ("Auto-save? (y or n) ");
9919 if (((c
= getchar ()) & ~040) == 'Y')
9921 Fdo_auto_save (Qt
, Qnil
);
9923 printf ("\r\nAuto-save done");
9924 #else /* not MSDOS */
9925 printf ("Auto-save done\n");
9926 #endif /* not MSDOS */
9928 while (c
!= '\n') c
= getchar ();
9932 /* During GC, it must be safe to reenable quitting again. */
9933 Vinhibit_quit
= Qnil
;
9936 #endif /* not MSDOS */
9937 printf ("Garbage collection in progress; cannot auto-save now\r\n");
9938 printf ("but will instead do a real quit after garbage collection ends\r\n");
9943 printf ("\r\nAbort? (y or n) ");
9944 #else /* not MSDOS */
9946 printf ("Abort (and enter debugger)? (y or n) ");
9948 printf ("Abort (and dump core)? (y or n) ");
9949 #endif /* not VMS */
9950 #endif /* not MSDOS */
9952 if (((c
= getchar ()) & ~040) == 'Y')
9954 while (c
!= '\n') c
= getchar ();
9956 printf ("\r\nContinuing...\r\n");
9957 #else /* not MSDOS */
9958 printf ("Continuing...\n");
9959 #endif /* not MSDOS */
9966 /* If executing a function that wants to be interrupted out of
9967 and the user has not deferred quitting by binding `inhibit-quit'
9968 then quit right away. */
9969 if (immediate_quit
&& NILP (Vinhibit_quit
))
9971 struct gl_state_s saved
;
9972 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9977 GCPRO4 (saved
.object
, saved
.global_code
,
9978 saved
.current_syntax_table
, saved
.old_prop
);
9979 Fsignal (Qquit
, Qnil
);
9984 /* Else request quit when it's safe */
9988 if (waiting_for_input
&& !echoing
)
9989 quit_throw_to_read_char ();
9994 /* Handle a C-g by making read_char return C-g. */
9997 quit_throw_to_read_char ()
10000 /* Prevent another signal from doing this before we finish. */
10001 clear_waiting_for_input ();
10004 Vunread_command_events
= Qnil
;
10005 unread_command_char
= -1;
10007 #if 0 /* Currently, sit_for is called from read_char without turning
10008 off polling. And that can call set_waiting_for_input.
10009 It seems to be harmless. */
10010 #ifdef POLL_FOR_INPUT
10011 /* May be > 1 if in recursive minibuffer. */
10012 if (poll_suppress_count
== 0)
10016 if (FRAMEP (internal_last_event_frame
)
10017 && !EQ (internal_last_event_frame
, selected_frame
))
10018 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10021 _longjmp (getcjmp
, 1);
10024 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
10025 doc
: /* Set mode of reading keyboard input.
10026 First arg INTERRUPT non-nil means use input interrupts;
10027 nil means use CBREAK mode.
10028 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
10029 (no effect except in CBREAK mode).
10030 Third arg META t means accept 8-bit input (for a Meta key).
10031 META nil means ignore the top bit, on the assumption it is parity.
10032 Otherwise, accept 8-bit input and don't use the top bit for Meta.
10033 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
10034 See also `current-input-mode'. */)
10035 (interrupt
, flow
, meta
, quit
)
10036 Lisp_Object interrupt
, flow
, meta
, quit
;
10039 && (!INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400))
10040 error ("set-input-mode: QUIT must be an ASCII character");
10042 #ifdef POLL_FOR_INPUT
10047 /* this causes startup screen to be restored and messes with the mouse */
10048 reset_sys_modes ();
10052 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10053 if (read_socket_hook
)
10055 /* When using X, don't give the user a real choice,
10056 because we haven't implemented the mechanisms to support it. */
10057 #ifdef NO_SOCK_SIGIO
10058 interrupt_input
= 0;
10059 #else /* not NO_SOCK_SIGIO */
10060 interrupt_input
= 1;
10061 #endif /* NO_SOCK_SIGIO */
10064 interrupt_input
= !NILP (interrupt
);
10065 #else /* not SIGIO */
10066 interrupt_input
= 0;
10067 #endif /* not SIGIO */
10069 /* Our VMS input only works by interrupts, as of now. */
10071 interrupt_input
= 1;
10074 flow_control
= !NILP (flow
);
10077 else if (EQ (meta
, Qt
))
10082 /* Don't let this value be out of range. */
10083 quit_char
= XINT (quit
) & (meta_key
? 0377 : 0177);
10089 #ifdef POLL_FOR_INPUT
10090 poll_suppress_count
= 1;
10096 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
10097 doc
: /* Return information about the way Emacs currently reads keyboard input.
10098 The value is a list of the form (INTERRUPT FLOW META QUIT), where
10099 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
10100 nil, Emacs is using CBREAK mode.
10101 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
10102 terminal; this does not apply if Emacs uses interrupt-driven input.
10103 META is t if accepting 8-bit input with 8th bit as Meta flag.
10104 META nil means ignoring the top bit, on the assumption it is parity.
10105 META is neither t nor nil if accepting 8-bit input and using
10106 all 8 bits as the character code.
10107 QUIT is the character Emacs currently uses to quit.
10108 The elements of this list correspond to the arguments of
10109 `set-input-mode'. */)
10112 Lisp_Object val
[4];
10114 val
[0] = interrupt_input
? Qt
: Qnil
;
10115 val
[1] = flow_control
? Qt
: Qnil
;
10116 val
[2] = meta_key
== 2 ? make_number (0) : meta_key
== 1 ? Qt
: Qnil
;
10117 XSETFASTINT (val
[3], quit_char
);
10119 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
10124 * Set up a new kboard object with reasonable initial values.
10130 kb
->Voverriding_terminal_local_map
= Qnil
;
10131 kb
->Vlast_command
= Qnil
;
10132 kb
->Vreal_last_command
= Qnil
;
10133 kb
->Vprefix_arg
= Qnil
;
10134 kb
->Vlast_prefix_arg
= Qnil
;
10135 kb
->kbd_queue
= Qnil
;
10136 kb
->kbd_queue_has_data
= 0;
10137 kb
->immediate_echo
= 0;
10138 kb
->echoptr
= kb
->echobuf
;
10139 kb
->echo_after_prompt
= -1;
10140 kb
->kbd_macro_buffer
= 0;
10141 kb
->kbd_macro_bufsize
= 0;
10142 kb
->defining_kbd_macro
= Qnil
;
10143 kb
->Vlast_kbd_macro
= Qnil
;
10144 kb
->reference_count
= 0;
10145 kb
->Vsystem_key_alist
= Qnil
;
10146 kb
->system_key_syms
= Qnil
;
10147 kb
->Vdefault_minibuffer_frame
= Qnil
;
10151 * Destroy the contents of a kboard object, but not the object itself.
10152 * We use this just before deleting it, or if we're going to initialize
10153 * it a second time.
10159 if (kb
->kbd_macro_buffer
)
10160 xfree (kb
->kbd_macro_buffer
);
10163 #ifdef MULTI_KBOARD
10165 /* Free KB and memory referenced from it. */
10173 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
10176 *kbp
= kb
->next_kboard
;
10178 /* Prevent a dangling reference to KB. */
10179 if (kb
== current_kboard
10180 && FRAMEP (selected_frame
)
10181 && FRAME_LIVE_P (XFRAME (selected_frame
)))
10183 current_kboard
= XFRAME (selected_frame
)->kboard
;
10184 if (current_kboard
== kb
)
10192 #endif /* MULTI_KBOARD */
10197 /* This is correct before outermost invocation of the editor loop */
10198 command_loop_level
= -1;
10199 immediate_quit
= 0;
10200 quit_char
= Ctl ('g');
10201 Vunread_command_events
= Qnil
;
10202 unread_command_char
= -1;
10203 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
10205 recent_keys_index
= 0;
10206 kbd_fetch_ptr
= kbd_buffer
;
10207 kbd_store_ptr
= kbd_buffer
;
10208 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10210 do_mouse_tracking
= Qnil
;
10214 /* This means that command_loop_1 won't try to select anything the first
10216 internal_last_event_frame
= Qnil
;
10217 Vlast_event_frame
= internal_last_event_frame
;
10219 #ifdef MULTI_KBOARD
10220 current_kboard
= initial_kboard
;
10222 wipe_kboard (current_kboard
);
10223 init_kboard (current_kboard
);
10225 if (!noninteractive
&& !read_socket_hook
&& NILP (Vwindow_system
))
10227 signal (SIGINT
, interrupt_signal
);
10228 #if defined (HAVE_TERMIO) || defined (HAVE_TERMIOS)
10229 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
10230 SIGQUIT and we can't tell which one it will give us. */
10231 signal (SIGQUIT
, interrupt_signal
);
10232 #endif /* HAVE_TERMIO */
10234 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10236 if (!noninteractive
)
10237 signal (SIGIO
, input_available_signal
);
10240 /* Use interrupt input by default, if it works and noninterrupt input
10241 has deficiencies. */
10243 #ifdef INTERRUPT_INPUT
10244 interrupt_input
= 1;
10246 interrupt_input
= 0;
10249 /* Our VMS input only works by interrupts, as of now. */
10251 interrupt_input
= 1;
10257 if (keyboard_init_hook
)
10258 (*keyboard_init_hook
) ();
10260 #ifdef POLL_FOR_INPUT
10261 poll_suppress_count
= 1;
10266 /* This type's only use is in syms_of_keyboard, to initialize the
10267 event header symbols and put properties on them. */
10268 struct event_head
{
10274 struct event_head head_table
[] = {
10275 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
10276 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
10277 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
10278 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
10279 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
10280 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
}
10284 syms_of_keyboard ()
10286 Vpre_help_message
= Qnil
;
10287 staticpro (&Vpre_help_message
);
10289 Vlispy_mouse_stem
= build_string ("mouse");
10290 staticpro (&Vlispy_mouse_stem
);
10293 QCimage
= intern (":image");
10294 staticpro (&QCimage
);
10296 staticpro (&Qhelp_echo
);
10297 Qhelp_echo
= intern ("help-echo");
10299 staticpro (&item_properties
);
10300 item_properties
= Qnil
;
10302 staticpro (&tool_bar_item_properties
);
10303 tool_bar_item_properties
= Qnil
;
10304 staticpro (&tool_bar_items_vector
);
10305 tool_bar_items_vector
= Qnil
;
10307 staticpro (&real_this_command
);
10308 real_this_command
= Qnil
;
10310 Qtimer_event_handler
= intern ("timer-event-handler");
10311 staticpro (&Qtimer_event_handler
);
10313 Qdisabled_command_hook
= intern ("disabled-command-hook");
10314 staticpro (&Qdisabled_command_hook
);
10316 Qself_insert_command
= intern ("self-insert-command");
10317 staticpro (&Qself_insert_command
);
10319 Qforward_char
= intern ("forward-char");
10320 staticpro (&Qforward_char
);
10322 Qbackward_char
= intern ("backward-char");
10323 staticpro (&Qbackward_char
);
10325 Qdisabled
= intern ("disabled");
10326 staticpro (&Qdisabled
);
10328 Qundefined
= intern ("undefined");
10329 staticpro (&Qundefined
);
10331 Qpre_command_hook
= intern ("pre-command-hook");
10332 staticpro (&Qpre_command_hook
);
10334 Qpost_command_hook
= intern ("post-command-hook");
10335 staticpro (&Qpost_command_hook
);
10337 Qpost_command_idle_hook
= intern ("post-command-idle-hook");
10338 staticpro (&Qpost_command_idle_hook
);
10340 Qdeferred_action_function
= intern ("deferred-action-function");
10341 staticpro (&Qdeferred_action_function
);
10343 Qcommand_hook_internal
= intern ("command-hook-internal");
10344 staticpro (&Qcommand_hook_internal
);
10346 Qfunction_key
= intern ("function-key");
10347 staticpro (&Qfunction_key
);
10348 Qmouse_click
= intern ("mouse-click");
10349 staticpro (&Qmouse_click
);
10351 Qmouse_wheel
= intern ("mouse-wheel");
10352 staticpro (&Qmouse_wheel
);
10353 Qlanguage_change
= intern ("language-change");
10354 staticpro (&Qlanguage_change
);
10356 Qdrag_n_drop
= intern ("drag-n-drop");
10357 staticpro (&Qdrag_n_drop
);
10359 Qusr1_signal
= intern ("usr1-signal");
10360 staticpro (&Qusr1_signal
);
10361 Qusr2_signal
= intern ("usr2-signal");
10362 staticpro (&Qusr2_signal
);
10364 Qmenu_enable
= intern ("menu-enable");
10365 staticpro (&Qmenu_enable
);
10366 Qmenu_alias
= intern ("menu-alias");
10367 staticpro (&Qmenu_alias
);
10368 QCenable
= intern (":enable");
10369 staticpro (&QCenable
);
10370 QCvisible
= intern (":visible");
10371 staticpro (&QCvisible
);
10372 QChelp
= intern (":help");
10373 staticpro (&QChelp
);
10374 QCfilter
= intern (":filter");
10375 staticpro (&QCfilter
);
10376 QCbutton
= intern (":button");
10377 staticpro (&QCbutton
);
10378 QCkeys
= intern (":keys");
10379 staticpro (&QCkeys
);
10380 QCkey_sequence
= intern (":key-sequence");
10381 staticpro (&QCkey_sequence
);
10382 QCtoggle
= intern (":toggle");
10383 staticpro (&QCtoggle
);
10384 QCradio
= intern (":radio");
10385 staticpro (&QCradio
);
10387 Qmode_line
= intern ("mode-line");
10388 staticpro (&Qmode_line
);
10389 Qvertical_line
= intern ("vertical-line");
10390 staticpro (&Qvertical_line
);
10391 Qvertical_scroll_bar
= intern ("vertical-scroll-bar");
10392 staticpro (&Qvertical_scroll_bar
);
10393 Qmenu_bar
= intern ("menu-bar");
10394 staticpro (&Qmenu_bar
);
10396 Qabove_handle
= intern ("above-handle");
10397 staticpro (&Qabove_handle
);
10398 Qhandle
= intern ("handle");
10399 staticpro (&Qhandle
);
10400 Qbelow_handle
= intern ("below-handle");
10401 staticpro (&Qbelow_handle
);
10402 Qup
= intern ("up");
10404 Qdown
= intern ("down");
10405 staticpro (&Qdown
);
10406 Qtop
= intern ("top");
10408 Qbottom
= intern ("bottom");
10409 staticpro (&Qbottom
);
10410 Qend_scroll
= intern ("end-scroll");
10411 staticpro (&Qend_scroll
);
10412 Qratio
= intern ("ratio");
10413 staticpro (&Qratio
);
10415 Qevent_kind
= intern ("event-kind");
10416 staticpro (&Qevent_kind
);
10417 Qevent_symbol_elements
= intern ("event-symbol-elements");
10418 staticpro (&Qevent_symbol_elements
);
10419 Qevent_symbol_element_mask
= intern ("event-symbol-element-mask");
10420 staticpro (&Qevent_symbol_element_mask
);
10421 Qmodifier_cache
= intern ("modifier-cache");
10422 staticpro (&Qmodifier_cache
);
10424 Qrecompute_lucid_menubar
= intern ("recompute-lucid-menubar");
10425 staticpro (&Qrecompute_lucid_menubar
);
10426 Qactivate_menubar_hook
= intern ("activate-menubar-hook");
10427 staticpro (&Qactivate_menubar_hook
);
10429 Qpolling_period
= intern ("polling-period");
10430 staticpro (&Qpolling_period
);
10432 Qinput_method_function
= intern ("input-method-function");
10433 staticpro (&Qinput_method_function
);
10435 Qinput_method_exit_on_first_char
= intern ("input-method-exit-on-first-char");
10436 staticpro (&Qinput_method_exit_on_first_char
);
10437 Qinput_method_use_echo_area
= intern ("input-method-use-echo-area");
10438 staticpro (&Qinput_method_use_echo_area
);
10440 Fset (Qinput_method_exit_on_first_char
, Qnil
);
10441 Fset (Qinput_method_use_echo_area
, Qnil
);
10443 last_point_position_buffer
= Qnil
;
10446 struct event_head
*p
;
10448 for (p
= head_table
;
10449 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
10452 *p
->var
= intern (p
->name
);
10453 staticpro (p
->var
);
10454 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
10455 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
10459 button_down_location
= Fmake_vector (make_number (1), Qnil
);
10460 staticpro (&button_down_location
);
10461 mouse_syms
= Fmake_vector (make_number (1), Qnil
);
10462 staticpro (&mouse_syms
);
10466 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
10468 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
10469 for (i
= 0; i
< len
; i
++)
10470 if (modifier_names
[i
])
10471 XVECTOR (modifier_symbols
)->contents
[i
] = intern (modifier_names
[i
]);
10472 staticpro (&modifier_symbols
);
10475 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
10476 staticpro (&recent_keys
);
10478 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
10479 staticpro (&this_command_keys
);
10481 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
10482 staticpro (&raw_keybuf
);
10484 Qextended_command_history
= intern ("extended-command-history");
10485 Fset (Qextended_command_history
, Qnil
);
10486 staticpro (&Qextended_command_history
);
10488 kbd_buffer_gcpro
= Fmake_vector (make_number (2 * KBD_BUFFER_SIZE
), Qnil
);
10489 staticpro (&kbd_buffer_gcpro
);
10491 accent_key_syms
= Qnil
;
10492 staticpro (&accent_key_syms
);
10494 func_key_syms
= Qnil
;
10495 staticpro (&func_key_syms
);
10498 mouse_wheel_syms
= Qnil
;
10499 staticpro (&mouse_wheel_syms
);
10501 drag_n_drop_syms
= Qnil
;
10502 staticpro (&drag_n_drop_syms
);
10505 unread_switch_frame
= Qnil
;
10506 staticpro (&unread_switch_frame
);
10508 internal_last_event_frame
= Qnil
;
10509 staticpro (&internal_last_event_frame
);
10511 read_key_sequence_cmd
= Qnil
;
10512 staticpro (&read_key_sequence_cmd
);
10514 menu_bar_one_keymap_changed_items
= Qnil
;
10515 staticpro (&menu_bar_one_keymap_changed_items
);
10517 defsubr (&Sevent_convert_list
);
10518 defsubr (&Sread_key_sequence
);
10519 defsubr (&Sread_key_sequence_vector
);
10520 defsubr (&Srecursive_edit
);
10522 defsubr (&Strack_mouse
);
10524 defsubr (&Sinput_pending_p
);
10525 defsubr (&Scommand_execute
);
10526 defsubr (&Srecent_keys
);
10527 defsubr (&Sthis_command_keys
);
10528 defsubr (&Sthis_command_keys_vector
);
10529 defsubr (&Sthis_single_command_keys
);
10530 defsubr (&Sthis_single_command_raw_keys
);
10531 defsubr (&Sreset_this_command_lengths
);
10532 defsubr (&Sclear_this_command_keys
);
10533 defsubr (&Ssuspend_emacs
);
10534 defsubr (&Sabort_recursive_edit
);
10535 defsubr (&Sexit_recursive_edit
);
10536 defsubr (&Srecursion_depth
);
10537 defsubr (&Stop_level
);
10538 defsubr (&Sdiscard_input
);
10539 defsubr (&Sopen_dribble_file
);
10540 defsubr (&Sset_input_mode
);
10541 defsubr (&Scurrent_input_mode
);
10542 defsubr (&Sexecute_extended_command
);
10544 DEFVAR_LISP ("last-command-char", &last_command_char
,
10545 doc
: /* Last input event that was part of a command. */);
10547 DEFVAR_LISP_NOPRO ("last-command-event", &last_command_char
,
10548 doc
: /* Last input event that was part of a command. */);
10550 DEFVAR_LISP ("last-nonmenu-event", &last_nonmenu_event
,
10551 doc
: /* Last input event in a command, except for mouse menu events.
10552 Mouse menus give back keys that don't look like mouse events;
10553 this variable holds the actual mouse event that led to the menu,
10554 so that you can determine whether the command was run by mouse or not. */);
10556 DEFVAR_LISP ("last-input-char", &last_input_char
,
10557 doc
: /* Last input event. */);
10559 DEFVAR_LISP_NOPRO ("last-input-event", &last_input_char
,
10560 doc
: /* Last input event. */);
10562 DEFVAR_LISP ("unread-command-events", &Vunread_command_events
,
10563 doc
: /* List of events to be read as the command input.
10564 These events are processed first, before actual keyboard input. */);
10565 Vunread_command_events
= Qnil
;
10567 DEFVAR_INT ("unread-command-char", &unread_command_char
,
10568 doc
: /* If not -1, an object to be read as next command input event. */);
10570 DEFVAR_LISP ("unread-post-input-method-events", &Vunread_post_input_method_events
,
10571 doc
: /* List of events to be processed as input by input methods.
10572 These events are processed after `unread-command-events', but
10573 before actual keyboard input. */);
10574 Vunread_post_input_method_events
= Qnil
;
10576 DEFVAR_LISP ("unread-input-method-events", &Vunread_input_method_events
,
10577 doc
: /* List of events to be processed as input by input methods.
10578 These events are processed after `unread-command-events', but
10579 before actual keyboard input. */);
10580 Vunread_input_method_events
= Qnil
;
10582 DEFVAR_LISP ("meta-prefix-char", &meta_prefix_char
,
10583 doc
: /* Meta-prefix character code.
10584 Meta-foo as command input turns into this character followed by foo. */);
10585 XSETINT (meta_prefix_char
, 033);
10587 DEFVAR_KBOARD ("last-command", Vlast_command
,
10588 doc
: /* The last command executed.
10589 Normally a symbol with a function definition, but can be whatever was found
10590 in the keymap, or whatever the variable `this-command' was set to by that
10593 The value `mode-exit' is special; it means that the previous command
10594 read an event that told it to exit, and it did so and unread that event.
10595 In other words, the present command is the event that made the previous
10598 The value `kill-region' is special; it means that the previous command
10599 was a kill command. */);
10601 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
10602 doc
: /* Same as `last-command', but never altered by Lisp code. */);
10604 DEFVAR_LISP ("this-command", &Vthis_command
,
10605 doc
: /* The command now being executed.
10606 The command can set this variable; whatever is put here
10607 will be in `last-command' during the following command. */);
10608 Vthis_command
= Qnil
;
10610 DEFVAR_LISP ("this-original-command", &Vthis_original_command
,
10611 doc
: /* If non-nil, the original command bound to the current key sequence.
10612 The value of `this-command' is the result of looking up the original
10613 command in the active keymaps. */);
10614 Vthis_original_command
= Qnil
;
10616 DEFVAR_INT ("auto-save-interval", &auto_save_interval
,
10617 doc
: /* *Number of input events between auto-saves.
10618 Zero means disable autosaving due to number of characters typed. */);
10619 auto_save_interval
= 300;
10621 DEFVAR_LISP ("auto-save-timeout", &Vauto_save_timeout
,
10622 doc
: /* *Number of seconds idle time before auto-save.
10623 Zero or nil means disable auto-saving due to idleness.
10624 After auto-saving due to this many seconds of idle time,
10625 Emacs also does a garbage collection if that seems to be warranted. */);
10626 XSETFASTINT (Vauto_save_timeout
, 30);
10628 DEFVAR_LISP ("echo-keystrokes", &Vecho_keystrokes
,
10629 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
10630 The value may be integer or floating point. */);
10631 Vecho_keystrokes
= make_number (1);
10633 DEFVAR_INT ("polling-period", &polling_period
,
10634 doc
: /* *Interval between polling for input during Lisp execution.
10635 The reason for polling is to make C-g work to stop a running program.
10636 Polling is needed only when using X windows and SIGIO does not work.
10637 Polling is automatically disabled in all other cases. */);
10638 polling_period
= 2;
10640 DEFVAR_LISP ("double-click-time", &Vdouble_click_time
,
10641 doc
: /* *Maximum time between mouse clicks to make a double-click.
10642 Measured in milliseconds. nil means disable double-click recognition;
10643 t means double-clicks have no time limit and are detected
10644 by position only. */);
10645 Vdouble_click_time
= make_number (500);
10647 DEFVAR_INT ("double-click-fuzz", &double_click_fuzz
,
10648 doc
: /* *Maximum mouse movement between clicks to make a double-click.
10649 On window-system frames, value is the number of pixels the mouse may have
10650 moved horizontally or vertically between two clicks to make a double-click.
10651 On non window-system frames, value is interpreted in units of 1/8 characters
10654 This variable is also the threshold for motion of the mouse
10655 to count as a drag. */);
10656 double_click_fuzz
= 3;
10658 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", &inhibit_local_menu_bar_menus
,
10659 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
10660 inhibit_local_menu_bar_menus
= 0;
10662 DEFVAR_INT ("num-input-keys", &num_input_keys
,
10663 doc
: /* Number of complete key sequences read as input so far.
10664 This includes key sequences read from keyboard macros.
10665 The number is effectively the number of interactive command invocations. */);
10666 num_input_keys
= 0;
10668 DEFVAR_INT ("num-nonmacro-input-events", &num_nonmacro_input_events
,
10669 doc
: /* Number of input events read from the keyboard so far.
10670 This does not include events generated by keyboard macros. */);
10671 num_nonmacro_input_events
= 0;
10673 DEFVAR_LISP ("last-event-frame", &Vlast_event_frame
,
10674 doc
: /* The frame in which the most recently read event occurred.
10675 If the last event came from a keyboard macro, this is set to `macro'. */);
10676 Vlast_event_frame
= Qnil
;
10678 /* This variable is set up in sysdep.c. */
10679 DEFVAR_LISP ("tty-erase-char", &Vtty_erase_char
,
10680 doc
: /* The ERASE character as set by the user with stty. */);
10682 DEFVAR_LISP ("help-char", &Vhelp_char
,
10683 doc
: /* Character to recognize as meaning Help.
10684 When it is read, do `(eval help-form)', and display result if it's a string.
10685 If the value of `help-form' is nil, this char can be read normally. */);
10686 XSETINT (Vhelp_char
, Ctl ('H'));
10688 DEFVAR_LISP ("help-event-list", &Vhelp_event_list
,
10689 doc
: /* List of input events to recognize as meaning Help.
10690 These work just like the value of `help-char' (see that). */);
10691 Vhelp_event_list
= Qnil
;
10693 DEFVAR_LISP ("help-form", &Vhelp_form
,
10694 doc
: /* Form to execute when character `help-char' is read.
10695 If the form returns a string, that string is displayed.
10696 If `help-form' is nil, the help char is not recognized. */);
10699 DEFVAR_LISP ("prefix-help-command", &Vprefix_help_command
,
10700 doc
: /* Command to run when `help-char' character follows a prefix key.
10701 This command is used only when there is no actual binding
10702 for that character after that prefix key. */);
10703 Vprefix_help_command
= Qnil
;
10705 DEFVAR_LISP ("top-level", &Vtop_level
,
10706 doc
: /* Form to evaluate when Emacs starts up.
10707 Useful to set before you dump a modified Emacs. */);
10710 DEFVAR_LISP ("keyboard-translate-table", &Vkeyboard_translate_table
,
10711 doc
: /* Translate table for keyboard input, or nil.
10712 Each character is looked up in this string and the contents used instead.
10713 The value may be a string, a vector, or a char-table.
10714 If it is a string or vector of length N,
10715 character codes N and up are untranslated.
10716 In a vector or a char-table, an element which is nil means "no translation". */);
10717 Vkeyboard_translate_table
= Qnil
;
10719 DEFVAR_BOOL ("cannot-suspend", &cannot_suspend
,
10720 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
10721 \(Even if the operating system has support for stopping a process.\) */);
10722 cannot_suspend
= 0;
10724 DEFVAR_BOOL ("menu-prompting", &menu_prompting
,
10725 doc
: /* Non-nil means prompt with menus when appropriate.
10726 This is done when reading from a keymap that has a prompt string,
10727 for elements that have prompt strings.
10728 The menu is displayed on the screen
10729 if X menus were enabled at configuration
10730 time and the previous event was a mouse click prefix key.
10731 Otherwise, menu prompting uses the echo area. */);
10732 menu_prompting
= 1;
10734 DEFVAR_LISP ("menu-prompt-more-char", &menu_prompt_more_char
,
10735 doc
: /* Character to see next line of menu prompt.
10736 Type this character while in a menu prompt to rotate around the lines of it. */);
10737 XSETINT (menu_prompt_more_char
, ' ');
10739 DEFVAR_INT ("extra-keyboard-modifiers", &extra_keyboard_modifiers
,
10740 doc
: /* A mask of additional modifier keys to use with every keyboard character.
10741 Emacs applies the modifiers of the character stored here to each keyboard
10742 character it reads. For example, after evaluating the expression
10743 (setq extra-keyboard-modifiers ?\\C-x)
10744 all input characters will have the control modifier applied to them.
10746 Note that the character ?\\C-@, equivalent to the integer zero, does
10747 not count as a control character; rather, it counts as a character
10748 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
10749 cancels any modification. */);
10750 extra_keyboard_modifiers
= 0;
10752 DEFVAR_LISP ("deactivate-mark", &Vdeactivate_mark
,
10753 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
10754 The command loop sets this to nil before each command,
10755 and tests the value when the command returns.
10756 Buffer modification stores t in this variable. */);
10757 Vdeactivate_mark
= Qnil
;
10759 DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal
,
10760 doc
: /* Temporary storage of pre-command-hook or post-command-hook. */);
10761 Vcommand_hook_internal
= Qnil
;
10763 DEFVAR_LISP ("pre-command-hook", &Vpre_command_hook
,
10764 doc
: /* Normal hook run before each command is executed.
10765 If an unhandled error happens in running this hook,
10766 the hook value is set to nil, since otherwise the error
10767 might happen repeatedly and make Emacs nonfunctional. */);
10768 Vpre_command_hook
= Qnil
;
10770 DEFVAR_LISP ("post-command-hook", &Vpost_command_hook
,
10771 doc
: /* Normal hook run after each command is executed.
10772 If an unhandled error happens in running this hook,
10773 the hook value is set to nil, since otherwise the error
10774 might happen repeatedly and make Emacs nonfunctional. */);
10775 Vpost_command_hook
= Qnil
;
10777 DEFVAR_LISP ("post-command-idle-hook", &Vpost_command_idle_hook
,
10778 doc
: /* Normal hook run after each command is executed, if idle.
10779 Errors running the hook are caught and ignored.
10780 This feature is obsolete; use idle timers instead. See `etc/NEWS'. */);
10781 Vpost_command_idle_hook
= Qnil
;
10783 DEFVAR_INT ("post-command-idle-delay", &post_command_idle_delay
,
10784 doc
: /* Delay time before running `post-command-idle-hook'.
10785 This is measured in microseconds. */);
10786 post_command_idle_delay
= 100000;
10789 DEFVAR_LISP ("echo-area-clear-hook", ...,
10790 doc
: /* Normal hook run when clearing the echo area. */);
10792 Qecho_area_clear_hook
= intern ("echo-area-clear-hook");
10793 SET_SYMBOL_VALUE (Qecho_area_clear_hook
, Qnil
);
10795 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", &Vlucid_menu_bar_dirty_flag
,
10796 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
10797 Vlucid_menu_bar_dirty_flag
= Qnil
;
10799 DEFVAR_LISP ("menu-bar-final-items", &Vmenu_bar_final_items
,
10800 doc
: /* List of menu bar items to move to the end of the menu bar.
10801 The elements of the list are event types that may have menu bar bindings. */);
10802 Vmenu_bar_final_items
= Qnil
;
10804 DEFVAR_KBOARD ("overriding-terminal-local-map",
10805 Voverriding_terminal_local_map
,
10806 doc
: /* Per-terminal keymap that overrides all other local keymaps.
10807 If this variable is non-nil, it is used as a keymap instead of the
10808 buffer's local map, and the minor mode keymaps and text property keymaps.
10809 This variable is intended to let commands such as `universal-argument'
10810 set up a different keymap for reading the next command. */);
10812 DEFVAR_LISP ("overriding-local-map", &Voverriding_local_map
,
10813 doc
: /* Keymap that overrides all other local keymaps.
10814 If this variable is non-nil, it is used as a keymap instead of the
10815 buffer's local map, and the minor mode keymaps and text property keymaps. */);
10816 Voverriding_local_map
= Qnil
;
10818 DEFVAR_LISP ("overriding-local-map-menu-flag", &Voverriding_local_map_menu_flag
,
10819 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
10820 Otherwise, the menu bar continues to reflect the buffer's local map
10821 and the minor mode maps regardless of `overriding-local-map'. */);
10822 Voverriding_local_map_menu_flag
= Qnil
;
10824 DEFVAR_LISP ("special-event-map", &Vspecial_event_map
,
10825 doc
: /* Keymap defining bindings for special events to execute at low level. */);
10826 Vspecial_event_map
= Fcons (intern ("keymap"), Qnil
);
10828 DEFVAR_LISP ("track-mouse", &do_mouse_tracking
,
10829 doc
: /* *Non-nil means generate motion events for mouse motion. */);
10831 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
10832 doc
: /* Alist of system-specific X windows key symbols.
10833 Each element should have the form (N . SYMBOL) where N is the
10834 numeric keysym code (sans the \"system-specific\" bit 1<<28)
10835 and SYMBOL is its name. */);
10837 DEFVAR_LISP ("deferred-action-list", &Vdeferred_action_list
,
10838 doc
: /* List of deferred actions to be performed at a later time.
10839 The precise format isn't relevant here; we just check whether it is nil. */);
10840 Vdeferred_action_list
= Qnil
;
10842 DEFVAR_LISP ("deferred-action-function", &Vdeferred_action_function
,
10843 doc
: /* Function to call to handle deferred actions, after each command.
10844 This function is called with no arguments after each command
10845 whenever `deferred-action-list' is non-nil. */);
10846 Vdeferred_action_function
= Qnil
;
10848 DEFVAR_LISP ("suggest-key-bindings", &Vsuggest_key_bindings
,
10849 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
10850 The value can be a length of time to show the message for.
10851 If the value is non-nil and not a number, we wait 2 seconds. */);
10852 Vsuggest_key_bindings
= Qt
;
10854 DEFVAR_LISP ("timer-list", &Vtimer_list
,
10855 doc
: /* List of active absolute time timers in order of increasing time. */);
10856 Vtimer_list
= Qnil
;
10858 DEFVAR_LISP ("timer-idle-list", &Vtimer_idle_list
,
10859 doc
: /* List of active idle-time timers in order of increasing time. */);
10860 Vtimer_idle_list
= Qnil
;
10862 DEFVAR_LISP ("input-method-function", &Vinput_method_function
,
10863 doc
: /* If non-nil, the function that implements the current input method.
10864 It's called with one argument, a printing character that was just read.
10865 \(That means a character with code 040...0176.)
10866 Typically this function uses `read-event' to read additional events.
10867 When it does so, it should first bind `input-method-function' to nil
10868 so it will not be called recursively.
10870 The function should return a list of zero or more events
10871 to be used as input. If it wants to put back some events
10872 to be reconsidered, separately, by the input method,
10873 it can add them to the beginning of `unread-command-events'.
10875 The input method function can find in `input-method-previous-method'
10876 the previous echo area message.
10878 The input method function should refer to the variables
10879 `input-method-use-echo-area' and `input-method-exit-on-first-char'
10880 for guidance on what to do. */);
10881 Vinput_method_function
= Qnil
;
10883 DEFVAR_LISP ("input-method-previous-message",
10884 &Vinput_method_previous_message
,
10885 doc
: /* When `input-method-function' is called, hold the previous echo area message.
10886 This variable exists because `read-event' clears the echo area
10887 before running the input method. It is nil if there was no message. */);
10888 Vinput_method_previous_message
= Qnil
;
10890 DEFVAR_LISP ("show-help-function", &Vshow_help_function
,
10891 doc
: /* If non-nil, the function that implements the display of help.
10892 It's called with one argument, the help string to display. */);
10893 Vshow_help_function
= Qnil
;
10895 DEFVAR_LISP ("disable-point-adjustment", &Vdisable_point_adjustment
,
10896 doc
: /* If non-nil, suppress point adjustment after executing a command.
10898 After a command is executed, if point is moved into a region that has
10899 special properties (e.g. composition, display), we adjust point to
10900 the boundary of the region. But, several special commands sets this
10901 variable to non-nil, then we suppress the point adjustment.
10903 This variable is set to nil before reading a command, and is checked
10904 just after executing the command. */);
10905 Vdisable_point_adjustment
= Qnil
;
10907 DEFVAR_LISP ("global-disable-point-adjustment",
10908 &Vglobal_disable_point_adjustment
,
10909 doc
: /* *If non-nil, always suppress point adjustment.
10911 The default value is nil, in which case, point adjustment are
10912 suppressed only after special commands that set
10913 `disable-point-adjustment' (which see) to non-nil. */);
10914 Vglobal_disable_point_adjustment
= Qnil
;
10916 DEFVAR_BOOL ("update-menu-bindings", &update_menu_bindings
,
10917 doc
: /* Non-nil means updating menu bindings is allowed.
10918 A value of nil means menu bindings should not be updated.
10919 Used during Emacs' startup. */);
10920 update_menu_bindings
= 1;
10922 DEFVAR_LISP ("minibuffer-message-timeout", &Vminibuffer_message_timeout
,
10923 doc
: /* *How long to display an echo-area message when the minibuffer is active.
10924 If the value is not a number, such messages don't time out. */);
10925 Vminibuffer_message_timeout
= make_number (2);
10929 keys_of_keyboard ()
10931 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
10932 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
10933 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
10934 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
10935 initial_define_key (meta_map
, 'x', "execute-extended-command");
10937 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
10938 "handle-delete-frame");
10939 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
10941 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",