1 /* Keyboard and mouse input; editor command loop.
3 Copyright (C) 1985-1989, 1993-1997, 1999-2011 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
28 #include "termhooks.h"
34 #include "character.h"
36 #include "dispextern.h"
38 #include "intervals.h"
40 #include "blockinput.h"
47 #ifdef HAVE_GTK_AND_PTHREAD
54 #include <sys/ioctl.h>
55 #endif /* not MSDOS */
57 #include "syssignal.h"
59 #include <sys/types.h>
63 /* This is to get the definitions of the XK_ symbols. */
70 #endif /* HAVE_NTGUI */
76 /* Variables for blockinput.h: */
78 /* Non-zero if interrupt input is blocked right now. */
79 volatile int interrupt_input_blocked
;
81 /* Nonzero means an input interrupt has arrived
82 during the current critical section. */
83 int interrupt_input_pending
;
85 /* This var should be (interrupt_input_pending || pending_atimers).
86 The QUIT macro checks this instead of interrupt_input_pending and
87 pending_atimers separately, to reduce code size. So, any code that
88 changes interrupt_input_pending or pending_atimers should update
94 #define KBD_BUFFER_SIZE 4096
96 KBOARD
*initial_kboard
;
97 KBOARD
*current_kboard
;
101 /* Non-nil disable property on a command means
102 do not execute it; call disabled-command-function's value instead. */
103 Lisp_Object Qdisabled
, Qdisabled_command_function
;
105 #define NUM_RECENT_KEYS (300)
106 int recent_keys_index
; /* Index for storing next element into recent_keys */
107 int total_keys
; /* Total number of elements stored into recent_keys */
108 Lisp_Object recent_keys
; /* Vector holds the last NUM_RECENT_KEYS keystrokes */
110 /* Vector holding the key sequence that invoked the current command.
111 It is reused for each command, and it may be longer than the current
112 sequence; this_command_key_count indicates how many elements
113 actually mean something.
114 It's easier to staticpro a single Lisp_Object than an array. */
115 Lisp_Object this_command_keys
;
116 int this_command_key_count
;
118 /* 1 after calling Freset_this_command_lengths.
120 int this_command_key_count_reset
;
122 /* This vector is used as a buffer to record the events that were actually read
123 by read_key_sequence. */
124 Lisp_Object raw_keybuf
;
125 int raw_keybuf_count
;
127 #define GROW_RAW_KEYBUF \
128 if (raw_keybuf_count == XVECTOR (raw_keybuf)->size) \
129 raw_keybuf = larger_vector (raw_keybuf, raw_keybuf_count * 2, Qnil) \
131 /* Number of elements of this_command_keys
132 that precede this key sequence. */
133 int this_single_command_key_start
;
135 /* Record values of this_command_key_count and echo_length ()
136 before this command was read. */
137 static int before_command_key_count
;
138 static int before_command_echo_length
;
140 /* For longjmp to where kbd input is being done. */
142 static jmp_buf getcjmp
;
144 /* True while doing kbd input. */
145 int waiting_for_input
;
147 /* True while displaying for echoing. Delays C-g throwing. */
151 /* Non-null means we can start echoing at the next input pause even
152 though there is something in the echo area. */
154 static struct kboard
*ok_to_echo_at_next_pause
;
156 /* The kboard last echoing, or null for none. Reset to 0 in
157 cancel_echoing. If non-null, and a current echo area message
158 exists, and echo_message_buffer is eq to the current message
159 buffer, we know that the message comes from echo_kboard. */
161 struct kboard
*echo_kboard
;
163 /* The buffer used for echoing. Set in echo_now, reset in
166 Lisp_Object echo_message_buffer
;
168 /* Nonzero means C-g should cause immediate error-signal. */
171 /* Character that causes a quit. Normally C-g.
173 If we are running on an ordinary terminal, this must be an ordinary
174 ASCII char, since we want to make it our interrupt character.
176 If we are not running on an ordinary terminal, it still needs to be
177 an ordinary ASCII char. This character needs to be recognized in
178 the input interrupt handler. At this point, the keystroke is
179 represented as a struct input_event, while the desired quit
180 character is specified as a lispy event. The mapping from struct
181 input_events to lispy events cannot run in an interrupt handler,
182 and the reverse mapping is difficult for anything but ASCII
185 FOR THESE ELABORATE AND UNSATISFYING REASONS, quit_char must be an
189 /* Current depth in recursive edits. */
190 int command_loop_level
;
192 /* If not Qnil, this is a switch-frame event which we decided to put
193 off until the end of a key sequence. This should be read as the
194 next command input, after any unread_command_events.
196 read_key_sequence uses this to delay switch-frame events until the
197 end of the key sequence; Fread_char uses it to put off switch-frame
198 events until a non-ASCII event is acceptable as input. */
199 Lisp_Object unread_switch_frame
;
201 /* Last size recorded for a current buffer which is not a minibuffer. */
202 static EMACS_INT last_non_minibuf_size
;
204 /* Total number of times read_char has returned. */
205 int num_input_events
;
207 /* Value of num_nonmacro_input_events as of last auto save. */
211 /* This is like Vthis_command, except that commands never set it. */
212 Lisp_Object real_this_command
;
214 /* The value of point when the last command was started. */
215 EMACS_INT last_point_position
;
217 /* The buffer that was current when the last command was started. */
218 Lisp_Object last_point_position_buffer
;
220 /* The window that was selected when the last command was started. */
221 Lisp_Object last_point_position_window
;
223 /* The frame in which the last input event occurred, or Qmacro if the
224 last event came from a macro. We use this to determine when to
225 generate switch-frame events. This may be cleared by functions
226 like Fselect_frame, to make sure that a switch-frame event is
227 generated by the next character. */
228 Lisp_Object internal_last_event_frame
;
230 /* The timestamp of the last input event we received from the X server.
231 X Windows wants this for selection ownership. */
232 unsigned long last_event_timestamp
;
234 Lisp_Object Qx_set_selection
, QPRIMARY
, Qhandle_switch_frame
;
236 Lisp_Object Qself_insert_command
;
237 Lisp_Object Qforward_char
;
238 Lisp_Object Qbackward_char
;
239 Lisp_Object Qundefined
;
240 Lisp_Object Qtimer_event_handler
;
242 /* read_key_sequence stores here the command definition of the
243 key sequence that it reads. */
244 Lisp_Object read_key_sequence_cmd
;
246 Lisp_Object Qinput_method_function
;
248 Lisp_Object Qdeactivate_mark
;
250 Lisp_Object Qrecompute_lucid_menubar
, Qactivate_menubar_hook
;
252 Lisp_Object Qecho_area_clear_hook
;
254 /* Hooks to run before and after each command. */
255 Lisp_Object Qpre_command_hook
;
256 Lisp_Object Qpost_command_hook
;
257 Lisp_Object Qcommand_hook_internal
;
259 Lisp_Object Qdeferred_action_function
;
261 Lisp_Object Qinput_method_exit_on_first_char
;
262 Lisp_Object Qinput_method_use_echo_area
;
264 /* File in which we write all commands we read. */
267 /* Nonzero if input is available. */
270 /* Circular buffer for pre-read keyboard input. */
272 static struct input_event kbd_buffer
[KBD_BUFFER_SIZE
];
274 /* Pointer to next available character in kbd_buffer.
275 If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
276 This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
277 next available char is in kbd_buffer[0]. */
278 static struct input_event
*kbd_fetch_ptr
;
280 /* Pointer to next place to store character in kbd_buffer. This
281 may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the next
282 character should go in kbd_buffer[0]. */
283 static struct input_event
* volatile kbd_store_ptr
;
285 /* The above pair of variables forms a "queue empty" flag. When we
286 enqueue a non-hook event, we increment kbd_store_ptr. When we
287 dequeue a non-hook event, we increment kbd_fetch_ptr. We say that
288 there is input available if the two pointers are not equal.
290 Why not just have a flag set and cleared by the enqueuing and
291 dequeuing functions? Such a flag could be screwed up by interrupts
292 at inopportune times. */
294 /* Symbols to head events. */
295 Lisp_Object Qmouse_movement
;
296 Lisp_Object Qscroll_bar_movement
;
297 Lisp_Object Qswitch_frame
;
298 Lisp_Object Qdelete_frame
;
299 Lisp_Object Qiconify_frame
;
300 Lisp_Object Qmake_frame_visible
;
301 Lisp_Object Qselect_window
;
302 Lisp_Object Qhelp_echo
;
304 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
305 Lisp_Object Qmouse_fixup_help_message
;
308 /* Symbols to denote kinds of events. */
309 Lisp_Object Qfunction_key
;
310 Lisp_Object Qmouse_click
;
311 #if defined (WINDOWSNT)
312 Lisp_Object Qlanguage_change
;
314 Lisp_Object Qdrag_n_drop
;
315 Lisp_Object Qsave_session
;
317 Lisp_Object Qdbus_event
;
319 Lisp_Object Qconfig_changed_event
;
321 /* Lisp_Object Qmouse_movement; - also an event header */
323 /* Properties of event headers. */
324 Lisp_Object Qevent_kind
;
325 Lisp_Object Qevent_symbol_elements
;
327 /* menu and tool bar item parts */
328 Lisp_Object Qmenu_enable
;
329 Lisp_Object QCenable
, QCvisible
, QChelp
, QCfilter
, QCkeys
, QCkey_sequence
;
330 Lisp_Object QCbutton
, QCtoggle
, QCradio
, QClabel
, QCvert_only
;
332 /* An event header symbol HEAD may have a property named
333 Qevent_symbol_element_mask, which is of the form (BASE MODIFIERS);
334 BASE is the base, unmodified version of HEAD, and MODIFIERS is the
335 mask of modifiers applied to it. If present, this is used to help
336 speed up parse_modifiers. */
337 Lisp_Object Qevent_symbol_element_mask
;
339 /* An unmodified event header BASE may have a property named
340 Qmodifier_cache, which is an alist mapping modifier masks onto
341 modified versions of BASE. If present, this helps speed up
343 Lisp_Object Qmodifier_cache
;
345 /* Symbols to use for parts of windows. */
346 Lisp_Object Qmode_line
;
347 Lisp_Object Qvertical_line
;
348 Lisp_Object Qvertical_scroll_bar
;
349 Lisp_Object Qmenu_bar
;
351 Lisp_Object
recursive_edit_unwind (Lisp_Object buffer
), command_loop (void);
352 Lisp_Object
Fthis_command_keys (void);
353 Lisp_Object Qextended_command_history
;
354 EMACS_TIME
timer_check (int do_it_now
);
356 static void record_menu_key (Lisp_Object c
);
357 static int echo_length (void);
359 Lisp_Object Qpolling_period
;
361 /* Incremented whenever a timer is run. */
364 /* Address (if not 0) of EMACS_TIME to zero out if a SIGIO interrupt
366 EMACS_TIME
*input_available_clear_time
;
368 /* Nonzero means use SIGIO interrupts; zero means use CBREAK mode.
369 Default is 1 if INTERRUPT_INPUT is defined. */
372 /* Nonzero while interrupts are temporarily deferred during redisplay. */
373 int interrupts_deferred
;
375 /* Allow m- file to inhibit use of FIONREAD. */
376 #ifdef BROKEN_FIONREAD
380 /* We are unable to use interrupts if FIONREAD is not available,
381 so flush SIGIO so we won't try. */
382 #if !defined (FIONREAD)
388 /* If we support a window system, turn on the code to poll periodically
389 to detect C-g. It isn't actually used when doing interrupt input. */
390 #if defined(HAVE_WINDOW_SYSTEM) && !defined(USE_ASYNC_EVENTS)
391 #define POLL_FOR_INPUT
394 /* The time when Emacs started being idle. */
396 static EMACS_TIME timer_idleness_start_time
;
398 /* After Emacs stops being idle, this saves the last value
399 of timer_idleness_start_time from when it was idle. */
401 static EMACS_TIME timer_last_idleness_start_time
;
404 /* Global variable declarations. */
406 /* Flags for readable_events. */
407 #define READABLE_EVENTS_DO_TIMERS_NOW (1 << 0)
408 #define READABLE_EVENTS_FILTER_EVENTS (1 << 1)
409 #define READABLE_EVENTS_IGNORE_SQUEEZABLES (1 << 2)
411 /* Function for init_keyboard to call with no args (if nonzero). */
412 void (*keyboard_init_hook
) (void);
414 static int read_avail_input (int);
415 static void get_input_pending (int *, int);
416 static int readable_events (int);
417 static Lisp_Object
read_char_x_menu_prompt (int, Lisp_Object
*,
419 static Lisp_Object
read_char_minibuf_menu_prompt (int, int,
421 static Lisp_Object
make_lispy_event (struct input_event
*);
422 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
423 static Lisp_Object
make_lispy_movement (struct frame
*, Lisp_Object
,
424 enum scroll_bar_part
,
425 Lisp_Object
, Lisp_Object
,
428 static Lisp_Object
modify_event_symbol (EMACS_INT
, unsigned, Lisp_Object
,
429 Lisp_Object
, const char *const *,
430 Lisp_Object
*, unsigned);
431 static Lisp_Object
make_lispy_switch_frame (Lisp_Object
);
432 static void save_getcjmp (jmp_buf);
433 static void restore_getcjmp (jmp_buf);
434 static Lisp_Object
apply_modifiers (int, Lisp_Object
);
435 static void clear_event (struct input_event
*);
436 static Lisp_Object
restore_kboard_configuration (Lisp_Object
);
437 static SIGTYPE
interrupt_signal (int signalnum
);
439 static SIGTYPE
input_available_signal (int signo
);
441 static void handle_interrupt (void);
442 static void timer_start_idle (void);
443 static void timer_stop_idle (void);
444 static void timer_resume_idle (void);
445 static SIGTYPE
handle_user_signal (int);
446 static char *find_user_signal_name (int);
447 static int store_user_signal_events (void);
450 /* Add C to the echo string, if echoing is going on.
451 C can be a character, which is printed prettily ("M-C-x" and all that
452 jazz), or a symbol, whose name is printed. */
455 echo_char (Lisp_Object c
)
457 if (current_kboard
->immediate_echo
)
459 int size
= KEY_DESCRIPTION_SIZE
+ 100;
460 char *buffer
= (char *) alloca (size
);
462 Lisp_Object echo_string
;
464 echo_string
= KVAR (current_kboard
, echo_string
);
466 /* If someone has passed us a composite event, use its head symbol. */
471 ptr
= push_key_description (XINT (c
), ptr
, 1);
473 else if (SYMBOLP (c
))
475 Lisp_Object name
= SYMBOL_NAME (c
);
476 int nbytes
= SBYTES (name
);
478 if (size
- (ptr
- buffer
) < nbytes
)
480 int offset
= ptr
- buffer
;
481 size
= max (2 * size
, size
+ nbytes
);
482 buffer
= (char *) alloca (size
);
483 ptr
= buffer
+ offset
;
486 ptr
+= copy_text (SDATA (name
), (unsigned char *) ptr
, nbytes
,
487 STRING_MULTIBYTE (name
), 1);
490 if ((NILP (echo_string
) || SCHARS (echo_string
) == 0)
493 const char *text
= " (Type ? for further options)";
494 int len
= strlen (text
);
496 if (size
- (ptr
- buffer
) < len
)
498 int offset
= ptr
- buffer
;
500 buffer
= (char *) alloca (size
);
501 ptr
= buffer
+ offset
;
504 memcpy (ptr
, text
, len
);
508 /* Replace a dash from echo_dash with a space, otherwise
509 add a space at the end as a separator between keys. */
510 if (STRINGP (echo_string
)
511 && SCHARS (echo_string
) > 1)
513 Lisp_Object last_char
, prev_char
, idx
;
515 idx
= make_number (SCHARS (echo_string
) - 2);
516 prev_char
= Faref (echo_string
, idx
);
518 idx
= make_number (SCHARS (echo_string
) - 1);
519 last_char
= Faref (echo_string
, idx
);
521 /* We test PREV_CHAR to make sure this isn't the echoing
523 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
524 Faset (echo_string
, idx
, make_number (' '));
526 echo_string
= concat2 (echo_string
, build_string (" "));
528 else if (STRINGP (echo_string
))
529 echo_string
= concat2 (echo_string
, build_string (" "));
531 KVAR (current_kboard
, echo_string
)
532 = concat2 (echo_string
, make_string (buffer
, ptr
- buffer
));
538 /* Temporarily add a dash to the end of the echo string if it's not
539 empty, so that it serves as a mini-prompt for the very next character. */
544 /* Do nothing if not echoing at all. */
545 if (NILP (KVAR (current_kboard
, echo_string
)))
548 if (this_command_key_count
== 0)
551 if (!current_kboard
->immediate_echo
552 && SCHARS (KVAR (current_kboard
, echo_string
)) == 0)
555 /* Do nothing if we just printed a prompt. */
556 if (current_kboard
->echo_after_prompt
557 == SCHARS (KVAR (current_kboard
, echo_string
)))
560 /* Do nothing if we have already put a dash at the end. */
561 if (SCHARS (KVAR (current_kboard
, echo_string
)) > 1)
563 Lisp_Object last_char
, prev_char
, idx
;
565 idx
= make_number (SCHARS (KVAR (current_kboard
, echo_string
)) - 2);
566 prev_char
= Faref (KVAR (current_kboard
, echo_string
), idx
);
568 idx
= make_number (SCHARS (KVAR (current_kboard
, echo_string
)) - 1);
569 last_char
= Faref (KVAR (current_kboard
, echo_string
), idx
);
571 if (XINT (last_char
) == '-' && XINT (prev_char
) != ' ')
575 /* Put a dash at the end of the buffer temporarily,
576 but make it go away when the next character is added. */
577 KVAR (current_kboard
, echo_string
) = concat2 (KVAR (current_kboard
, echo_string
),
582 /* Display the current echo string, and begin echoing if not already
588 if (!current_kboard
->immediate_echo
)
591 current_kboard
->immediate_echo
= 1;
593 for (i
= 0; i
< this_command_key_count
; i
++)
597 /* Set before_command_echo_length to the value that would
598 have been saved before the start of this subcommand in
599 command_loop_1, if we had already been echoing then. */
600 if (i
== this_single_command_key_start
)
601 before_command_echo_length
= echo_length ();
603 c
= XVECTOR (this_command_keys
)->contents
[i
];
604 if (! (EVENT_HAS_PARAMETERS (c
)
605 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
609 /* Set before_command_echo_length to the value that would
610 have been saved before the start of this subcommand in
611 command_loop_1, if we had already been echoing then. */
612 if (this_command_key_count
== this_single_command_key_start
)
613 before_command_echo_length
= echo_length ();
615 /* Put a dash at the end to invite the user to type more. */
620 message3_nolog (KVAR (current_kboard
, echo_string
),
621 SBYTES (KVAR (current_kboard
, echo_string
)),
622 STRING_MULTIBYTE (KVAR (current_kboard
, echo_string
)));
625 /* Record in what buffer we echoed, and from which kboard. */
626 echo_message_buffer
= echo_area_buffer
[0];
627 echo_kboard
= current_kboard
;
629 if (waiting_for_input
&& !NILP (Vquit_flag
))
630 quit_throw_to_read_char ();
633 /* Turn off echoing, for the start of a new command. */
636 cancel_echoing (void)
638 current_kboard
->immediate_echo
= 0;
639 current_kboard
->echo_after_prompt
= -1;
640 KVAR (current_kboard
, echo_string
) = Qnil
;
641 ok_to_echo_at_next_pause
= NULL
;
643 echo_message_buffer
= Qnil
;
646 /* Return the length of the current echo string. */
651 return (STRINGP (KVAR (current_kboard
, echo_string
))
652 ? SCHARS (KVAR (current_kboard
, echo_string
))
656 /* Truncate the current echo message to its first LEN chars.
657 This and echo_char get used by read_key_sequence when the user
658 switches frames while entering a key sequence. */
661 echo_truncate (EMACS_INT nchars
)
663 if (STRINGP (KVAR (current_kboard
, echo_string
)))
664 KVAR (current_kboard
, echo_string
)
665 = Fsubstring (KVAR (current_kboard
, echo_string
),
666 make_number (0), make_number (nchars
));
667 truncate_echo_area (nchars
);
671 /* Functions for manipulating this_command_keys. */
673 add_command_key (Lisp_Object key
)
675 #if 0 /* Not needed after we made Freset_this_command_lengths
676 do the job immediately. */
677 /* If reset-this-command-length was called recently, obey it now.
678 See the doc string of that function for an explanation of why. */
679 if (before_command_restore_flag
)
681 this_command_key_count
= before_command_key_count_1
;
682 if (this_command_key_count
< this_single_command_key_start
)
683 this_single_command_key_start
= this_command_key_count
;
684 echo_truncate (before_command_echo_length_1
);
685 before_command_restore_flag
= 0;
689 if (this_command_key_count
>= ASIZE (this_command_keys
))
690 this_command_keys
= larger_vector (this_command_keys
,
691 2 * ASIZE (this_command_keys
),
694 ASET (this_command_keys
, this_command_key_count
, key
);
695 ++this_command_key_count
;
700 recursive_edit_1 (void)
702 int count
= SPECPDL_INDEX ();
705 if (command_loop_level
> 0)
707 specbind (Qstandard_output
, Qt
);
708 specbind (Qstandard_input
, Qt
);
711 #ifdef HAVE_WINDOW_SYSTEM
712 /* The command loop has started an hourglass timer, so we have to
713 cancel it here, otherwise it will fire because the recursive edit
714 can take some time. Do not check for display_hourglass_p here,
715 because it could already be nil. */
719 /* This function may have been called from a debugger called from
720 within redisplay, for instance by Edebugging a function called
721 from fontification-functions. We want to allow redisplay in
722 the debugging session.
724 The recursive edit is left with a `(throw exit ...)'. The `exit'
725 tag is not caught anywhere in redisplay, i.e. when we leave the
726 recursive edit, the original redisplay leading to the recursive
727 edit will be unwound. The outcome should therefore be safe. */
728 specbind (Qinhibit_redisplay
, Qnil
);
731 val
= command_loop ();
733 Fsignal (Qquit
, Qnil
);
734 /* Handle throw from read_minibuf when using minibuffer
735 while it's active but we're in another window. */
737 xsignal1 (Qerror
, val
);
739 return unbind_to (count
, Qnil
);
742 /* When an auto-save happens, record the "time", and don't do again soon. */
745 record_auto_save (void)
747 last_auto_save
= num_nonmacro_input_events
;
750 /* Make an auto save happen as soon as possible at command level. */
753 force_auto_save_soon (void)
755 last_auto_save
= - auto_save_interval
- 1;
757 record_asynch_buffer_change ();
760 DEFUN ("recursive-edit", Frecursive_edit
, Srecursive_edit
, 0, 0, "",
761 doc
: /* Invoke the editor command loop recursively.
762 To get out of the recursive edit, a command can do `(throw 'exit nil)';
763 that tells this function to return.
764 Alternatively, `(throw 'exit t)' makes this function signal an error.
765 This function is called by the editor initialization to begin editing. */)
768 int count
= SPECPDL_INDEX ();
771 /* If we enter while input is blocked, don't lock up here.
772 This may happen through the debugger during redisplay. */
776 command_loop_level
++;
777 update_mode_lines
= 1;
779 if (command_loop_level
780 && current_buffer
!= XBUFFER (XWINDOW (selected_window
)->buffer
))
781 buffer
= Fcurrent_buffer ();
785 /* If we leave recursive_edit_1 below with a `throw' for instance,
786 like it is done in the splash screen display, we have to
787 make sure that we restore single_kboard as command_loop_1
788 would have done if it were left normally. */
789 if (command_loop_level
> 0)
790 temporarily_switch_to_single_kboard (SELECTED_FRAME ());
791 record_unwind_protect (recursive_edit_unwind
, buffer
);
794 return unbind_to (count
, Qnil
);
798 recursive_edit_unwind (Lisp_Object buffer
)
800 if (BUFFERP (buffer
))
801 Fset_buffer (buffer
);
803 command_loop_level
--;
804 update_mode_lines
= 1;
809 #if 0 /* These two functions are now replaced with
810 temporarily_switch_to_single_kboard. */
814 #if 0 /* Theory: if there's anything in Vunread_command_events,
815 it will right away be read by read_key_sequence,
816 and then if we do switch KBOARDS, it will go into the side
817 queue then. So we don't need to do anything special here -- rms. */
818 if (CONSP (Vunread_command_events
))
820 current_kboard
->kbd_queue
821 = nconc2 (Vunread_command_events
, current_kboard
->kbd_queue
);
822 current_kboard
->kbd_queue_has_data
= 1;
824 Vunread_command_events
= Qnil
;
829 /* Switch to the single-kboard state, making current_kboard
830 the only KBOARD from which further input is accepted. */
833 single_kboard_state ()
839 /* If we're in single_kboard state for kboard KBOARD,
843 not_single_kboard_state (KBOARD
*kboard
)
845 if (kboard
== current_kboard
)
849 /* Maintain a stack of kboards, so other parts of Emacs
850 can switch temporarily to the kboard of a given frame
851 and then revert to the previous status. */
856 struct kboard_stack
*next
;
859 static struct kboard_stack
*kboard_stack
;
862 push_kboard (struct kboard
*k
)
864 struct kboard_stack
*p
865 = (struct kboard_stack
*) xmalloc (sizeof (struct kboard_stack
));
867 p
->next
= kboard_stack
;
868 p
->kboard
= current_kboard
;
878 struct kboard_stack
*p
= kboard_stack
;
880 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
882 if (t
->kboard
== p
->kboard
)
884 current_kboard
= p
->kboard
;
891 /* The terminal we remembered has been deleted. */
892 current_kboard
= FRAME_KBOARD (SELECTED_FRAME ());
895 kboard_stack
= p
->next
;
899 /* Switch to single_kboard mode, making current_kboard the only KBOARD
900 from which further input is accepted. If F is non-nil, set its
901 KBOARD as the current keyboard.
903 This function uses record_unwind_protect to return to the previous
906 If Emacs is already in single_kboard mode, and F's keyboard is
907 locked, then this function will throw an errow. */
910 temporarily_switch_to_single_kboard (struct frame
*f
)
912 int was_locked
= single_kboard
;
915 if (f
!= NULL
&& FRAME_KBOARD (f
) != current_kboard
)
916 /* We can not switch keyboards while in single_kboard mode.
917 In rare cases, Lisp code may call `recursive-edit' (or
918 `read-minibuffer' or `y-or-n-p') after it switched to a
919 locked frame. For example, this is likely to happen
920 when server.el connects to a new terminal while Emacs is in
921 single_kboard mode. It is best to throw an error instead
922 of presenting the user with a frozen screen. */
923 error ("Terminal %d is locked, cannot read from it",
924 FRAME_TERMINAL (f
)->id
);
926 /* This call is unnecessary, but helps
927 `restore_kboard_configuration' discover if somebody changed
928 `current_kboard' behind our back. */
929 push_kboard (current_kboard
);
932 current_kboard
= FRAME_KBOARD (f
);
934 record_unwind_protect (restore_kboard_configuration
,
935 (was_locked
? Qt
: Qnil
));
938 #if 0 /* This function is not needed anymore. */
940 record_single_kboard_state ()
943 push_kboard (current_kboard
);
944 record_unwind_protect (restore_kboard_configuration
,
945 (single_kboard
? Qt
: Qnil
));
950 restore_kboard_configuration (Lisp_Object was_locked
)
952 if (NILP (was_locked
))
956 struct kboard
*prev
= current_kboard
;
959 /* The pop should not change the kboard. */
960 if (single_kboard
&& current_kboard
!= prev
)
967 /* Handle errors that are not handled at inner levels
968 by printing an error message and returning to the editor command loop. */
971 cmd_error (Lisp_Object data
)
973 Lisp_Object old_level
, old_length
;
976 #ifdef HAVE_WINDOW_SYSTEM
977 if (display_hourglass_p
)
981 if (!NILP (executing_kbd_macro
))
983 if (executing_kbd_macro_iterations
== 1)
984 sprintf (macroerror
, "After 1 kbd macro iteration: ");
986 sprintf (macroerror
, "After %d kbd macro iterations: ",
987 executing_kbd_macro_iterations
);
992 Vstandard_output
= Qt
;
993 Vstandard_input
= Qt
;
994 Vexecuting_kbd_macro
= Qnil
;
995 executing_kbd_macro
= Qnil
;
996 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
997 KVAR (current_kboard
, Vlast_prefix_arg
) = Qnil
;
1000 /* Avoid unquittable loop if data contains a circular list. */
1001 old_level
= Vprint_level
;
1002 old_length
= Vprint_length
;
1003 XSETFASTINT (Vprint_level
, 10);
1004 XSETFASTINT (Vprint_length
, 10);
1005 cmd_error_internal (data
, macroerror
);
1006 Vprint_level
= old_level
;
1007 Vprint_length
= old_length
;
1011 Vinhibit_quit
= Qnil
;
1012 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1013 if (command_loop_level
== 0 && minibuf_level
== 0)
1014 any_kboard_state ();
1017 return make_number (0);
1020 /* Take actions on handling an error. DATA is the data that describes
1023 CONTEXT is a C-string containing ASCII characters only which
1024 describes the context in which the error happened. If we need to
1025 generalize CONTEXT to allow multibyte characters, make it a Lisp
1029 cmd_error_internal (Lisp_Object data
, const char *context
)
1031 struct frame
*sf
= SELECTED_FRAME ();
1033 /* The immediate context is not interesting for Quits,
1034 since they are asyncronous. */
1035 if (EQ (XCAR (data
), Qquit
))
1036 Vsignaling_function
= Qnil
;
1041 /* Use user's specified output function if any. */
1042 if (!NILP (Vcommand_error_function
))
1043 call3 (Vcommand_error_function
, data
,
1044 context
? build_string (context
) : empty_unibyte_string
,
1045 Vsignaling_function
);
1046 /* If the window system or terminal frame hasn't been initialized
1047 yet, or we're not interactive, write the message to stderr and exit. */
1048 else if (!sf
->glyphs_initialized_p
1049 /* The initial frame is a special non-displaying frame. It
1050 will be current in daemon mode when there are no frames
1051 to display, and in non-daemon mode before the real frame
1052 has finished initializing. If an error is thrown in the
1053 latter case while creating the frame, then the frame
1054 will never be displayed, so the safest thing to do is
1055 write to stderr and quit. In daemon mode, there are
1056 many other potential errors that do not prevent frames
1057 from being created, so continuing as normal is better in
1059 || (!IS_DAEMON
&& FRAME_INITIAL_P (sf
))
1062 print_error_message (data
, Qexternal_debugging_output
,
1063 context
, Vsignaling_function
);
1064 Fterpri (Qexternal_debugging_output
);
1065 Fkill_emacs (make_number (-1));
1069 clear_message (1, 0);
1071 message_log_maybe_newline ();
1074 print_error_message (data
, Qt
, context
, Vsignaling_function
);
1077 Vsignaling_function
= Qnil
;
1080 Lisp_Object
command_loop_1 (void);
1081 Lisp_Object
command_loop_2 (Lisp_Object
);
1082 Lisp_Object
top_level_1 (Lisp_Object
);
1084 /* Entry to editor-command-loop.
1085 This level has the catches for exiting/returning to editor command loop.
1086 It returns nil to exit recursive edit, t to abort it. */
1091 if (command_loop_level
> 0 || minibuf_level
> 0)
1094 val
= internal_catch (Qexit
, command_loop_2
, Qnil
);
1095 executing_kbd_macro
= Qnil
;
1101 internal_catch (Qtop_level
, top_level_1
, Qnil
);
1102 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1103 /* Reset single_kboard in case top-level set it while
1104 evaluating an -f option, or we are stuck there for some
1106 any_kboard_state ();
1108 internal_catch (Qtop_level
, command_loop_2
, Qnil
);
1109 executing_kbd_macro
= Qnil
;
1111 /* End of file in -batch run causes exit here. */
1117 /* Here we catch errors in execution of commands within the
1118 editing loop, and reenter the editing loop.
1119 When there is an error, cmd_error runs and returns a non-nil
1120 value to us. A value of nil means that command_loop_1 itself
1121 returned due to end of file (or end of kbd macro). */
1124 command_loop_2 (Lisp_Object ignore
)
1126 register Lisp_Object val
;
1129 val
= internal_condition_case (command_loop_1
, Qerror
, cmd_error
);
1130 while (!NILP (val
));
1138 return Feval (Vtop_level
);
1142 top_level_1 (Lisp_Object ignore
)
1144 /* On entry to the outer level, run the startup file */
1145 if (!NILP (Vtop_level
))
1146 internal_condition_case (top_level_2
, Qerror
, cmd_error
);
1147 else if (!NILP (Vpurify_flag
))
1148 message ("Bare impure Emacs (standard Lisp code not loaded)");
1150 message ("Bare Emacs (standard Lisp code not loaded)");
1154 DEFUN ("top-level", Ftop_level
, Stop_level
, 0, 0, "",
1155 doc
: /* Exit all recursive editing levels.
1156 This also exits all active minibuffers. */)
1159 #ifdef HAVE_WINDOW_SYSTEM
1160 if (display_hourglass_p
)
1161 cancel_hourglass ();
1164 /* Unblock input if we enter with input blocked. This may happen if
1165 redisplay traps e.g. during tool-bar update with input blocked. */
1166 while (INPUT_BLOCKED_P
)
1169 Fthrow (Qtop_level
, Qnil
);
1172 DEFUN ("exit-recursive-edit", Fexit_recursive_edit
, Sexit_recursive_edit
, 0, 0, "",
1173 doc
: /* Exit from the innermost recursive edit or minibuffer. */)
1176 if (command_loop_level
> 0 || minibuf_level
> 0)
1177 Fthrow (Qexit
, Qnil
);
1179 error ("No recursive edit is in progress");
1182 DEFUN ("abort-recursive-edit", Fabort_recursive_edit
, Sabort_recursive_edit
, 0, 0, "",
1183 doc
: /* Abort the command that requested this recursive edit or minibuffer input. */)
1186 if (command_loop_level
> 0 || minibuf_level
> 0)
1189 error ("No recursive edit is in progress");
1192 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1194 /* Restore mouse tracking enablement. See Ftrack_mouse for the only use
1195 of this function. */
1198 tracking_off (Lisp_Object old_value
)
1200 do_mouse_tracking
= old_value
;
1201 if (NILP (old_value
))
1203 /* Redisplay may have been preempted because there was input
1204 available, and it assumes it will be called again after the
1205 input has been processed. If the only input available was
1206 the sort that we have just disabled, then we need to call
1208 if (!readable_events (READABLE_EVENTS_DO_TIMERS_NOW
))
1210 redisplay_preserve_echo_area (6);
1211 get_input_pending (&input_pending
,
1212 READABLE_EVENTS_DO_TIMERS_NOW
);
1218 DEFUN ("track-mouse", Ftrack_mouse
, Strack_mouse
, 0, UNEVALLED
, 0,
1219 doc
: /* Evaluate BODY with mouse movement events enabled.
1220 Within a `track-mouse' form, mouse motion generates input events that
1221 you can read with `read-event'.
1222 Normally, mouse motion is ignored.
1223 usage: (track-mouse BODY...) */)
1226 int count
= SPECPDL_INDEX ();
1229 record_unwind_protect (tracking_off
, do_mouse_tracking
);
1231 do_mouse_tracking
= Qt
;
1233 val
= Fprogn (args
);
1234 return unbind_to (count
, val
);
1237 /* If mouse has moved on some frame, return one of those frames.
1241 If ignore_mouse_drag_p is non-zero, ignore (implicit) mouse movement
1242 after resizing the tool-bar window. */
1244 int ignore_mouse_drag_p
;
1247 some_mouse_moved (void)
1249 Lisp_Object tail
, frame
;
1251 if (ignore_mouse_drag_p
)
1253 /* ignore_mouse_drag_p = 0; */
1257 FOR_EACH_FRAME (tail
, frame
)
1259 if (XFRAME (frame
)->mouse_moved
)
1260 return XFRAME (frame
);
1266 #endif /* HAVE_MOUSE || HAVE_GPM */
1268 /* This is the actual command reading loop,
1269 sans error-handling encapsulation. */
1271 static int read_key_sequence (Lisp_Object
*, int, Lisp_Object
,
1273 void safe_run_hooks (Lisp_Object
);
1274 static void adjust_point_for_property (EMACS_INT
, int);
1276 /* Cancel hourglass from protect_unwind.
1278 #ifdef HAVE_WINDOW_SYSTEM
1280 cancel_hourglass_unwind (Lisp_Object arg
)
1282 cancel_hourglass ();
1287 /* FIXME: This is wrong rather than test window-system, we should call
1288 a new set-selection, which will then dispatch to x-set-selection, or
1289 tty-set-selection, or w32-set-selection, ... */
1290 EXFUN (Fwindow_system
, 1);
1293 command_loop_1 (void)
1296 Lisp_Object keybuf
[30];
1298 int prev_modiff
= 0;
1299 struct buffer
*prev_buffer
= NULL
;
1300 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1301 int was_locked
= single_kboard
;
1303 int already_adjusted
= 0;
1305 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1306 KVAR (current_kboard
, Vlast_prefix_arg
) = Qnil
;
1307 Vdeactivate_mark
= Qnil
;
1308 waiting_for_input
= 0;
1311 this_command_key_count
= 0;
1312 this_command_key_count_reset
= 0;
1313 this_single_command_key_start
= 0;
1315 if (NILP (Vmemory_full
))
1317 /* Make sure this hook runs after commands that get errors and
1318 throw to top level. */
1319 /* Note that the value cell will never directly contain nil
1320 if the symbol is a local variable. */
1321 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1322 safe_run_hooks (Qpost_command_hook
);
1324 /* If displaying a message, resize the echo area window to fit
1325 that message's size exactly. */
1326 if (!NILP (echo_area_buffer
[0]))
1327 resize_echo_area_exactly ();
1329 if (!NILP (Vdeferred_action_list
))
1330 safe_run_hooks (Qdeferred_action_function
);
1333 /* Do this after running Vpost_command_hook, for consistency. */
1334 KVAR (current_kboard
, Vlast_command
) = Vthis_command
;
1335 KVAR (current_kboard
, Vreal_last_command
) = real_this_command
;
1336 if (!CONSP (last_command_event
))
1337 KVAR (current_kboard
, Vlast_repeatable_command
) = real_this_command
;
1341 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1344 /* Make sure the current window's buffer is selected. */
1345 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1346 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1348 /* Display any malloc warning that just came out. Use while because
1349 displaying one warning can cause another. */
1351 while (pending_malloc_warning
)
1352 display_malloc_warning ();
1354 Vdeactivate_mark
= Qnil
;
1356 /* If minibuffer on and echo area in use,
1357 wait a short time and redraw minibuffer. */
1360 && !NILP (echo_area_buffer
[0])
1361 && EQ (minibuf_window
, echo_area_window
)
1362 && NUMBERP (Vminibuffer_message_timeout
))
1364 /* Bind inhibit-quit to t so that C-g gets read in
1365 rather than quitting back to the minibuffer. */
1366 int count
= SPECPDL_INDEX ();
1367 specbind (Qinhibit_quit
, Qt
);
1369 sit_for (Vminibuffer_message_timeout
, 0, 2);
1371 /* Clear the echo area. */
1373 safe_run_hooks (Qecho_area_clear_hook
);
1375 unbind_to (count
, Qnil
);
1377 /* If a C-g came in before, treat it as input now. */
1378 if (!NILP (Vquit_flag
))
1381 Vunread_command_events
= Fcons (make_number (quit_char
), Qnil
);
1386 /* Select the frame that the last event came from. Usually,
1387 switch-frame events will take care of this, but if some lisp
1388 code swallows a switch-frame event, we'll fix things up here.
1389 Is this a good idea? */
1390 if (FRAMEP (internal_last_event_frame
)
1391 && !EQ (internal_last_event_frame
, selected_frame
))
1392 Fselect_frame (internal_last_event_frame
, Qnil
);
1394 /* If it has changed current-menubar from previous value,
1395 really recompute the menubar from the value. */
1396 if (! NILP (Vlucid_menu_bar_dirty_flag
)
1397 && !NILP (Ffboundp (Qrecompute_lucid_menubar
)))
1398 call0 (Qrecompute_lucid_menubar
);
1400 before_command_key_count
= this_command_key_count
;
1401 before_command_echo_length
= echo_length ();
1403 Vthis_command
= Qnil
;
1404 real_this_command
= Qnil
;
1405 Vthis_original_command
= Qnil
;
1406 Vthis_command_keys_shift_translated
= Qnil
;
1408 /* Read next key sequence; i gets its length. */
1409 i
= read_key_sequence (keybuf
, sizeof keybuf
/ sizeof keybuf
[0],
1412 /* A filter may have run while we were reading the input. */
1413 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
1415 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1416 set_buffer_internal (XBUFFER (XWINDOW (selected_window
)->buffer
));
1420 /* Now we have read a key sequence of length I,
1421 or else I is 0 and we found end of file. */
1423 if (i
== 0) /* End of file -- happens only in */
1424 return Qnil
; /* a kbd macro, at the end. */
1425 /* -1 means read_key_sequence got a menu that was rejected.
1426 Just loop around and read another command. */
1430 this_command_key_count
= 0;
1431 this_command_key_count_reset
= 0;
1432 this_single_command_key_start
= 0;
1436 last_command_event
= keybuf
[i
- 1];
1438 /* If the previous command tried to force a specific window-start,
1439 forget about that, in case this command moves point far away
1440 from that position. But also throw away beg_unchanged and
1441 end_unchanged information in that case, so that redisplay will
1442 update the whole window properly. */
1443 if (!NILP (XWINDOW (selected_window
)->force_start
))
1446 XWINDOW (selected_window
)->force_start
= Qnil
;
1447 b
= XBUFFER (XWINDOW (selected_window
)->buffer
);
1448 BUF_BEG_UNCHANGED (b
) = BUF_END_UNCHANGED (b
) = 0;
1451 cmd
= read_key_sequence_cmd
;
1452 if (!NILP (Vexecuting_kbd_macro
))
1454 if (!NILP (Vquit_flag
))
1456 Vexecuting_kbd_macro
= Qt
;
1457 QUIT
; /* Make some noise. */
1458 /* Will return since macro now empty. */
1462 /* Do redisplay processing after this command except in special
1463 cases identified below. */
1464 prev_buffer
= current_buffer
;
1465 prev_modiff
= MODIFF
;
1466 last_point_position
= PT
;
1467 last_point_position_window
= selected_window
;
1468 XSETBUFFER (last_point_position_buffer
, prev_buffer
);
1470 /* By default, we adjust point to a boundary of a region that
1471 has such a property that should be treated intangible
1472 (e.g. composition, display). But, some commands will set
1473 this variable differently. */
1474 Vdisable_point_adjustment
= Qnil
;
1476 /* Process filters and timers may have messed with deactivate-mark.
1477 reset it before we execute the command. */
1478 Vdeactivate_mark
= Qnil
;
1480 /* Remap command through active keymaps */
1481 Vthis_original_command
= cmd
;
1485 if (cmd1
= Fcommand_remapping (cmd
, Qnil
, Qnil
), !NILP (cmd1
))
1489 /* Execute the command. */
1491 Vthis_command
= cmd
;
1492 real_this_command
= cmd
;
1493 /* Note that the value cell will never directly contain nil
1494 if the symbol is a local variable. */
1495 if (!NILP (Vpre_command_hook
) && !NILP (Vrun_hooks
))
1496 safe_run_hooks (Qpre_command_hook
);
1498 already_adjusted
= 0;
1500 if (NILP (Vthis_command
))
1502 /* nil means key is undefined. */
1503 Lisp_Object keys
= Fvector (i
, keybuf
);
1504 keys
= Fkey_description (keys
, Qnil
);
1506 message_with_string ("%s is undefined", keys
, 0);
1507 KVAR (current_kboard
, defining_kbd_macro
) = Qnil
;
1508 update_mode_lines
= 1;
1509 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
1513 /* Here for a command that isn't executed directly */
1515 #ifdef HAVE_WINDOW_SYSTEM
1516 int scount
= SPECPDL_INDEX ();
1518 if (display_hourglass_p
1519 && NILP (Vexecuting_kbd_macro
))
1521 record_unwind_protect (cancel_hourglass_unwind
, Qnil
);
1526 if (NILP (KVAR (current_kboard
, Vprefix_arg
))) /* FIXME: Why? --Stef */
1528 Fcommand_execute (Vthis_command
, Qnil
, Qnil
, Qnil
);
1530 #ifdef HAVE_WINDOW_SYSTEM
1531 /* Do not check display_hourglass_p here, because
1532 Fcommand_execute could change it, but we should cancel
1533 hourglass cursor anyway.
1534 But don't cancel the hourglass within a macro
1535 just because a command in the macro finishes. */
1536 if (NILP (Vexecuting_kbd_macro
))
1537 unbind_to (scount
, Qnil
);
1540 KVAR (current_kboard
, Vlast_prefix_arg
) = Vcurrent_prefix_arg
;
1542 /* Note that the value cell will never directly contain nil
1543 if the symbol is a local variable. */
1544 if (!NILP (Vpost_command_hook
) && !NILP (Vrun_hooks
))
1545 safe_run_hooks (Qpost_command_hook
);
1547 /* If displaying a message, resize the echo area window to fit
1548 that message's size exactly. */
1549 if (!NILP (echo_area_buffer
[0]))
1550 resize_echo_area_exactly ();
1552 if (!NILP (Vdeferred_action_list
))
1553 safe_run_hooks (Qdeferred_action_function
);
1555 /* If there is a prefix argument,
1556 1) We don't want Vlast_command to be ``universal-argument''
1557 (that would be dumb), so don't set Vlast_command,
1558 2) we want to leave echoing on so that the prefix will be
1559 echoed as part of this key sequence, so don't call
1561 3) we want to leave this_command_key_count non-zero, so that
1562 read_char will realize that it is re-reading a character, and
1563 not echo it a second time.
1565 If the command didn't actually create a prefix arg,
1566 but is merely a frame event that is transparent to prefix args,
1567 then the above doesn't apply. */
1568 if (NILP (KVAR (current_kboard
, Vprefix_arg
)) || CONSP (last_command_event
))
1570 KVAR (current_kboard
, Vlast_command
) = Vthis_command
;
1571 KVAR (current_kboard
, Vreal_last_command
) = real_this_command
;
1572 if (!CONSP (last_command_event
))
1573 KVAR (current_kboard
, Vlast_repeatable_command
) = real_this_command
;
1575 this_command_key_count
= 0;
1576 this_command_key_count_reset
= 0;
1577 this_single_command_key_start
= 0;
1580 if (!NILP (BVAR (current_buffer
, mark_active
))
1581 && !NILP (Vrun_hooks
))
1583 /* In Emacs 22, setting transient-mark-mode to `only' was a
1584 way of turning it on for just one command. This usage is
1585 obsolete, but support it anyway. */
1586 if (EQ (Vtransient_mark_mode
, Qidentity
))
1587 Vtransient_mark_mode
= Qnil
;
1588 else if (EQ (Vtransient_mark_mode
, Qonly
))
1589 Vtransient_mark_mode
= Qidentity
;
1591 if (!NILP (Vdeactivate_mark
))
1592 /* If `select-active-regions' is non-nil, this call to
1593 `deactivate-mark' also sets the PRIMARY selection. */
1594 call0 (Qdeactivate_mark
);
1597 /* Even if not deactivating the mark, set PRIMARY if
1598 `select-active-regions' is non-nil. */
1599 if (!NILP (Fwindow_system (Qnil
))
1600 /* Even if mark_active is non-nil, the actual buffer
1601 marker may not have been set yet (Bug#7044). */
1602 && XMARKER (BVAR (current_buffer
, mark
))->buffer
1603 && (EQ (Vselect_active_regions
, Qonly
)
1604 ? EQ (CAR_SAFE (Vtransient_mark_mode
), Qonly
)
1605 : (!NILP (Vselect_active_regions
)
1606 && !NILP (Vtransient_mark_mode
)))
1607 && !EQ (Vthis_command
, Qhandle_switch_frame
))
1610 XINT (Fmarker_position (BVAR (current_buffer
, mark
)));
1613 call2 (Qx_set_selection
, QPRIMARY
,
1614 make_buffer_string (beg
, end
, 0));
1616 call2 (Qx_set_selection
, QPRIMARY
,
1617 make_buffer_string (end
, beg
, 0));
1618 /* Don't set empty selections. */
1621 if (current_buffer
!= prev_buffer
|| MODIFF
!= prev_modiff
)
1622 call1 (Vrun_hooks
, intern ("activate-mark-hook"));
1625 Vsaved_region_selection
= Qnil
;
1630 if (current_buffer
== prev_buffer
1631 && last_point_position
!= PT
1632 && NILP (Vdisable_point_adjustment
)
1633 && NILP (Vglobal_disable_point_adjustment
))
1635 if (last_point_position
> BEGV
1636 && last_point_position
< ZV
1637 && (composition_adjust_point (last_point_position
,
1638 last_point_position
)
1639 != last_point_position
))
1640 /* The last point was temporarily set within a grapheme
1641 cluster to prevent automatic composition. To recover
1642 the automatic composition, we must update the
1644 windows_or_buffers_changed
++;
1645 if (!already_adjusted
)
1646 adjust_point_for_property (last_point_position
,
1647 MODIFF
!= prev_modiff
);
1650 /* Install chars successfully executed in kbd macro. */
1652 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
))
1653 && NILP (KVAR (current_kboard
, Vprefix_arg
)))
1654 finalize_kbd_macro_chars ();
1655 #if 0 /* This shouldn't be necessary anymore. --lorentey */
1657 any_kboard_state ();
1662 /* Adjust point to a boundary of a region that has such a property
1663 that should be treated intangible. For the moment, we check
1664 `composition', `display' and `invisible' properties.
1665 LAST_PT is the last position of point. */
1668 adjust_point_for_property (EMACS_INT last_pt
, int modified
)
1671 Lisp_Object val
, overlay
, tmp
;
1672 /* When called after buffer modification, we should temporarily
1673 suppress the point adjustment for automatic composition so that a
1674 user can keep inserting another character at point or keep
1675 deleting characters around point. */
1676 int check_composition
= ! modified
, check_display
= 1, check_invisible
= 1;
1677 EMACS_INT orig_pt
= PT
;
1679 /* FIXME: cycling is probably not necessary because these properties
1680 can't be usefully combined anyway. */
1681 while (check_composition
|| check_display
|| check_invisible
)
1683 /* FIXME: check `intangible'. */
1684 if (check_composition
1685 && PT
> BEGV
&& PT
< ZV
1686 && (beg
= composition_adjust_point (last_pt
, PT
)) != PT
)
1689 check_display
= check_invisible
= 1;
1691 check_composition
= 0;
1693 && PT
> BEGV
&& PT
< ZV
1694 && !NILP (val
= get_char_property_and_overlay
1695 (make_number (PT
), Qdisplay
, Qnil
, &overlay
))
1696 && display_prop_intangible_p (val
)
1697 && (!OVERLAYP (overlay
)
1698 ? get_property_and_range (PT
, Qdisplay
, &val
, &beg
, &end
, Qnil
)
1699 : (beg
= OVERLAY_POSITION (OVERLAY_START (overlay
)),
1700 end
= OVERLAY_POSITION (OVERLAY_END (overlay
))))
1701 && (beg
< PT
/* && end > PT <- It's always the case. */
1702 || (beg
<= PT
&& STRINGP (val
) && SCHARS (val
) == 0)))
1705 SET_PT (PT
< last_pt
1706 ? (STRINGP (val
) && SCHARS (val
) == 0 ? beg
- 1 : beg
)
1708 check_composition
= check_invisible
= 1;
1711 if (check_invisible
&& PT
> BEGV
&& PT
< ZV
)
1713 int inv
, ellipsis
= 0;
1716 /* Find boundaries `beg' and `end' of the invisible area, if any. */
1719 /* FIXME: We should stop if we find a spot between
1720 two runs of `invisible' where inserted text would
1721 be visible. This is important when we have two
1722 invisible boundaries that enclose an area: if the
1723 area is empty, we need this test in order to make
1724 it possible to place point in the middle rather
1725 than skip both boundaries. However, this code
1726 also stops anywhere in a non-sticky text-property,
1727 which breaks (e.g.) Org mode. */
1728 && (val
= get_pos_property (make_number (end
),
1730 TEXT_PROP_MEANS_INVISIBLE (val
))
1732 && !NILP (val
= get_char_property_and_overlay
1733 (make_number (end
), Qinvisible
, Qnil
, &overlay
))
1734 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1736 ellipsis
= ellipsis
|| inv
> 1
1737 || (OVERLAYP (overlay
)
1738 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1739 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1740 tmp
= Fnext_single_char_property_change
1741 (make_number (end
), Qinvisible
, Qnil
, Qnil
);
1742 end
= NATNUMP (tmp
) ? XFASTINT (tmp
) : ZV
;
1746 && (val
= get_pos_property (make_number (beg
),
1748 TEXT_PROP_MEANS_INVISIBLE (val
))
1750 && !NILP (val
= get_char_property_and_overlay
1751 (make_number (beg
- 1), Qinvisible
, Qnil
, &overlay
))
1752 && (inv
= TEXT_PROP_MEANS_INVISIBLE (val
)))
1754 ellipsis
= ellipsis
|| inv
> 1
1755 || (OVERLAYP (overlay
)
1756 && (!NILP (Foverlay_get (overlay
, Qafter_string
))
1757 || !NILP (Foverlay_get (overlay
, Qbefore_string
))));
1758 tmp
= Fprevious_single_char_property_change
1759 (make_number (beg
), Qinvisible
, Qnil
, Qnil
);
1760 beg
= NATNUMP (tmp
) ? XFASTINT (tmp
) : BEGV
;
1763 /* Move away from the inside area. */
1764 if (beg
< PT
&& end
> PT
)
1766 SET_PT ((orig_pt
== PT
&& (last_pt
< beg
|| last_pt
> end
))
1767 /* We haven't moved yet (so we don't need to fear
1768 infinite-looping) and we were outside the range
1769 before (so either end of the range still corresponds
1770 to a move in the right direction): pretend we moved
1771 less than we actually did, so that we still have
1772 more freedom below in choosing which end of the range
1774 ? (orig_pt
= -1, PT
< last_pt
? end
: beg
)
1775 /* We either have moved already or the last point
1776 was already in the range: we don't get to choose
1777 which end of the range we have to go to. */
1778 : (PT
< last_pt
? beg
: end
));
1779 check_composition
= check_display
= 1;
1781 #if 0 /* This assertion isn't correct, because SET_PT may end up setting
1782 the point to something other than its argument, due to
1783 point-motion hooks, intangibility, etc. */
1784 xassert (PT
== beg
|| PT
== end
);
1787 /* Pretend the area doesn't exist if the buffer is not
1789 if (!modified
&& !ellipsis
&& beg
< end
)
1791 if (last_pt
== beg
&& PT
== end
&& end
< ZV
)
1792 (check_composition
= check_display
= 1, SET_PT (end
+ 1));
1793 else if (last_pt
== end
&& PT
== beg
&& beg
> BEGV
)
1794 (check_composition
= check_display
= 1, SET_PT (beg
- 1));
1795 else if (PT
== ((PT
< last_pt
) ? beg
: end
))
1796 /* We've already moved as far as we can. Trying to go
1797 to the other end would mean moving backwards and thus
1798 could lead to an infinite loop. */
1800 else if (val
= get_pos_property (make_number (PT
),
1802 TEXT_PROP_MEANS_INVISIBLE (val
)
1803 && (val
= get_pos_property
1804 (make_number (PT
== beg
? end
: beg
),
1806 !TEXT_PROP_MEANS_INVISIBLE (val
)))
1807 (check_composition
= check_display
= 1,
1808 SET_PT (PT
== beg
? end
: beg
));
1811 check_invisible
= 0;
1815 /* Subroutine for safe_run_hooks: run the hook HOOK. */
1818 safe_run_hooks_1 (void)
1820 if (NILP (Vrun_hooks
))
1822 return call1 (Vrun_hooks
, Vinhibit_quit
);
1825 /* Subroutine for safe_run_hooks: handle an error by clearing out the hook. */
1828 safe_run_hooks_error (Lisp_Object data
)
1830 Lisp_Object args
[3];
1831 args
[0] = build_string ("Error in %s: %s");
1832 args
[1] = Vinhibit_quit
;
1835 return Fset (Vinhibit_quit
, Qnil
);
1838 /* If we get an error while running the hook, cause the hook variable
1839 to be nil. Also inhibit quits, so that C-g won't cause the hook
1840 to mysteriously evaporate. */
1843 safe_run_hooks (Lisp_Object hook
)
1845 int count
= SPECPDL_INDEX ();
1846 specbind (Qinhibit_quit
, hook
);
1848 internal_condition_case (safe_run_hooks_1
, Qt
, safe_run_hooks_error
);
1850 unbind_to (count
, Qnil
);
1854 /* Nonzero means polling for input is temporarily suppressed. */
1856 int poll_suppress_count
;
1858 /* Asynchronous timer for polling. */
1860 struct atimer
*poll_timer
;
1863 #ifdef POLL_FOR_INPUT
1865 /* Poll for input, so that we catch a C-g if it comes in. This
1866 function is called from x_make_frame_visible, see comment
1870 poll_for_input_1 (void)
1872 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
1873 doing anything dangerous. */
1877 if (interrupt_input_blocked
== 0
1878 && !waiting_for_input
)
1879 read_avail_input (0);
1885 /* Timer callback function for poll_timer. TIMER is equal to
1889 poll_for_input (struct atimer
*timer
)
1891 if (poll_suppress_count
== 0)
1894 interrupt_input_pending
= 1;
1895 pending_signals
= 1;
1897 poll_for_input_1 ();
1902 #endif /* POLL_FOR_INPUT */
1904 /* Begin signals to poll for input, if they are appropriate.
1905 This function is called unconditionally from various places. */
1908 start_polling (void)
1910 #ifdef POLL_FOR_INPUT
1911 /* XXX This condition was (read_socket_hook && !interrupt_input),
1912 but read_socket_hook is not global anymore. Let's pretend that
1914 if (!interrupt_input
)
1916 /* Turn alarm handling on unconditionally. It might have
1917 been turned off in process.c. */
1918 turn_on_atimers (1);
1920 /* If poll timer doesn't exist, are we need one with
1921 a different interval, start a new one. */
1922 if (poll_timer
== NULL
1923 || EMACS_SECS (poll_timer
->interval
) != polling_period
)
1925 EMACS_TIME interval
;
1928 cancel_atimer (poll_timer
);
1930 EMACS_SET_SECS_USECS (interval
, polling_period
, 0);
1931 poll_timer
= start_atimer (ATIMER_CONTINUOUS
, interval
,
1932 poll_for_input
, NULL
);
1935 /* Let the timer's callback function poll for input
1936 if this becomes zero. */
1937 --poll_suppress_count
;
1942 /* Nonzero if we are using polling to handle input asynchronously. */
1945 input_polling_used (void)
1947 #ifdef POLL_FOR_INPUT
1948 /* XXX This condition was (read_socket_hook && !interrupt_input),
1949 but read_socket_hook is not global anymore. Let's pretend that
1951 return !interrupt_input
;
1957 /* Turn off polling. */
1962 #ifdef POLL_FOR_INPUT
1963 /* XXX This condition was (read_socket_hook && !interrupt_input),
1964 but read_socket_hook is not global anymore. Let's pretend that
1966 if (!interrupt_input
)
1967 ++poll_suppress_count
;
1971 /* Set the value of poll_suppress_count to COUNT
1972 and start or stop polling accordingly. */
1975 set_poll_suppress_count (int count
)
1977 #ifdef POLL_FOR_INPUT
1978 if (count
== 0 && poll_suppress_count
!= 0)
1980 poll_suppress_count
= 1;
1983 else if (count
!= 0 && poll_suppress_count
== 0)
1987 poll_suppress_count
= count
;
1991 /* Bind polling_period to a value at least N.
1992 But don't decrease it. */
1995 bind_polling_period (int n
)
1997 #ifdef POLL_FOR_INPUT
1998 int new = polling_period
;
2003 stop_other_atimers (poll_timer
);
2005 specbind (Qpolling_period
, make_number (new));
2006 /* Start a new alarm with the new period. */
2011 /* Apply the control modifier to CHARACTER. */
2014 make_ctrl_char (int c
)
2016 /* Save the upper bits here. */
2017 int upper
= c
& ~0177;
2019 if (! ASCII_BYTE_P (c
))
2020 return c
|= ctrl_modifier
;
2024 /* Everything in the columns containing the upper-case letters
2025 denotes a control character. */
2026 if (c
>= 0100 && c
< 0140)
2030 /* Set the shift modifier for a control char
2031 made from a shifted letter. But only for letters! */
2032 if (oc
>= 'A' && oc
<= 'Z')
2033 c
|= shift_modifier
;
2036 /* The lower-case letters denote control characters too. */
2037 else if (c
>= 'a' && c
<= 'z')
2040 /* Include the bits for control and shift
2041 only if the basic ASCII code can't indicate them. */
2045 /* Replace the high bits. */
2046 c
|= (upper
& ~ctrl_modifier
);
2051 /* Display the help-echo property of the character after the mouse pointer.
2052 Either show it in the echo area, or call show-help-function to display
2053 it by other means (maybe in a tooltip).
2055 If HELP is nil, that means clear the previous help echo.
2057 If HELP is a string, display that string. If HELP is a function,
2058 call it with OBJECT and POS as arguments; the function should
2059 return a help string or nil for none. For all other types of HELP,
2060 evaluate it to obtain a string.
2062 WINDOW is the window in which the help was generated, if any.
2063 It is nil if not in a window.
2065 If OBJECT is a buffer, POS is the position in the buffer where the
2066 `help-echo' text property was found.
2068 If OBJECT is an overlay, that overlay has a `help-echo' property,
2069 and POS is the position in the overlay's buffer under the mouse.
2071 If OBJECT is a string (an overlay string or a string displayed with
2072 the `display' property). POS is the position in that string under
2075 OK_TO_OVERWRITE_KEYSTROKE_ECHO non-zero means it's okay if the help
2076 echo overwrites a keystroke echo currently displayed in the echo
2079 Note: this function may only be called with HELP nil or a string
2080 from X code running asynchronously. */
2083 show_help_echo (Lisp_Object help
, Lisp_Object window
, Lisp_Object object
,
2084 Lisp_Object pos
, int ok_to_overwrite_keystroke_echo
)
2086 if (!NILP (help
) && !STRINGP (help
))
2088 if (FUNCTIONP (help
))
2090 Lisp_Object args
[4];
2095 help
= safe_call (4, args
);
2098 help
= safe_eval (help
);
2100 if (!STRINGP (help
))
2104 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
2105 if (!noninteractive
&& STRINGP (help
))
2107 /* The mouse-fixup-help-message Lisp function can call
2108 mouse_position_hook, which resets the mouse_moved flags.
2109 This causes trouble if we are trying to read a mouse motion
2110 event (i.e., if we are inside a `track-mouse' form), so we
2111 restore the mouse_moved flag. */
2112 FRAME_PTR f
= NILP (do_mouse_tracking
) ? NULL
: some_mouse_moved ();
2113 help
= call1 (Qmouse_fixup_help_message
, help
);
2119 if (STRINGP (help
) || NILP (help
))
2121 if (!NILP (Vshow_help_function
))
2122 call1 (Vshow_help_function
, help
);
2123 help_echo_showing_p
= STRINGP (help
);
2129 /* Input of single characters from keyboard */
2131 Lisp_Object
print_help (Lisp_Object object
);
2132 static Lisp_Object
kbd_buffer_get_event (KBOARD
**kbp
, int *used_mouse_menu
,
2133 struct timeval
*end_time
);
2134 static void record_char (Lisp_Object c
);
2136 static Lisp_Object help_form_saved_window_configs
;
2138 read_char_help_form_unwind (Lisp_Object arg
)
2140 Lisp_Object window_config
= XCAR (help_form_saved_window_configs
);
2141 help_form_saved_window_configs
= XCDR (help_form_saved_window_configs
);
2142 if (!NILP (window_config
))
2143 Fset_window_configuration (window_config
);
2147 #define STOP_POLLING \
2148 do { if (! polling_stopped_here) stop_polling (); \
2149 polling_stopped_here = 1; } while (0)
2151 #define RESUME_POLLING \
2152 do { if (polling_stopped_here) start_polling (); \
2153 polling_stopped_here = 0; } while (0)
2155 /* read a character from the keyboard; call the redisplay if needed */
2156 /* commandflag 0 means do not do auto-saving, but do do redisplay.
2157 -1 means do not do redisplay, but do do autosaving.
2160 /* The arguments MAPS and NMAPS are for menu prompting.
2161 MAPS is an array of keymaps; NMAPS is the length of MAPS.
2163 PREV_EVENT is the previous input event, or nil if we are reading
2164 the first event of a key sequence (or not reading a key sequence).
2165 If PREV_EVENT is t, that is a "magic" value that says
2166 not to run input methods, but in other respects to act as if
2167 not reading a key sequence.
2169 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
2170 if we used a mouse menu to read the input, or zero otherwise. If
2171 USED_MOUSE_MENU is null, we don't dereference it.
2173 Value is -2 when we find input on another keyboard. A second call
2174 to read_char will read it.
2176 If END_TIME is non-null, it is a pointer to an EMACS_TIME
2177 specifying the maximum time to wait until. If no input arrives by
2178 that time, stop waiting and return nil.
2180 Value is t if we showed a menu and the user rejected it. */
2183 read_char (int commandflag
, int nmaps
, Lisp_Object
*maps
, Lisp_Object prev_event
,
2184 int *used_mouse_menu
, struct timeval
*end_time
)
2186 volatile Lisp_Object c
;
2188 jmp_buf local_getcjmp
;
2190 volatile int key_already_recorded
= 0;
2191 Lisp_Object tem
, save
;
2192 volatile Lisp_Object previous_echo_area_message
;
2193 volatile Lisp_Object also_record
;
2194 volatile int reread
;
2195 struct gcpro gcpro1
, gcpro2
;
2196 int polling_stopped_here
= 0;
2197 struct kboard
*orig_kboard
= current_kboard
;
2201 #if 0 /* This was commented out as part of fixing echo for C-u left. */
2202 before_command_key_count
= this_command_key_count
;
2203 before_command_echo_length
= echo_length ();
2206 previous_echo_area_message
= Qnil
;
2208 GCPRO2 (c
, previous_echo_area_message
);
2213 if (CONSP (Vunread_post_input_method_events
))
2215 c
= XCAR (Vunread_post_input_method_events
);
2216 Vunread_post_input_method_events
2217 = XCDR (Vunread_post_input_method_events
);
2219 /* Undo what read_char_x_menu_prompt did when it unread
2220 additional keys returned by Fx_popup_menu. */
2222 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2230 if (unread_command_char
!= -1)
2232 XSETINT (c
, unread_command_char
);
2233 unread_command_char
= -1;
2239 if (CONSP (Vunread_command_events
))
2241 int was_disabled
= 0;
2243 c
= XCAR (Vunread_command_events
);
2244 Vunread_command_events
= XCDR (Vunread_command_events
);
2248 /* Undo what sit-for did when it unread additional keys
2249 inside universal-argument. */
2252 && EQ (XCAR (c
), Qt
))
2258 /* Undo what read_char_x_menu_prompt did when it unread
2259 additional keys returned by Fx_popup_menu. */
2261 && EQ (XCDR (c
), Qdisabled
)
2262 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
))))
2268 /* If the queued event is something that used the mouse,
2269 set used_mouse_menu accordingly. */
2271 /* Also check was_disabled so last-nonmenu-event won't return
2272 a bad value when submenus are involved. (Bug#447) */
2273 && (EQ (c
, Qtool_bar
) || EQ (c
, Qmenu_bar
) || was_disabled
))
2274 *used_mouse_menu
= 1;
2276 goto reread_for_input_method
;
2279 if (CONSP (Vunread_input_method_events
))
2281 c
= XCAR (Vunread_input_method_events
);
2282 Vunread_input_method_events
= XCDR (Vunread_input_method_events
);
2284 /* Undo what read_char_x_menu_prompt did when it unread
2285 additional keys returned by Fx_popup_menu. */
2287 && (SYMBOLP (XCAR (c
)) || INTEGERP (XCAR (c
)))
2291 goto reread_for_input_method
;
2294 this_command_key_count_reset
= 0;
2296 if (!NILP (Vexecuting_kbd_macro
))
2298 /* We set this to Qmacro; since that's not a frame, nobody will
2299 try to switch frames on us, and the selected window will
2302 Since this event came from a macro, it would be misleading to
2303 leave internal_last_event_frame set to wherever the last
2304 real event came from. Normally, a switch-frame event selects
2305 internal_last_event_frame after each command is read, but
2306 events read from a macro should never cause a new frame to be
2308 Vlast_event_frame
= internal_last_event_frame
= Qmacro
;
2310 /* Exit the macro if we are at the end.
2311 Also, some things replace the macro with t
2312 to force an early exit. */
2313 if (EQ (Vexecuting_kbd_macro
, Qt
)
2314 || executing_kbd_macro_index
>= XFASTINT (Flength (Vexecuting_kbd_macro
)))
2320 c
= Faref (Vexecuting_kbd_macro
, make_number (executing_kbd_macro_index
));
2321 if (STRINGP (Vexecuting_kbd_macro
)
2322 && (XINT (c
) & 0x80) && (XUINT (c
) <= 0xff))
2323 XSETFASTINT (c
, CHAR_META
| (XINT (c
) & ~0x80));
2325 executing_kbd_macro_index
++;
2330 if (!NILP (unread_switch_frame
))
2332 c
= unread_switch_frame
;
2333 unread_switch_frame
= Qnil
;
2335 /* This event should make it into this_command_keys, and get echoed
2336 again, so we do not set `reread'. */
2340 /* if redisplay was requested */
2341 if (commandflag
>= 0)
2343 int echo_current
= EQ (echo_message_buffer
, echo_area_buffer
[0]);
2345 /* If there is pending input, process any events which are not
2346 user-visible, such as X selection_request events. */
2348 || detect_input_pending_run_timers (0))
2349 swallow_events (0); /* may clear input_pending */
2351 /* Redisplay if no pending input. */
2352 while (!input_pending
)
2354 if (help_echo_showing_p
&& !EQ (selected_window
, minibuf_window
))
2355 redisplay_preserve_echo_area (5);
2360 /* Normal case: no input arrived during redisplay. */
2363 /* Input arrived and pre-empted redisplay.
2364 Process any events which are not user-visible. */
2366 /* If that cleared input_pending, try again to redisplay. */
2369 /* Prevent the redisplay we just did
2370 from messing up echoing of the input after the prompt. */
2371 if (commandflag
== 0 && echo_current
)
2372 echo_message_buffer
= echo_area_buffer
[0];
2376 /* Message turns off echoing unless more keystrokes turn it on again.
2378 The code in 20.x for the condition was
2380 1. echo_area_glyphs && *echo_area_glyphs
2381 2. && echo_area_glyphs != current_kboard->echobuf
2382 3. && ok_to_echo_at_next_pause != echo_area_glyphs
2384 (1) means there's a current message displayed
2386 (2) means it's not the message from echoing from the current
2389 (3) There's only one place in 20.x where ok_to_echo_at_next_pause
2390 is set to a non-null value. This is done in read_char and it is
2391 set to echo_area_glyphs after a call to echo_char. That means
2392 ok_to_echo_at_next_pause is either null or
2393 current_kboard->echobuf with the appropriate current_kboard at
2396 So, condition (3) means in clear text ok_to_echo_at_next_pause
2397 must be either null, or the current message isn't from echoing at
2398 all, or it's from echoing from a different kboard than the
2401 if (/* There currently is something in the echo area. */
2402 !NILP (echo_area_buffer
[0])
2403 && (/* And it's either not from echoing. */
2404 !EQ (echo_area_buffer
[0], echo_message_buffer
)
2405 /* Or it's an echo from a different kboard. */
2406 || echo_kboard
!= current_kboard
2407 /* Or we explicitly allow overwriting whatever there is. */
2408 || ok_to_echo_at_next_pause
== NULL
))
2413 /* Try reading a character via menu prompting in the minibuf.
2414 Try this before the sit-for, because the sit-for
2415 would do the wrong thing if we are supposed to do
2416 menu prompting. If EVENT_HAS_PARAMETERS then we are reading
2417 after a mouse event so don't try a minibuf menu. */
2419 if (nmaps
> 0 && INTERACTIVE
2420 && !NILP (prev_event
) && ! EVENT_HAS_PARAMETERS (prev_event
)
2421 /* Don't bring up a menu if we already have another event. */
2422 && NILP (Vunread_command_events
)
2423 && unread_command_char
< 0
2424 && !detect_input_pending_run_timers (0))
2426 c
= read_char_minibuf_menu_prompt (commandflag
, nmaps
, maps
);
2428 if (INTEGERP (c
) && XINT (c
) == -2)
2429 return c
; /* wrong_kboard_jmpbuf */
2433 key_already_recorded
= 1;
2438 /* Make a longjmp point for quits to use, but don't alter getcjmp just yet.
2439 We will do that below, temporarily for short sections of code,
2440 when appropriate. local_getcjmp must be in effect
2441 around any call to sit_for or kbd_buffer_get_event;
2442 it *must not* be in effect when we call redisplay. */
2444 jmpcount
= SPECPDL_INDEX ();
2445 if (_setjmp (local_getcjmp
))
2447 /* Handle quits while reading the keyboard. */
2448 /* We must have saved the outer value of getcjmp here,
2449 so restore it now. */
2450 restore_getcjmp (save_jump
);
2451 unbind_to (jmpcount
, Qnil
);
2452 XSETINT (c
, quit_char
);
2453 internal_last_event_frame
= selected_frame
;
2454 Vlast_event_frame
= internal_last_event_frame
;
2455 /* If we report the quit char as an event,
2456 don't do so more than once. */
2457 if (!NILP (Vinhibit_quit
))
2461 KBOARD
*kb
= FRAME_KBOARD (XFRAME (selected_frame
));
2462 if (kb
!= current_kboard
)
2464 Lisp_Object last
= KVAR (kb
, kbd_queue
);
2465 /* We shouldn't get here if we were in single-kboard mode! */
2470 while (CONSP (XCDR (last
)))
2472 if (!NILP (XCDR (last
)))
2476 KVAR (kb
, kbd_queue
) = Fcons (c
, Qnil
);
2478 XSETCDR (last
, Fcons (c
, Qnil
));
2479 kb
->kbd_queue_has_data
= 1;
2480 current_kboard
= kb
;
2481 /* This is going to exit from read_char
2482 so we had better get rid of this frame's stuff. */
2484 return make_number (-2); /* wrong_kboard_jmpbuf */
2490 /* Start idle timers if no time limit is supplied. We don't do it
2491 if a time limit is supplied to avoid an infinite recursion in the
2492 situation where an idle timer calls `sit-for'. */
2495 timer_start_idle ();
2497 /* If in middle of key sequence and minibuffer not active,
2498 start echoing if enough time elapses. */
2500 if (minibuf_level
== 0
2502 && !current_kboard
->immediate_echo
2503 && this_command_key_count
> 0
2505 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
2506 && NILP (Fzerop (Vecho_keystrokes
))
2507 && (/* No message. */
2508 NILP (echo_area_buffer
[0])
2509 /* Or empty message. */
2510 || (BUF_BEG (XBUFFER (echo_area_buffer
[0]))
2511 == BUF_Z (XBUFFER (echo_area_buffer
[0])))
2512 /* Or already echoing from same kboard. */
2513 || (echo_kboard
&& ok_to_echo_at_next_pause
== echo_kboard
)
2514 /* Or not echoing before and echoing allowed. */
2515 || (!echo_kboard
&& ok_to_echo_at_next_pause
)))
2517 /* After a mouse event, start echoing right away.
2518 This is because we are probably about to display a menu,
2519 and we don't want to delay before doing so. */
2520 if (EVENT_HAS_PARAMETERS (prev_event
))
2526 save_getcjmp (save_jump
);
2527 restore_getcjmp (local_getcjmp
);
2528 tem0
= sit_for (Vecho_keystrokes
, 1, 1);
2529 restore_getcjmp (save_jump
);
2531 && ! CONSP (Vunread_command_events
))
2536 /* Maybe auto save due to number of keystrokes. */
2538 if (commandflag
!= 0
2539 && auto_save_interval
> 0
2540 && num_nonmacro_input_events
- last_auto_save
> max (auto_save_interval
, 20)
2541 && !detect_input_pending_run_timers (0))
2543 Fdo_auto_save (Qnil
, Qnil
);
2544 /* Hooks can actually change some buffers in auto save. */
2548 /* Try reading using an X menu.
2549 This is never confused with reading using the minibuf
2550 because the recursive call of read_char in read_char_minibuf_menu_prompt
2551 does not pass on any keymaps. */
2553 if (nmaps
> 0 && INTERACTIVE
2554 && !NILP (prev_event
)
2555 && EVENT_HAS_PARAMETERS (prev_event
)
2556 && !EQ (XCAR (prev_event
), Qmenu_bar
)
2557 && !EQ (XCAR (prev_event
), Qtool_bar
)
2558 /* Don't bring up a menu if we already have another event. */
2559 && NILP (Vunread_command_events
)
2560 && unread_command_char
< 0)
2562 c
= read_char_x_menu_prompt (nmaps
, maps
, prev_event
, used_mouse_menu
);
2564 /* Now that we have read an event, Emacs is not idle. */
2571 /* Maybe autosave and/or garbage collect due to idleness. */
2573 if (INTERACTIVE
&& NILP (c
))
2576 EMACS_INT buffer_size
;
2578 /* Slow down auto saves logarithmically in size of current buffer,
2579 and garbage collect while we're at it. */
2580 if (! MINI_WINDOW_P (XWINDOW (selected_window
)))
2581 last_non_minibuf_size
= Z
- BEG
;
2582 buffer_size
= (last_non_minibuf_size
>> 8) + 1;
2584 while (buffer_size
> 64)
2585 delay_level
++, buffer_size
-= buffer_size
>> 2;
2586 if (delay_level
< 4) delay_level
= 4;
2587 /* delay_level is 4 for files under around 50k, 7 at 100k,
2588 9 at 200k, 11 at 300k, and 12 at 500k. It is 15 at 1 meg. */
2590 /* Auto save if enough time goes by without input. */
2591 if (commandflag
!= 0
2592 && num_nonmacro_input_events
> last_auto_save
2593 && INTEGERP (Vauto_save_timeout
)
2594 && XINT (Vauto_save_timeout
) > 0)
2597 int timeout
= delay_level
* XFASTINT (Vauto_save_timeout
) / 4;
2599 save_getcjmp (save_jump
);
2600 restore_getcjmp (local_getcjmp
);
2601 tem0
= sit_for (make_number (timeout
), 1, 1);
2602 restore_getcjmp (save_jump
);
2605 && ! CONSP (Vunread_command_events
))
2607 Fdo_auto_save (Qnil
, Qnil
);
2609 /* If we have auto-saved and there is still no input
2610 available, garbage collect if there has been enough
2611 consing going on to make it worthwhile. */
2612 if (!detect_input_pending_run_timers (0)
2613 && consing_since_gc
> gc_cons_threshold
/ 2)
2614 Fgarbage_collect ();
2621 /* Notify the caller if an autosave hook, or a timer, sentinel or
2622 filter in the sit_for calls above have changed the current
2623 kboard. This could happen if they use the minibuffer or start a
2624 recursive edit, like the fancy splash screen in server.el's
2625 filter. If this longjmp wasn't here, read_key_sequence would
2626 interpret the next key sequence using the wrong translation
2627 tables and function keymaps. */
2628 if (NILP (c
) && current_kboard
!= orig_kboard
)
2631 return make_number (-2); /* wrong_kboard_jmpbuf */
2634 /* If this has become non-nil here, it has been set by a timer
2635 or sentinel or filter. */
2636 if (CONSP (Vunread_command_events
))
2638 c
= XCAR (Vunread_command_events
);
2639 Vunread_command_events
= XCDR (Vunread_command_events
);
2642 /* Read something from current KBOARD's side queue, if possible. */
2646 if (current_kboard
->kbd_queue_has_data
)
2648 if (!CONSP (KVAR (current_kboard
, kbd_queue
)))
2650 c
= XCAR (KVAR (current_kboard
, kbd_queue
));
2651 KVAR (current_kboard
, kbd_queue
)
2652 = XCDR (KVAR (current_kboard
, kbd_queue
));
2653 if (NILP (KVAR (current_kboard
, kbd_queue
)))
2654 current_kboard
->kbd_queue_has_data
= 0;
2655 input_pending
= readable_events (0);
2656 if (EVENT_HAS_PARAMETERS (c
)
2657 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qswitch_frame
))
2658 internal_last_event_frame
= XCAR (XCDR (c
));
2659 Vlast_event_frame
= internal_last_event_frame
;
2663 /* If current_kboard's side queue is empty check the other kboards.
2664 If one of them has data that we have not yet seen here,
2665 switch to it and process the data waiting for it.
2667 Note: if the events queued up for another kboard
2668 have already been seen here, and therefore are not a complete command,
2669 the kbd_queue_has_data field is 0, so we skip that kboard here.
2670 That's to avoid an infinite loop switching between kboards here. */
2671 if (NILP (c
) && !single_kboard
)
2674 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
2675 if (kb
->kbd_queue_has_data
)
2677 current_kboard
= kb
;
2678 /* This is going to exit from read_char
2679 so we had better get rid of this frame's stuff. */
2681 return make_number (-2); /* wrong_kboard_jmpbuf */
2689 /* Finally, we read from the main queue,
2690 and if that gives us something we can't use yet, we put it on the
2691 appropriate side queue and try again. */
2700 EMACS_GET_TIME (now
);
2701 if (EMACS_TIME_GE (now
, *end_time
))
2705 /* Actually read a character, waiting if necessary. */
2706 save_getcjmp (save_jump
);
2707 restore_getcjmp (local_getcjmp
);
2709 timer_start_idle ();
2710 c
= kbd_buffer_get_event (&kb
, used_mouse_menu
, end_time
);
2711 restore_getcjmp (save_jump
);
2713 if (! NILP (c
) && (kb
!= current_kboard
))
2715 Lisp_Object last
= KVAR (kb
, kbd_queue
);
2718 while (CONSP (XCDR (last
)))
2720 if (!NILP (XCDR (last
)))
2724 KVAR (kb
, kbd_queue
) = Fcons (c
, Qnil
);
2726 XSETCDR (last
, Fcons (c
, Qnil
));
2727 kb
->kbd_queue_has_data
= 1;
2731 current_kboard
= kb
;
2732 /* This is going to exit from read_char
2733 so we had better get rid of this frame's stuff. */
2735 return make_number (-2);
2739 /* Terminate Emacs in batch mode if at eof. */
2740 if (noninteractive
&& INTEGERP (c
) && XINT (c
) < 0)
2741 Fkill_emacs (make_number (1));
2745 /* Add in any extra modifiers, where appropriate. */
2746 if ((extra_keyboard_modifiers
& CHAR_CTL
)
2747 || ((extra_keyboard_modifiers
& 0177) < ' '
2748 && (extra_keyboard_modifiers
& 0177) != 0))
2749 XSETINT (c
, make_ctrl_char (XINT (c
)));
2751 /* Transfer any other modifier bits directly from
2752 extra_keyboard_modifiers to c. Ignore the actual character code
2753 in the low 16 bits of extra_keyboard_modifiers. */
2754 XSETINT (c
, XINT (c
) | (extra_keyboard_modifiers
& ~0xff7f & ~CHAR_CTL
));
2765 if (commandflag
>= 0
2766 && !input_pending
&& !detect_input_pending_run_timers (0))
2774 /* Buffer switch events are only for internal wakeups
2775 so don't show them to the user.
2776 Also, don't record a key if we already did. */
2777 if (BUFFERP (c
) || key_already_recorded
)
2780 /* Process special events within read_char
2781 and loop around to read another event. */
2784 tem
= access_keymap (get_keymap (Vspecial_event_map
, 0, 1), c
, 0, 0, 1);
2789 struct buffer
*prev_buffer
= current_buffer
;
2790 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2791 int was_locked
= single_kboard
;
2792 int count
= SPECPDL_INDEX ();
2793 record_single_kboard_state ();
2796 last_input_event
= c
;
2797 Fcommand_execute (tem
, Qnil
, Fvector (1, &last_input_event
), Qt
);
2799 if (CONSP (c
) && EQ (XCAR (c
), Qselect_window
) && !end_time
)
2800 /* We stopped being idle for this event; undo that. This
2801 prevents automatic window selection (under
2802 mouse_autoselect_window from acting as a real input event, for
2803 example banishing the mouse under mouse-avoidance-mode. */
2804 timer_resume_idle ();
2806 #if 0 /* This shouldn't be necessary anymore. --lorentey */
2807 /* Resume allowing input from any kboard, if that was true before. */
2809 any_kboard_state ();
2810 unbind_to (count
, Qnil
);
2813 if (current_buffer
!= prev_buffer
)
2815 /* The command may have changed the keymaps. Pretend there
2816 is input in another keyboard and return. This will
2817 recalculate keymaps. */
2818 c
= make_number (-2);
2825 /* Handle things that only apply to characters. */
2828 /* If kbd_buffer_get_event gave us an EOF, return that. */
2832 if ((STRINGP (KVAR (current_kboard
, Vkeyboard_translate_table
))
2833 && SCHARS (KVAR (current_kboard
, Vkeyboard_translate_table
)) > (unsigned) XFASTINT (c
))
2834 || (VECTORP (KVAR (current_kboard
, Vkeyboard_translate_table
))
2835 && XVECTOR (KVAR (current_kboard
, Vkeyboard_translate_table
))->size
> (unsigned) XFASTINT (c
))
2836 || (CHAR_TABLE_P (KVAR (current_kboard
, Vkeyboard_translate_table
))
2840 d
= Faref (KVAR (current_kboard
, Vkeyboard_translate_table
), c
);
2841 /* nil in keyboard-translate-table means no translation. */
2847 /* If this event is a mouse click in the menu bar,
2848 return just menu-bar for now. Modify the mouse click event
2849 so we won't do this twice, then queue it up. */
2850 if (EVENT_HAS_PARAMETERS (c
)
2852 && CONSP (EVENT_START (c
))
2853 && CONSP (XCDR (EVENT_START (c
))))
2857 posn
= POSN_POSN (EVENT_START (c
));
2858 /* Handle menu-bar events:
2859 insert the dummy prefix event `menu-bar'. */
2860 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
2862 /* Change menu-bar to (menu-bar) as the event "position". */
2863 POSN_SET_POSN (EVENT_START (c
), Fcons (posn
, Qnil
));
2866 Vunread_command_events
= Fcons (c
, Vunread_command_events
);
2871 /* Store these characters into recent_keys, the dribble file if any,
2872 and the keyboard macro being defined, if any. */
2874 if (! NILP (also_record
))
2875 record_char (also_record
);
2877 /* Wipe the echo area.
2878 But first, if we are about to use an input method,
2879 save the echo area contents for it to refer to. */
2881 && ! NILP (Vinput_method_function
)
2882 && (unsigned) XINT (c
) >= ' '
2883 && (unsigned) XINT (c
) != 127
2884 && (unsigned) XINT (c
) < 256)
2886 previous_echo_area_message
= Fcurrent_message ();
2887 Vinput_method_previous_message
= previous_echo_area_message
;
2890 /* Now wipe the echo area, except for help events which do their
2891 own stuff with the echo area. */
2893 || (!(EQ (Qhelp_echo
, XCAR (c
)))
2894 && !(EQ (Qswitch_frame
, XCAR (c
)))))
2896 if (!NILP (echo_area_buffer
[0]))
2897 safe_run_hooks (Qecho_area_clear_hook
);
2898 clear_message (1, 0);
2901 reread_for_input_method
:
2903 /* Pass this to the input method, if appropriate. */
2905 && ! NILP (Vinput_method_function
)
2906 /* Don't run the input method within a key sequence,
2907 after the first event of the key sequence. */
2908 && NILP (prev_event
)
2909 && (unsigned) XINT (c
) >= ' '
2910 && (unsigned) XINT (c
) != 127
2911 && (unsigned) XINT (c
) < 256)
2914 int key_count
, key_count_reset
;
2915 struct gcpro inner_gcpro1
;
2916 int count
= SPECPDL_INDEX ();
2918 /* Save the echo status. */
2919 int saved_immediate_echo
= current_kboard
->immediate_echo
;
2920 struct kboard
*saved_ok_to_echo
= ok_to_echo_at_next_pause
;
2921 Lisp_Object saved_echo_string
= KVAR (current_kboard
, echo_string
);
2922 int saved_echo_after_prompt
= current_kboard
->echo_after_prompt
;
2925 if (before_command_restore_flag
)
2927 this_command_key_count
= before_command_key_count_1
;
2928 if (this_command_key_count
< this_single_command_key_start
)
2929 this_single_command_key_start
= this_command_key_count
;
2930 echo_truncate (before_command_echo_length_1
);
2931 before_command_restore_flag
= 0;
2935 /* Save the this_command_keys status. */
2936 key_count
= this_command_key_count
;
2937 key_count_reset
= this_command_key_count_reset
;
2940 keys
= Fcopy_sequence (this_command_keys
);
2943 GCPRO1_VAR (keys
, inner_gcpro1
);
2945 /* Clear out this_command_keys. */
2946 this_command_key_count
= 0;
2947 this_command_key_count_reset
= 0;
2949 /* Now wipe the echo area. */
2950 if (!NILP (echo_area_buffer
[0]))
2951 safe_run_hooks (Qecho_area_clear_hook
);
2952 clear_message (1, 0);
2955 /* If we are not reading a key sequence,
2956 never use the echo area. */
2959 specbind (Qinput_method_use_echo_area
, Qt
);
2962 /* Call the input method. */
2963 tem
= call1 (Vinput_method_function
, c
);
2965 tem
= unbind_to (count
, tem
);
2967 /* Restore the saved echoing state
2968 and this_command_keys state. */
2969 this_command_key_count
= key_count
;
2970 this_command_key_count_reset
= key_count_reset
;
2972 this_command_keys
= keys
;
2975 ok_to_echo_at_next_pause
= saved_ok_to_echo
;
2976 KVAR (current_kboard
, echo_string
) = saved_echo_string
;
2977 current_kboard
->echo_after_prompt
= saved_echo_after_prompt
;
2978 if (saved_immediate_echo
)
2981 UNGCPRO_VAR (inner_gcpro1
);
2983 /* The input method can return no events. */
2986 /* Bring back the previous message, if any. */
2987 if (! NILP (previous_echo_area_message
))
2988 message_with_string ("%s", previous_echo_area_message
, 0);
2991 /* It returned one event or more. */
2993 Vunread_post_input_method_events
2994 = nconc2 (XCDR (tem
), Vunread_post_input_method_events
);
2999 /* Display help if not echoing. */
3000 if (CONSP (c
) && EQ (XCAR (c
), Qhelp_echo
))
3002 /* (help-echo FRAME HELP WINDOW OBJECT POS). */
3003 Lisp_Object help
, object
, position
, window
, htem
;
3005 htem
= Fcdr (XCDR (c
));
3008 window
= Fcar (htem
);
3010 object
= Fcar (htem
);
3012 position
= Fcar (htem
);
3014 show_help_echo (help
, window
, object
, position
, 0);
3016 /* We stopped being idle for this event; undo that. */
3018 timer_resume_idle ();
3022 if ((! reread
|| this_command_key_count
== 0
3023 || this_command_key_count_reset
)
3027 /* Don't echo mouse motion events. */
3028 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3029 && NILP (Fzerop (Vecho_keystrokes
))
3030 && ! (EVENT_HAS_PARAMETERS (c
)
3031 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_movement
)))
3034 if (! NILP (also_record
))
3035 echo_char (also_record
);
3036 /* Once we reread a character, echoing can happen
3037 the next time we pause to read a new one. */
3038 ok_to_echo_at_next_pause
= current_kboard
;
3041 /* Record this character as part of the current key. */
3042 add_command_key (c
);
3043 if (! NILP (also_record
))
3044 add_command_key (also_record
);
3047 last_input_event
= c
;
3050 /* Process the help character specially if enabled */
3051 if (!NILP (Vhelp_form
) && help_char_p (c
))
3054 int count
= SPECPDL_INDEX ();
3056 help_form_saved_window_configs
3057 = Fcons (Fcurrent_window_configuration (Qnil
),
3058 help_form_saved_window_configs
);
3059 record_unwind_protect (read_char_help_form_unwind
, Qnil
);
3061 tem0
= Feval (Vhelp_form
);
3063 internal_with_output_to_temp_buffer ("*Help*", print_help
, tem0
);
3068 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3069 if (EVENT_HAS_PARAMETERS (c
)
3070 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c
)), Qmouse_click
))
3071 XSETCAR (help_form_saved_window_configs
, Qnil
);
3073 while (BUFFERP (c
));
3074 /* Remove the help from the frame */
3075 unbind_to (count
, Qnil
);
3078 if (EQ (c
, make_number (040)))
3082 c
= read_char (0, 0, 0, Qnil
, 0, NULL
);
3083 while (BUFFERP (c
));
3092 /* Record a key that came from a mouse menu.
3093 Record it for echoing, for this-command-keys, and so on. */
3096 record_menu_key (Lisp_Object c
)
3098 /* Wipe the echo area. */
3099 clear_message (1, 0);
3104 before_command_key_count
= this_command_key_count
;
3105 before_command_echo_length
= echo_length ();
3108 /* Don't echo mouse motion events. */
3109 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
3110 && NILP (Fzerop (Vecho_keystrokes
)))
3114 /* Once we reread a character, echoing can happen
3115 the next time we pause to read a new one. */
3116 ok_to_echo_at_next_pause
= 0;
3119 /* Record this character as part of the current key. */
3120 add_command_key (c
);
3122 /* Re-reading in the middle of a command */
3123 last_input_event
= c
;
3127 /* Return 1 if should recognize C as "the help character". */
3130 help_char_p (Lisp_Object c
)
3134 if (EQ (c
, Vhelp_char
))
3136 for (tail
= Vhelp_event_list
; CONSP (tail
); tail
= XCDR (tail
))
3137 if (EQ (c
, XCAR (tail
)))
3142 /* Record the input event C in various ways. */
3145 record_char (Lisp_Object c
)
3149 if (CONSP (c
) && (EQ (XCAR (c
), Qhelp_echo
) || EQ (XCAR (c
), Qmouse_movement
)))
3151 /* To avoid filling recent_keys with help-echo and mouse-movement
3152 events, we filter out repeated help-echo events, only store the
3153 first and last in a series of mouse-movement events, and don't
3154 store repeated help-echo events which are only separated by
3155 mouse-movement events. */
3157 Lisp_Object ev1
, ev2
, ev3
;
3160 if ((ix1
= recent_keys_index
- 1) < 0)
3161 ix1
= NUM_RECENT_KEYS
- 1;
3162 ev1
= AREF (recent_keys
, ix1
);
3164 if ((ix2
= ix1
- 1) < 0)
3165 ix2
= NUM_RECENT_KEYS
- 1;
3166 ev2
= AREF (recent_keys
, ix2
);
3168 if ((ix3
= ix2
- 1) < 0)
3169 ix3
= NUM_RECENT_KEYS
- 1;
3170 ev3
= AREF (recent_keys
, ix3
);
3172 if (EQ (XCAR (c
), Qhelp_echo
))
3174 /* Don't record `help-echo' in recent_keys unless it shows some help
3175 message, and a different help than the previously recorded
3177 Lisp_Object help
, last_help
;
3179 help
= Fcar_safe (Fcdr_safe (XCDR (c
)));
3180 if (!STRINGP (help
))
3182 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qhelp_echo
)
3183 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev1
))), EQ (last_help
, help
)))
3185 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3186 && CONSP (ev2
) && EQ (XCAR (ev2
), Qhelp_echo
)
3187 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev2
))), EQ (last_help
, help
)))
3189 else if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3190 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3191 && CONSP (ev3
) && EQ (XCAR (ev3
), Qhelp_echo
)
3192 && (last_help
= Fcar_safe (Fcdr_safe (XCDR (ev3
))), EQ (last_help
, help
)))
3195 else if (EQ (XCAR (c
), Qmouse_movement
))
3197 /* Only record one pair of `mouse-movement' on a window in recent_keys.
3198 So additional mouse movement events replace the last element. */
3199 Lisp_Object last_window
, window
;
3201 window
= Fcar_safe (Fcar_safe (XCDR (c
)));
3202 if (CONSP (ev1
) && EQ (XCAR (ev1
), Qmouse_movement
)
3203 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev1
))), EQ (last_window
, window
))
3204 && CONSP (ev2
) && EQ (XCAR (ev2
), Qmouse_movement
)
3205 && (last_window
= Fcar_safe (Fcar_safe (XCDR (ev2
))), EQ (last_window
, window
)))
3207 ASET (recent_keys
, ix1
, c
);
3213 store_kbd_macro_char (c
);
3218 ASET (recent_keys
, recent_keys_index
, c
);
3219 if (++recent_keys_index
>= NUM_RECENT_KEYS
)
3220 recent_keys_index
= 0;
3222 else if (recorded
< 0)
3224 /* We need to remove one or two events from recent_keys.
3225 To do this, we simply put nil at those events and move the
3226 recent_keys_index backwards over those events. Usually,
3227 users will never see those nil events, as they will be
3228 overwritten by the command keys entered to see recent_keys
3231 while (recorded
++ < 0 && total_keys
> 0)
3233 if (total_keys
< NUM_RECENT_KEYS
)
3235 if (--recent_keys_index
< 0)
3236 recent_keys_index
= NUM_RECENT_KEYS
- 1;
3237 ASET (recent_keys
, recent_keys_index
, Qnil
);
3241 num_nonmacro_input_events
++;
3243 /* Write c to the dribble file. If c is a lispy event, write
3244 the event's symbol to the dribble file, in <brackets>. Bleaugh.
3245 If you, dear reader, have a better idea, you've got the source. :-) */
3251 if (XUINT (c
) < 0x100)
3252 putc (XINT (c
), dribble
);
3254 fprintf (dribble
, " 0x%x", (int) XUINT (c
));
3258 Lisp_Object dribblee
;
3260 /* If it's a structured event, take the event header. */
3261 dribblee
= EVENT_HEAD (c
);
3263 if (SYMBOLP (dribblee
))
3265 putc ('<', dribble
);
3266 fwrite (SDATA (SYMBOL_NAME (dribblee
)), sizeof (char),
3267 SBYTES (SYMBOL_NAME (dribblee
)),
3269 putc ('>', dribble
);
3279 print_help (Lisp_Object object
)
3281 struct buffer
*old
= current_buffer
;
3282 Fprinc (object
, Qnil
);
3283 set_buffer_internal (XBUFFER (Vstandard_output
));
3284 call0 (intern ("help-mode"));
3285 set_buffer_internal (old
);
3289 /* Copy out or in the info on where C-g should throw to.
3290 This is used when running Lisp code from within get_char,
3291 in case get_char is called recursively.
3292 See read_process_output. */
3295 save_getcjmp (jmp_buf temp
)
3297 memcpy (temp
, getcjmp
, sizeof getcjmp
);
3301 restore_getcjmp (jmp_buf temp
)
3303 memcpy (getcjmp
, temp
, sizeof getcjmp
);
3306 /* Low level keyboard/mouse input.
3307 kbd_buffer_store_event places events in kbd_buffer, and
3308 kbd_buffer_get_event retrieves them. */
3310 /* Return true if there are any events in the queue that read-char
3311 would return. If this returns false, a read-char would block. */
3313 readable_events (int flags
)
3315 if (flags
& READABLE_EVENTS_DO_TIMERS_NOW
)
3318 /* If the buffer contains only FOCUS_IN_EVENT events, and
3319 READABLE_EVENTS_FILTER_EVENTS is set, report it as empty. */
3320 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3322 if (flags
& (READABLE_EVENTS_FILTER_EVENTS
3323 #ifdef USE_TOOLKIT_SCROLL_BARS
3324 | READABLE_EVENTS_IGNORE_SQUEEZABLES
3328 struct input_event
*event
;
3330 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3337 #ifdef USE_TOOLKIT_SCROLL_BARS
3338 (flags
& READABLE_EVENTS_FILTER_EVENTS
) &&
3340 event
->kind
== FOCUS_IN_EVENT
)
3341 #ifdef USE_TOOLKIT_SCROLL_BARS
3342 && !((flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3343 && event
->kind
== SCROLL_BAR_CLICK_EVENT
3344 && event
->part
== scroll_bar_handle
3345 && event
->modifiers
== 0)
3350 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3353 while (event
!= kbd_store_ptr
);
3359 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3360 if (!(flags
& READABLE_EVENTS_IGNORE_SQUEEZABLES
)
3361 && !NILP (do_mouse_tracking
) && some_mouse_moved ())
3366 if (current_kboard
->kbd_queue_has_data
)
3372 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
3373 if (kb
->kbd_queue_has_data
)
3379 /* Set this for debugging, to have a way to get out */
3383 event_to_kboard (struct input_event
*event
)
3386 frame
= event
->frame_or_window
;
3388 frame
= XCAR (frame
);
3389 else if (WINDOWP (frame
))
3390 frame
= WINDOW_FRAME (XWINDOW (frame
));
3392 /* There are still some events that don't set this field.
3393 For now, just ignore the problem.
3394 Also ignore dead frames here. */
3395 if (!FRAMEP (frame
) || !FRAME_LIVE_P (XFRAME (frame
)))
3398 return FRAME_KBOARD (XFRAME (frame
));
3402 /* Return the number of slots occupied in kbd_buffer. */
3405 kbd_buffer_nr_stored (void)
3407 return kbd_fetch_ptr
== kbd_store_ptr
3409 : (kbd_fetch_ptr
< kbd_store_ptr
3410 ? kbd_store_ptr
- kbd_fetch_ptr
3411 : ((kbd_buffer
+ KBD_BUFFER_SIZE
) - kbd_fetch_ptr
3412 + (kbd_store_ptr
- kbd_buffer
)));
3414 #endif /* Store an event obtained at interrupt level into kbd_buffer, fifo */
3417 kbd_buffer_store_event (register struct input_event
*event
)
3419 kbd_buffer_store_event_hold (event
, 0);
3422 /* Store EVENT obtained at interrupt level into kbd_buffer, fifo.
3424 If HOLD_QUIT is 0, just stuff EVENT into the fifo.
3425 Else, if HOLD_QUIT.kind != NO_EVENT, discard EVENT.
3426 Else, if EVENT is a quit event, store the quit event
3427 in HOLD_QUIT, and return (thus ignoring further events).
3429 This is used in read_avail_input to postpone the processing
3430 of the quit event until all subsequent input events have been
3431 parsed (and discarded).
3435 kbd_buffer_store_event_hold (register struct input_event
*event
,
3436 struct input_event
*hold_quit
)
3438 if (event
->kind
== NO_EVENT
)
3441 if (hold_quit
&& hold_quit
->kind
!= NO_EVENT
)
3444 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
3446 register int c
= event
->code
& 0377;
3448 if (event
->modifiers
& ctrl_modifier
)
3449 c
= make_ctrl_char (c
);
3451 c
|= (event
->modifiers
3452 & (meta_modifier
| alt_modifier
3453 | hyper_modifier
| super_modifier
));
3457 KBOARD
*kb
= FRAME_KBOARD (XFRAME (event
->frame_or_window
));
3458 struct input_event
*sp
;
3460 if (single_kboard
&& kb
!= current_kboard
)
3462 KVAR (kb
, kbd_queue
)
3463 = Fcons (make_lispy_switch_frame (event
->frame_or_window
),
3464 Fcons (make_number (c
), Qnil
));
3465 kb
->kbd_queue_has_data
= 1;
3466 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3468 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3471 if (event_to_kboard (sp
) == kb
)
3473 sp
->kind
= NO_EVENT
;
3474 sp
->frame_or_window
= Qnil
;
3483 memcpy (hold_quit
, event
, sizeof (*event
));
3487 /* If this results in a quit_char being returned to Emacs as
3488 input, set Vlast_event_frame properly. If this doesn't
3489 get returned to Emacs as an event, the next event read
3490 will set Vlast_event_frame again, so this is safe to do. */
3494 focus
= FRAME_FOCUS_FRAME (XFRAME (event
->frame_or_window
));
3496 focus
= event
->frame_or_window
;
3497 internal_last_event_frame
= focus
;
3498 Vlast_event_frame
= focus
;
3501 last_event_timestamp
= event
->timestamp
;
3502 handle_interrupt ();
3506 if (c
&& c
== stop_character
)
3512 /* Don't insert two BUFFER_SWITCH_EVENT's in a row.
3513 Just ignore the second one. */
3514 else if (event
->kind
== BUFFER_SWITCH_EVENT
3515 && kbd_fetch_ptr
!= kbd_store_ptr
3516 && ((kbd_store_ptr
== kbd_buffer
3517 ? kbd_buffer
+ KBD_BUFFER_SIZE
- 1
3518 : kbd_store_ptr
- 1)->kind
) == BUFFER_SWITCH_EVENT
)
3521 if (kbd_store_ptr
- kbd_buffer
== KBD_BUFFER_SIZE
)
3522 kbd_store_ptr
= kbd_buffer
;
3524 /* Don't let the very last slot in the buffer become full,
3525 since that would make the two pointers equal,
3526 and that is indistinguishable from an empty buffer.
3527 Discard the event if it would fill the last slot. */
3528 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3530 *kbd_store_ptr
= *event
;
3533 if (kbd_buffer_nr_stored () > KBD_BUFFER_SIZE
/2 && ! kbd_on_hold_p ())
3535 /* Don't read keyboard input until we have processed kbd_buffer.
3536 This happens when pasting text longer than KBD_BUFFER_SIZE/2. */
3537 hold_keyboard_input ();
3539 if (!noninteractive
)
3540 signal (SIGIO
, SIG_IGN
);
3544 #endif /* subprocesses */
3547 /* If we're inside while-no-input, and this event qualifies
3548 as input, set quit-flag to cause an interrupt. */
3549 if (!NILP (Vthrow_on_input
)
3550 && event
->kind
!= FOCUS_IN_EVENT
3551 && event
->kind
!= HELP_EVENT
3552 && event
->kind
!= DEICONIFY_EVENT
)
3554 Vquit_flag
= Vthrow_on_input
;
3555 /* If we're inside a function that wants immediate quits,
3557 if (immediate_quit
&& NILP (Vinhibit_quit
))
3567 /* Put an input event back in the head of the event queue. */
3570 kbd_buffer_unget_event (register struct input_event
*event
)
3572 if (kbd_fetch_ptr
== kbd_buffer
)
3573 kbd_fetch_ptr
= kbd_buffer
+ KBD_BUFFER_SIZE
;
3575 /* Don't let the very last slot in the buffer become full, */
3576 if (kbd_fetch_ptr
- 1 != kbd_store_ptr
)
3579 *kbd_fetch_ptr
= *event
;
3584 /* Generate a HELP_EVENT input_event and store it in the keyboard
3587 HELP is the help form.
3589 FRAME and WINDOW are the frame and window where the help is
3590 generated. OBJECT is the Lisp object where the help was found (a
3591 buffer, a string, an overlay, or nil if neither from a string nor
3592 from a buffer). POS is the position within OBJECT where the help
3596 gen_help_event (Lisp_Object help
, Lisp_Object frame
, Lisp_Object window
,
3597 Lisp_Object object
, EMACS_INT pos
)
3599 struct input_event event
;
3603 event
.kind
= HELP_EVENT
;
3604 event
.frame_or_window
= frame
;
3606 event
.x
= WINDOWP (window
) ? window
: frame
;
3609 kbd_buffer_store_event (&event
);
3613 /* Store HELP_EVENTs for HELP on FRAME in the input queue. */
3616 kbd_buffer_store_help_event (Lisp_Object frame
, Lisp_Object help
)
3618 struct input_event event
;
3620 event
.kind
= HELP_EVENT
;
3621 event
.frame_or_window
= frame
;
3626 kbd_buffer_store_event (&event
);
3630 /* Discard any mouse events in the event buffer by setting them to
3633 discard_mouse_events (void)
3635 struct input_event
*sp
;
3636 for (sp
= kbd_fetch_ptr
; sp
!= kbd_store_ptr
; sp
++)
3638 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3641 if (sp
->kind
== MOUSE_CLICK_EVENT
3642 || sp
->kind
== WHEEL_EVENT
3643 || sp
->kind
== HORIZ_WHEEL_EVENT
3645 || sp
->kind
== GPM_CLICK_EVENT
3647 || sp
->kind
== SCROLL_BAR_CLICK_EVENT
)
3649 sp
->kind
= NO_EVENT
;
3655 /* Return non-zero if there are any real events waiting in the event
3656 buffer, not counting `NO_EVENT's.
3658 If DISCARD is non-zero, discard NO_EVENT events at the front of
3659 the input queue, possibly leaving the input queue empty if there
3660 are no real input events. */
3663 kbd_buffer_events_waiting (int discard
)
3665 struct input_event
*sp
;
3667 for (sp
= kbd_fetch_ptr
;
3668 sp
!= kbd_store_ptr
&& sp
->kind
== NO_EVENT
;
3671 if (sp
== kbd_buffer
+ KBD_BUFFER_SIZE
)
3678 return sp
!= kbd_store_ptr
&& sp
->kind
!= NO_EVENT
;
3682 /* Clear input event EVENT. */
3685 clear_event (struct input_event
*event
)
3687 event
->kind
= NO_EVENT
;
3691 /* Read one event from the event buffer, waiting if necessary.
3692 The value is a Lisp object representing the event.
3693 The value is nil for an event that should be ignored,
3694 or that was handled here.
3695 We always read and discard one event. */
3698 kbd_buffer_get_event (KBOARD
**kbp
,
3699 int *used_mouse_menu
,
3700 struct timeval
*end_time
)
3706 if (kbd_on_hold_p () && kbd_buffer_nr_stored () < KBD_BUFFER_SIZE
/4)
3708 /* Start reading input again, we have processed enough so we can
3709 accept new events again. */
3710 unhold_keyboard_input ();
3712 if (!noninteractive
)
3713 signal (SIGIO
, input_available_signal
);
3717 #endif /* subprocesses */
3720 /* In case we are running as a daemon, only do this before
3721 detaching from the terminal. */
3722 || (IS_DAEMON
&& daemon_pipe
[1] >= 0))
3726 *kbp
= current_kboard
;
3730 /* Wait until there is input available. */
3733 /* Break loop if there's an unread command event. Needed in
3734 moused window autoselection which uses a timer to insert such
3736 if (CONSP (Vunread_command_events
))
3739 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3741 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3742 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3746 /* If the quit flag is set, then read_char will return
3747 quit_char, so that counts as "available input." */
3748 if (!NILP (Vquit_flag
))
3749 quit_throw_to_read_char ();
3751 /* One way or another, wait until input is available; then, if
3752 interrupt handlers have not read it, read it now. */
3754 /* Note SIGIO has been undef'd if FIONREAD is missing. */
3758 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3760 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
3761 if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
3766 EMACS_TIME duration
;
3767 EMACS_GET_TIME (duration
);
3768 if (EMACS_TIME_GE (duration
, *end_time
))
3769 return Qnil
; /* finished waiting */
3772 EMACS_SUB_TIME (duration
, *end_time
, duration
);
3773 wait_reading_process_output (EMACS_SECS (duration
),
3774 EMACS_USECS (duration
),
3775 -1, 1, Qnil
, NULL
, 0);
3779 wait_reading_process_output (0, 0, -1, 1, Qnil
, NULL
, 0);
3781 if (!interrupt_input
&& kbd_fetch_ptr
== kbd_store_ptr
)
3782 /* Pass 1 for EXPECT since we just waited to have input. */
3783 read_avail_input (1);
3786 if (CONSP (Vunread_command_events
))
3789 first
= XCAR (Vunread_command_events
);
3790 Vunread_command_events
= XCDR (Vunread_command_events
);
3791 *kbp
= current_kboard
;
3795 /* At this point, we know that there is a readable event available
3796 somewhere. If the event queue is empty, then there must be a
3797 mouse movement enabled and available. */
3798 if (kbd_fetch_ptr
!= kbd_store_ptr
)
3800 struct input_event
*event
;
3802 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
3806 last_event_timestamp
= event
->timestamp
;
3808 *kbp
= event_to_kboard (event
);
3810 *kbp
= current_kboard
; /* Better than returning null ptr? */
3814 /* These two kinds of events get special handling
3815 and don't actually appear to the command loop.
3816 We return nil for them. */
3817 if (event
->kind
== SELECTION_REQUEST_EVENT
3818 || event
->kind
== SELECTION_CLEAR_EVENT
)
3821 struct input_event copy
;
3823 /* Remove it from the buffer before processing it,
3824 since otherwise swallow_events will see it
3825 and process it again. */
3827 kbd_fetch_ptr
= event
+ 1;
3828 input_pending
= readable_events (0);
3829 x_handle_selection_event (©
);
3831 /* We're getting selection request events, but we don't have
3837 #if defined (HAVE_NS)
3838 else if (event
->kind
== NS_TEXT_EVENT
)
3840 if (event
->code
== KEY_NS_PUT_WORKING_TEXT
)
3841 obj
= Fcons (intern ("ns-put-working-text"), Qnil
);
3843 obj
= Fcons (intern ("ns-unput-working-text"), Qnil
);
3844 kbd_fetch_ptr
= event
+ 1;
3845 if (used_mouse_menu
)
3846 *used_mouse_menu
= 1;
3850 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3851 || defined (HAVE_NS)
3852 else if (event
->kind
== DELETE_WINDOW_EVENT
)
3854 /* Make an event (delete-frame (FRAME)). */
3855 obj
= Fcons (event
->frame_or_window
, Qnil
);
3856 obj
= Fcons (Qdelete_frame
, Fcons (obj
, Qnil
));
3857 kbd_fetch_ptr
= event
+ 1;
3860 #if defined (HAVE_X11) || defined (HAVE_NTGUI) \
3861 || defined (HAVE_NS)
3862 else if (event
->kind
== ICONIFY_EVENT
)
3864 /* Make an event (iconify-frame (FRAME)). */
3865 obj
= Fcons (event
->frame_or_window
, Qnil
);
3866 obj
= Fcons (Qiconify_frame
, Fcons (obj
, Qnil
));
3867 kbd_fetch_ptr
= event
+ 1;
3869 else if (event
->kind
== DEICONIFY_EVENT
)
3871 /* Make an event (make-frame-visible (FRAME)). */
3872 obj
= Fcons (event
->frame_or_window
, Qnil
);
3873 obj
= Fcons (Qmake_frame_visible
, Fcons (obj
, Qnil
));
3874 kbd_fetch_ptr
= event
+ 1;
3877 else if (event
->kind
== BUFFER_SWITCH_EVENT
)
3879 /* The value doesn't matter here; only the type is tested. */
3880 XSETBUFFER (obj
, current_buffer
);
3881 kbd_fetch_ptr
= event
+ 1;
3883 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
3884 || defined(HAVE_NS) || defined (USE_GTK)
3885 else if (event
->kind
== MENU_BAR_ACTIVATE_EVENT
)
3887 kbd_fetch_ptr
= event
+ 1;
3888 input_pending
= readable_events (0);
3889 if (FRAME_LIVE_P (XFRAME (event
->frame_or_window
)))
3890 x_activate_menubar (XFRAME (event
->frame_or_window
));
3893 #if defined (WINDOWSNT)
3894 else if (event
->kind
== LANGUAGE_CHANGE_EVENT
)
3896 /* Make an event (language-change (FRAME CHARSET LCID)). */
3897 obj
= Fcons (event
->frame_or_window
, Qnil
);
3898 obj
= Fcons (Qlanguage_change
, Fcons (obj
, Qnil
));
3899 kbd_fetch_ptr
= event
+ 1;
3902 else if (event
->kind
== SAVE_SESSION_EVENT
)
3904 obj
= Fcons (Qsave_session
, Fcons (event
->arg
, Qnil
));
3905 kbd_fetch_ptr
= event
+ 1;
3907 /* Just discard these, by returning nil.
3908 With MULTI_KBOARD, these events are used as placeholders
3909 when we need to randomly delete events from the queue.
3910 (They shouldn't otherwise be found in the buffer,
3911 but on some machines it appears they do show up
3912 even without MULTI_KBOARD.) */
3913 /* On Windows NT/9X, NO_EVENT is used to delete extraneous
3914 mouse events during a popup-menu call. */
3915 else if (event
->kind
== NO_EVENT
)
3916 kbd_fetch_ptr
= event
+ 1;
3917 else if (event
->kind
== HELP_EVENT
)
3919 Lisp_Object object
, position
, help
, frame
, window
;
3921 frame
= event
->frame_or_window
;
3922 object
= event
->arg
;
3923 position
= make_number (event
->code
);
3926 clear_event (event
);
3928 kbd_fetch_ptr
= event
+ 1;
3929 if (!WINDOWP (window
))
3931 obj
= Fcons (Qhelp_echo
,
3932 list5 (frame
, help
, window
, object
, position
));
3934 else if (event
->kind
== FOCUS_IN_EVENT
)
3936 /* Notification of a FocusIn event. The frame receiving the
3937 focus is in event->frame_or_window. Generate a
3938 switch-frame event if necessary. */
3939 Lisp_Object frame
, focus
;
3941 frame
= event
->frame_or_window
;
3942 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
3946 if (!EQ (frame
, internal_last_event_frame
)
3947 && !EQ (frame
, selected_frame
))
3948 obj
= make_lispy_switch_frame (frame
);
3949 internal_last_event_frame
= frame
;
3950 kbd_fetch_ptr
= event
+ 1;
3953 else if (event
->kind
== DBUS_EVENT
)
3955 obj
= make_lispy_event (event
);
3956 kbd_fetch_ptr
= event
+ 1;
3959 else if (event
->kind
== CONFIG_CHANGED_EVENT
)
3961 obj
= make_lispy_event (event
);
3962 kbd_fetch_ptr
= event
+ 1;
3966 /* If this event is on a different frame, return a switch-frame this
3967 time, and leave the event in the queue for next time. */
3971 frame
= event
->frame_or_window
;
3973 frame
= XCAR (frame
);
3974 else if (WINDOWP (frame
))
3975 frame
= WINDOW_FRAME (XWINDOW (frame
));
3977 focus
= FRAME_FOCUS_FRAME (XFRAME (frame
));
3981 if (! EQ (frame
, internal_last_event_frame
)
3982 && !EQ (frame
, selected_frame
))
3983 obj
= make_lispy_switch_frame (frame
);
3984 internal_last_event_frame
= frame
;
3986 /* If we didn't decide to make a switch-frame event, go ahead
3987 and build a real event from the queue entry. */
3991 obj
= make_lispy_event (event
);
3993 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
3994 || defined(HAVE_NS) || defined (USE_GTK)
3995 /* If this was a menu selection, then set the flag to inhibit
3996 writing to last_nonmenu_event. Don't do this if the event
3997 we're returning is (menu-bar), though; that indicates the
3998 beginning of the menu sequence, and we might as well leave
3999 that as the `event with parameters' for this selection. */
4001 && !EQ (event
->frame_or_window
, event
->arg
)
4002 && (event
->kind
== MENU_BAR_EVENT
4003 || event
->kind
== TOOL_BAR_EVENT
))
4004 *used_mouse_menu
= 1;
4007 /* certain system events are non-key events */
4009 && event
->kind
== NS_NONKEY_EVENT
)
4010 *used_mouse_menu
= 1;
4013 /* Wipe out this event, to catch bugs. */
4014 clear_event (event
);
4015 kbd_fetch_ptr
= event
+ 1;
4019 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
4020 /* Try generating a mouse motion event. */
4021 else if (!NILP (do_mouse_tracking
) && some_mouse_moved ())
4023 FRAME_PTR f
= some_mouse_moved ();
4024 Lisp_Object bar_window
;
4025 enum scroll_bar_part part
;
4029 *kbp
= current_kboard
;
4030 /* Note that this uses F to determine which terminal to look at.
4031 If there is no valid info, it does not store anything
4032 so x remains nil. */
4035 /* XXX Can f or mouse_position_hook be NULL here? */
4036 if (f
&& FRAME_TERMINAL (f
)->mouse_position_hook
)
4037 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, 0, &bar_window
,
4042 /* Decide if we should generate a switch-frame event. Don't
4043 generate switch-frame events for motion outside of all Emacs
4049 frame
= FRAME_FOCUS_FRAME (f
);
4051 XSETFRAME (frame
, f
);
4053 if (! EQ (frame
, internal_last_event_frame
)
4054 && !EQ (frame
, selected_frame
))
4055 obj
= make_lispy_switch_frame (frame
);
4056 internal_last_event_frame
= frame
;
4059 /* If we didn't decide to make a switch-frame event, go ahead and
4060 return a mouse-motion event. */
4061 if (!NILP (x
) && NILP (obj
))
4062 obj
= make_lispy_movement (f
, bar_window
, part
, x
, y
, t
);
4064 #endif /* HAVE_MOUSE || HAVE GPM */
4066 /* We were promised by the above while loop that there was
4067 something for us to read! */
4070 input_pending
= readable_events (0);
4072 Vlast_event_frame
= internal_last_event_frame
;
4077 /* Process any events that are not user-visible,
4078 then return, without reading any user-visible events. */
4081 swallow_events (int do_display
)
4085 while (kbd_fetch_ptr
!= kbd_store_ptr
)
4087 struct input_event
*event
;
4089 event
= ((kbd_fetch_ptr
< kbd_buffer
+ KBD_BUFFER_SIZE
)
4093 last_event_timestamp
= event
->timestamp
;
4095 /* These two kinds of events get special handling
4096 and don't actually appear to the command loop. */
4097 if (event
->kind
== SELECTION_REQUEST_EVENT
4098 || event
->kind
== SELECTION_CLEAR_EVENT
)
4101 struct input_event copy
;
4103 /* Remove it from the buffer before processing it,
4104 since otherwise swallow_events called recursively could see it
4105 and process it again. */
4107 kbd_fetch_ptr
= event
+ 1;
4108 input_pending
= readable_events (0);
4109 x_handle_selection_event (©
);
4111 /* We're getting selection request events, but we don't have
4120 old_timers_run
= timers_run
;
4121 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
4123 if (timers_run
!= old_timers_run
&& do_display
)
4124 redisplay_preserve_echo_area (7);
4127 /* Record the start of when Emacs is idle,
4128 for the sake of running idle-time timers. */
4131 timer_start_idle (void)
4135 /* If we are already in the idle state, do nothing. */
4136 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4139 EMACS_GET_TIME (timer_idleness_start_time
);
4141 timer_last_idleness_start_time
= timer_idleness_start_time
;
4143 /* Mark all idle-time timers as once again candidates for running. */
4144 for (timers
= Vtimer_idle_list
; CONSP (timers
); timers
= XCDR (timers
))
4148 timer
= XCAR (timers
);
4150 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4152 XVECTOR (timer
)->contents
[0] = Qnil
;
4156 /* Record that Emacs is no longer idle, so stop running idle-time timers. */
4159 timer_stop_idle (void)
4161 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
4164 /* Resume idle timer from last idle start time. */
4167 timer_resume_idle (void)
4169 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4172 timer_idleness_start_time
= timer_last_idleness_start_time
;
4175 /* This is only for debugging. */
4176 struct input_event last_timer_event
;
4178 /* List of elisp functions to call, delayed because they were generated in
4179 a context where Elisp could not be safely run (e.g. redisplay, signal,
4180 ...). Each element has the form (FUN . ARGS). */
4181 Lisp_Object pending_funcalls
;
4183 /* Check whether a timer has fired. To prevent larger problems we simply
4184 disregard elements that are not proper timers. Do not make a circular
4185 timer list for the time being.
4187 Returns the time to wait until the next timer fires. If a
4188 timer is triggering now, return zero.
4189 If no timer is active, return -1.
4191 If a timer is ripe, we run it, with quitting turned off.
4192 In that case we return 0 to indicate that a new timer_check_2 call
4196 timer_check_2 (void)
4198 EMACS_TIME nexttime
;
4199 EMACS_TIME now
, idleness_now
;
4200 Lisp_Object timers
, idle_timers
, chosen_timer
;
4201 struct gcpro gcpro1
, gcpro2
, gcpro3
;
4203 EMACS_SET_SECS (nexttime
, -1);
4204 EMACS_SET_USECS (nexttime
, -1);
4206 /* Always consider the ordinary timers. */
4207 timers
= Vtimer_list
;
4208 /* Consider the idle timers only if Emacs is idle. */
4209 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4210 idle_timers
= Vtimer_idle_list
;
4213 chosen_timer
= Qnil
;
4214 GCPRO3 (timers
, idle_timers
, chosen_timer
);
4216 /* First run the code that was delayed. */
4217 while (CONSP (pending_funcalls
))
4219 Lisp_Object funcall
= XCAR (pending_funcalls
);
4220 pending_funcalls
= XCDR (pending_funcalls
);
4221 safe_call2 (Qapply
, XCAR (funcall
), XCDR (funcall
));
4224 if (CONSP (timers
) || CONSP (idle_timers
))
4226 EMACS_GET_TIME (now
);
4227 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4228 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4231 while (CONSP (timers
) || CONSP (idle_timers
))
4233 Lisp_Object
*vector
;
4234 Lisp_Object timer
= Qnil
, idle_timer
= Qnil
;
4235 EMACS_TIME timer_time
, idle_timer_time
;
4236 EMACS_TIME difference
, timer_difference
, idle_timer_difference
;
4238 /* Skip past invalid timers and timers already handled. */
4241 timer
= XCAR (timers
);
4242 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4244 timers
= XCDR (timers
);
4247 vector
= XVECTOR (timer
)->contents
;
4249 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4250 || !INTEGERP (vector
[3])
4251 || ! NILP (vector
[0]))
4253 timers
= XCDR (timers
);
4257 if (!NILP (idle_timers
))
4259 timer
= XCAR (idle_timers
);
4260 if (!VECTORP (timer
) || XVECTOR (timer
)->size
!= 8)
4262 idle_timers
= XCDR (idle_timers
);
4265 vector
= XVECTOR (timer
)->contents
;
4267 if (!INTEGERP (vector
[1]) || !INTEGERP (vector
[2])
4268 || !INTEGERP (vector
[3])
4269 || ! NILP (vector
[0]))
4271 idle_timers
= XCDR (idle_timers
);
4276 /* Set TIMER, TIMER_TIME and TIMER_DIFFERENCE
4277 based on the next ordinary timer.
4278 TIMER_DIFFERENCE is the distance in time from NOW to when
4279 this timer becomes ripe (negative if it's already ripe). */
4282 timer
= XCAR (timers
);
4283 vector
= XVECTOR (timer
)->contents
;
4284 EMACS_SET_SECS (timer_time
,
4285 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4286 EMACS_SET_USECS (timer_time
, XINT (vector
[3]));
4287 EMACS_SUB_TIME (timer_difference
, timer_time
, now
);
4290 /* Set IDLE_TIMER, IDLE_TIMER_TIME and IDLE_TIMER_DIFFERENCE
4291 based on the next idle timer. */
4292 if (!NILP (idle_timers
))
4294 idle_timer
= XCAR (idle_timers
);
4295 vector
= XVECTOR (idle_timer
)->contents
;
4296 EMACS_SET_SECS (idle_timer_time
,
4297 (XINT (vector
[1]) << 16) | (XINT (vector
[2])));
4298 EMACS_SET_USECS (idle_timer_time
, XINT (vector
[3]));
4299 EMACS_SUB_TIME (idle_timer_difference
, idle_timer_time
, idleness_now
);
4302 /* Decide which timer is the next timer,
4303 and set CHOSEN_TIMER, VECTOR and DIFFERENCE accordingly.
4304 Also step down the list where we found that timer. */
4306 if (! NILP (timers
) && ! NILP (idle_timers
))
4309 EMACS_SUB_TIME (temp
, timer_difference
, idle_timer_difference
);
4310 if (EMACS_TIME_NEG_P (temp
))
4312 chosen_timer
= timer
;
4313 timers
= XCDR (timers
);
4314 difference
= timer_difference
;
4318 chosen_timer
= idle_timer
;
4319 idle_timers
= XCDR (idle_timers
);
4320 difference
= idle_timer_difference
;
4323 else if (! NILP (timers
))
4325 chosen_timer
= timer
;
4326 timers
= XCDR (timers
);
4327 difference
= timer_difference
;
4331 chosen_timer
= idle_timer
;
4332 idle_timers
= XCDR (idle_timers
);
4333 difference
= idle_timer_difference
;
4335 vector
= XVECTOR (chosen_timer
)->contents
;
4337 /* If timer is ripe, run it if it hasn't been run. */
4338 if (EMACS_TIME_NEG_P (difference
)
4339 || (EMACS_SECS (difference
) == 0
4340 && EMACS_USECS (difference
) == 0))
4342 if (NILP (vector
[0]))
4344 int count
= SPECPDL_INDEX ();
4345 Lisp_Object old_deactivate_mark
= Vdeactivate_mark
;
4347 /* Mark the timer as triggered to prevent problems if the lisp
4348 code fails to reschedule it right. */
4351 specbind (Qinhibit_quit
, Qt
);
4353 call1 (Qtimer_event_handler
, chosen_timer
);
4354 Vdeactivate_mark
= old_deactivate_mark
;
4356 unbind_to (count
, Qnil
);
4358 /* Since we have handled the event,
4359 we don't need to tell the caller to wake up and do it. */
4360 /* But the caller must still wait for the next timer, so
4361 return 0 to indicate that. */
4364 EMACS_SET_SECS (nexttime
, 0);
4365 EMACS_SET_USECS (nexttime
, 0);
4368 /* When we encounter a timer that is still waiting,
4369 return the amount of time to wait before it is ripe. */
4376 /* No timers are pending in the future. */
4377 /* Return 0 if we generated an event, and -1 if not. */
4383 /* Check whether a timer has fired. To prevent larger problems we simply
4384 disregard elements that are not proper timers. Do not make a circular
4385 timer list for the time being.
4387 Returns the time to wait until the next timer fires.
4388 If no timer is active, return -1.
4390 As long as any timer is ripe, we run it.
4392 DO_IT_NOW is now ignored. It used to mean that we should
4393 run the timer directly instead of queueing a timer-event.
4394 Now we always run timers directly. */
4397 timer_check (int do_it_now
)
4399 EMACS_TIME nexttime
;
4403 nexttime
= timer_check_2 ();
4405 while (EMACS_SECS (nexttime
) == 0 && EMACS_USECS (nexttime
) == 0);
4410 DEFUN ("current-idle-time", Fcurrent_idle_time
, Scurrent_idle_time
, 0, 0, 0,
4411 doc
: /* Return the current length of Emacs idleness, or nil.
4412 The value when Emacs is idle is a list of three integers. The first has
4413 the most significant 16 bits of the seconds, while the second has the least
4414 significant 16 bits. The third integer gives the microsecond count.
4416 The value when Emacs is not idle is nil.
4418 The microsecond count is zero on systems that do not provide
4419 resolution finer than a second. */)
4422 if (! EMACS_TIME_NEG_P (timer_idleness_start_time
))
4424 EMACS_TIME now
, idleness_now
;
4426 EMACS_GET_TIME (now
);
4427 EMACS_SUB_TIME (idleness_now
, now
, timer_idleness_start_time
);
4429 return list3 (make_number ((EMACS_SECS (idleness_now
) >> 16) & 0xffff),
4430 make_number ((EMACS_SECS (idleness_now
) >> 0) & 0xffff),
4431 make_number (EMACS_USECS (idleness_now
)));
4437 /* Caches for modify_event_symbol. */
4438 static Lisp_Object accent_key_syms
;
4439 static Lisp_Object func_key_syms
;
4440 static Lisp_Object mouse_syms
;
4441 static Lisp_Object wheel_syms
;
4442 static Lisp_Object drag_n_drop_syms
;
4444 /* This is a list of keysym codes for special "accent" characters.
4445 It parallels lispy_accent_keys. */
4447 static const int lispy_accent_codes
[] =
4449 #ifdef XK_dead_circumflex
4454 #ifdef XK_dead_grave
4459 #ifdef XK_dead_tilde
4464 #ifdef XK_dead_diaeresis
4469 #ifdef XK_dead_macron
4474 #ifdef XK_dead_degree
4479 #ifdef XK_dead_acute
4484 #ifdef XK_dead_cedilla
4489 #ifdef XK_dead_breve
4494 #ifdef XK_dead_ogonek
4499 #ifdef XK_dead_caron
4504 #ifdef XK_dead_doubleacute
4505 XK_dead_doubleacute
,
4509 #ifdef XK_dead_abovedot
4514 #ifdef XK_dead_abovering
4524 #ifdef XK_dead_belowdot
4529 #ifdef XK_dead_voiced_sound
4530 XK_dead_voiced_sound
,
4534 #ifdef XK_dead_semivoiced_sound
4535 XK_dead_semivoiced_sound
,
4551 /* This is a list of Lisp names for special "accent" characters.
4552 It parallels lispy_accent_codes. */
4554 static const char *const lispy_accent_keys
[] =
4572 "dead-voiced-sound",
4573 "dead-semivoiced-sound",
4579 #define FUNCTION_KEY_OFFSET 0x0
4581 const char *const lispy_function_keys
[] =
4585 0, /* VK_LBUTTON 0x01 */
4586 0, /* VK_RBUTTON 0x02 */
4587 "cancel", /* VK_CANCEL 0x03 */
4588 0, /* VK_MBUTTON 0x04 */
4590 0, 0, 0, /* 0x05 .. 0x07 */
4592 "backspace", /* VK_BACK 0x08 */
4593 "tab", /* VK_TAB 0x09 */
4595 0, 0, /* 0x0A .. 0x0B */
4597 "clear", /* VK_CLEAR 0x0C */
4598 "return", /* VK_RETURN 0x0D */
4600 0, 0, /* 0x0E .. 0x0F */
4602 0, /* VK_SHIFT 0x10 */
4603 0, /* VK_CONTROL 0x11 */
4604 0, /* VK_MENU 0x12 */
4605 "pause", /* VK_PAUSE 0x13 */
4606 "capslock", /* VK_CAPITAL 0x14 */
4607 "kana", /* VK_KANA/VK_HANGUL 0x15 */
4609 "junja", /* VK_JUNJA 0x17 */
4610 "final", /* VK_FINAL 0x18 */
4611 "kanji", /* VK_KANJI/VK_HANJA 0x19 */
4613 "escape", /* VK_ESCAPE 0x1B */
4614 "convert", /* VK_CONVERT 0x1C */
4615 "non-convert", /* VK_NONCONVERT 0x1D */
4616 "accept", /* VK_ACCEPT 0x1E */
4617 "mode-change", /* VK_MODECHANGE 0x1F */
4618 0, /* VK_SPACE 0x20 */
4619 "prior", /* VK_PRIOR 0x21 */
4620 "next", /* VK_NEXT 0x22 */
4621 "end", /* VK_END 0x23 */
4622 "home", /* VK_HOME 0x24 */
4623 "left", /* VK_LEFT 0x25 */
4624 "up", /* VK_UP 0x26 */
4625 "right", /* VK_RIGHT 0x27 */
4626 "down", /* VK_DOWN 0x28 */
4627 "select", /* VK_SELECT 0x29 */
4628 "print", /* VK_PRINT 0x2A */
4629 "execute", /* VK_EXECUTE 0x2B */
4630 "snapshot", /* VK_SNAPSHOT 0x2C */
4631 "insert", /* VK_INSERT 0x2D */
4632 "delete", /* VK_DELETE 0x2E */
4633 "help", /* VK_HELP 0x2F */
4635 /* VK_0 thru VK_9 are the same as ASCII '0' thru '9' (0x30 - 0x39) */
4637 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4639 0, 0, 0, 0, 0, 0, 0, /* 0x3A .. 0x40 */
4641 /* VK_A thru VK_Z are the same as ASCII 'A' thru 'Z' (0x41 - 0x5A) */
4643 0, 0, 0, 0, 0, 0, 0, 0, 0,
4644 0, 0, 0, 0, 0, 0, 0, 0, 0,
4645 0, 0, 0, 0, 0, 0, 0, 0,
4647 "lwindow", /* VK_LWIN 0x5B */
4648 "rwindow", /* VK_RWIN 0x5C */
4649 "apps", /* VK_APPS 0x5D */
4652 "kp-0", /* VK_NUMPAD0 0x60 */
4653 "kp-1", /* VK_NUMPAD1 0x61 */
4654 "kp-2", /* VK_NUMPAD2 0x62 */
4655 "kp-3", /* VK_NUMPAD3 0x63 */
4656 "kp-4", /* VK_NUMPAD4 0x64 */
4657 "kp-5", /* VK_NUMPAD5 0x65 */
4658 "kp-6", /* VK_NUMPAD6 0x66 */
4659 "kp-7", /* VK_NUMPAD7 0x67 */
4660 "kp-8", /* VK_NUMPAD8 0x68 */
4661 "kp-9", /* VK_NUMPAD9 0x69 */
4662 "kp-multiply", /* VK_MULTIPLY 0x6A */
4663 "kp-add", /* VK_ADD 0x6B */
4664 "kp-separator", /* VK_SEPARATOR 0x6C */
4665 "kp-subtract", /* VK_SUBTRACT 0x6D */
4666 "kp-decimal", /* VK_DECIMAL 0x6E */
4667 "kp-divide", /* VK_DIVIDE 0x6F */
4668 "f1", /* VK_F1 0x70 */
4669 "f2", /* VK_F2 0x71 */
4670 "f3", /* VK_F3 0x72 */
4671 "f4", /* VK_F4 0x73 */
4672 "f5", /* VK_F5 0x74 */
4673 "f6", /* VK_F6 0x75 */
4674 "f7", /* VK_F7 0x76 */
4675 "f8", /* VK_F8 0x77 */
4676 "f9", /* VK_F9 0x78 */
4677 "f10", /* VK_F10 0x79 */
4678 "f11", /* VK_F11 0x7A */
4679 "f12", /* VK_F12 0x7B */
4680 "f13", /* VK_F13 0x7C */
4681 "f14", /* VK_F14 0x7D */
4682 "f15", /* VK_F15 0x7E */
4683 "f16", /* VK_F16 0x7F */
4684 "f17", /* VK_F17 0x80 */
4685 "f18", /* VK_F18 0x81 */
4686 "f19", /* VK_F19 0x82 */
4687 "f20", /* VK_F20 0x83 */
4688 "f21", /* VK_F21 0x84 */
4689 "f22", /* VK_F22 0x85 */
4690 "f23", /* VK_F23 0x86 */
4691 "f24", /* VK_F24 0x87 */
4693 0, 0, 0, 0, /* 0x88 .. 0x8B */
4694 0, 0, 0, 0, /* 0x8C .. 0x8F */
4696 "kp-numlock", /* VK_NUMLOCK 0x90 */
4697 "scroll", /* VK_SCROLL 0x91 */
4698 /* Not sure where the following block comes from.
4699 Windows headers have NEC and Fujitsu specific keys in
4700 this block, but nothing generic. */
4701 "kp-space", /* VK_NUMPAD_CLEAR 0x92 */
4702 "kp-enter", /* VK_NUMPAD_ENTER 0x93 */
4703 "kp-prior", /* VK_NUMPAD_PRIOR 0x94 */
4704 "kp-next", /* VK_NUMPAD_NEXT 0x95 */
4705 "kp-end", /* VK_NUMPAD_END 0x96 */
4706 "kp-home", /* VK_NUMPAD_HOME 0x97 */
4707 "kp-left", /* VK_NUMPAD_LEFT 0x98 */
4708 "kp-up", /* VK_NUMPAD_UP 0x99 */
4709 "kp-right", /* VK_NUMPAD_RIGHT 0x9A */
4710 "kp-down", /* VK_NUMPAD_DOWN 0x9B */
4711 "kp-insert", /* VK_NUMPAD_INSERT 0x9C */
4712 "kp-delete", /* VK_NUMPAD_DELETE 0x9D */
4714 0, 0, /* 0x9E .. 0x9F */
4717 * VK_L* & VK_R* - left and right Alt, Ctrl and Shift virtual keys.
4718 * Used only as parameters to GetAsyncKeyState and GetKeyState.
4719 * No other API or message will distinguish left and right keys this way.
4724 /* Multimedia keys. These are handled as WM_APPCOMMAND, which allows us
4725 to enable them selectively, and gives access to a few more functions.
4726 See lispy_multimedia_keys below. */
4727 0, 0, 0, 0, 0, 0, 0, /* 0xA6 .. 0xAC Browser */
4728 0, 0, 0, /* 0xAD .. 0xAF Volume */
4729 0, 0, 0, 0, /* 0xB0 .. 0xB3 Media */
4730 0, 0, 0, 0, /* 0xB4 .. 0xB7 Apps */
4732 /* 0xB8 .. 0xC0 "OEM" keys - all seem to be punctuation. */
4733 0, 0, 0, 0, 0, 0, 0, 0, 0,
4735 /* 0xC1 - 0xDA unallocated, 0xDB-0xDF more OEM keys */
4736 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4737 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4740 "ax", /* VK_OEM_AX 0xE1 */
4741 0, /* VK_OEM_102 0xE2 */
4742 "ico-help", /* VK_ICO_HELP 0xE3 */
4743 "ico-00", /* VK_ICO_00 0xE4 */
4744 0, /* VK_PROCESSKEY 0xE5 - used by IME */
4745 "ico-clear", /* VK_ICO_CLEAR 0xE6 */
4746 0, /* VK_PACKET 0xE7 - used to pass unicode chars */
4748 "reset", /* VK_OEM_RESET 0xE9 */
4749 "jump", /* VK_OEM_JUMP 0xEA */
4750 "oem-pa1", /* VK_OEM_PA1 0xEB */
4751 "oem-pa2", /* VK_OEM_PA2 0xEC */
4752 "oem-pa3", /* VK_OEM_PA3 0xED */
4753 "wsctrl", /* VK_OEM_WSCTRL 0xEE */
4754 "cusel", /* VK_OEM_CUSEL 0xEF */
4755 "oem-attn", /* VK_OEM_ATTN 0xF0 */
4756 "finish", /* VK_OEM_FINISH 0xF1 */
4757 "copy", /* VK_OEM_COPY 0xF2 */
4758 "auto", /* VK_OEM_AUTO 0xF3 */
4759 "enlw", /* VK_OEM_ENLW 0xF4 */
4760 "backtab", /* VK_OEM_BACKTAB 0xF5 */
4761 "attn", /* VK_ATTN 0xF6 */
4762 "crsel", /* VK_CRSEL 0xF7 */
4763 "exsel", /* VK_EXSEL 0xF8 */
4764 "ereof", /* VK_EREOF 0xF9 */
4765 "play", /* VK_PLAY 0xFA */
4766 "zoom", /* VK_ZOOM 0xFB */
4767 "noname", /* VK_NONAME 0xFC */
4768 "pa1", /* VK_PA1 0xFD */
4769 "oem_clear", /* VK_OEM_CLEAR 0xFE */
4773 /* Some of these duplicate the "Media keys" on newer keyboards,
4774 but they are delivered to the application in a different way. */
4775 static const char *const lispy_multimedia_keys
[] =
4783 "browser-favorites",
4820 "toggle-dictate-command",
4826 "media-fast-forward",
4829 "media-channel-down"
4832 #else /* not HAVE_NTGUI */
4834 /* This should be dealt with in XTread_socket now, and that doesn't
4835 depend on the client system having the Kana syms defined. See also
4836 the XK_kana_A case below. */
4839 static const char *const lispy_kana_keys
[] =
4841 /* X Keysym value */
4842 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x400 .. 0x40f */
4843 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x410 .. 0x41f */
4844 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x420 .. 0x42f */
4845 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x430 .. 0x43f */
4846 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x440 .. 0x44f */
4847 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x450 .. 0x45f */
4848 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x460 .. 0x46f */
4849 0,0,0,0,0,0,0,0,0,0,0,0,0,0,"overline",0,
4850 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x480 .. 0x48f */
4851 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x490 .. 0x49f */
4852 0, "kana-fullstop", "kana-openingbracket", "kana-closingbracket",
4853 "kana-comma", "kana-conjunctive", "kana-WO", "kana-a",
4854 "kana-i", "kana-u", "kana-e", "kana-o",
4855 "kana-ya", "kana-yu", "kana-yo", "kana-tsu",
4856 "prolongedsound", "kana-A", "kana-I", "kana-U",
4857 "kana-E", "kana-O", "kana-KA", "kana-KI",
4858 "kana-KU", "kana-KE", "kana-KO", "kana-SA",
4859 "kana-SHI", "kana-SU", "kana-SE", "kana-SO",
4860 "kana-TA", "kana-CHI", "kana-TSU", "kana-TE",
4861 "kana-TO", "kana-NA", "kana-NI", "kana-NU",
4862 "kana-NE", "kana-NO", "kana-HA", "kana-HI",
4863 "kana-FU", "kana-HE", "kana-HO", "kana-MA",
4864 "kana-MI", "kana-MU", "kana-ME", "kana-MO",
4865 "kana-YA", "kana-YU", "kana-YO", "kana-RA",
4866 "kana-RI", "kana-RU", "kana-RE", "kana-RO",
4867 "kana-WA", "kana-N", "voicedsound", "semivoicedsound",
4868 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4e0 .. 0x4ef */
4869 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x4f0 .. 0x4ff */
4871 #endif /* XK_kana_A */
4874 #define FUNCTION_KEY_OFFSET 0xff00
4876 /* You'll notice that this table is arranged to be conveniently
4877 indexed by X Windows keysym values. */
4878 static const char *const lispy_function_keys
[] =
4880 /* X Keysym value */
4882 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff00...0f */
4883 "backspace", "tab", "linefeed", "clear",
4885 0, 0, 0, "pause", /* 0xff10...1f */
4886 0, 0, 0, 0, 0, 0, 0, "escape",
4888 0, "kanji", "muhenkan", "henkan", /* 0xff20...2f */
4889 "romaji", "hiragana", "katakana", "hiragana-katakana",
4890 "zenkaku", "hankaku", "zenkaku-hankaku", "touroku",
4891 "massyo", "kana-lock", "kana-shift", "eisu-shift",
4892 "eisu-toggle", /* 0xff30...3f */
4893 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
4894 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0xff40...4f */
4896 "home", "left", "up", "right", /* 0xff50 */ /* IsCursorKey */
4897 "down", "prior", "next", "end",
4898 "begin", 0, 0, 0, 0, 0, 0, 0,
4899 "select", /* 0xff60 */ /* IsMiscFunctionKey */
4910 "break", /* 0xff6b */
4913 0, 0, 0, 0, "backtab", 0, 0, 0, /* 0xff70... */
4914 0, 0, 0, 0, 0, 0, 0, "kp-numlock", /* 0xff78... */
4915 "kp-space", /* 0xff80 */ /* IsKeypadKey */
4916 0, 0, 0, 0, 0, 0, 0, 0,
4917 "kp-tab", /* 0xff89 */
4919 "kp-enter", /* 0xff8d */
4921 "kp-f1", /* 0xff91 */
4925 "kp-home", /* 0xff95 */
4930 "kp-prior", /* kp-page-up */
4931 "kp-next", /* kp-page-down */
4937 0, 0, 0, 0, 0, 0, 0, 0, 0,
4938 "kp-multiply", /* 0xffaa */
4943 "kp-divide", /* 0xffaf */
4944 "kp-0", /* 0xffb0 */
4945 "kp-1", "kp-2", "kp-3", "kp-4", "kp-5", "kp-6", "kp-7", "kp-8", "kp-9",
4948 "kp-equal", /* 0xffbd */
4949 "f1", /* 0xffbe */ /* IsFunctionKey */
4951 "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", /* 0xffc0 */
4952 "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18",
4953 "f19", "f20", "f21", "f22", "f23", "f24", "f25", "f26", /* 0xffd0 */
4954 "f27", "f28", "f29", "f30", "f31", "f32", "f33", "f34",
4955 "f35", 0, 0, 0, 0, 0, 0, 0, /* 0xffe0 */
4956 0, 0, 0, 0, 0, 0, 0, 0,
4957 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfff0 */
4958 0, 0, 0, 0, 0, 0, 0, "delete"
4961 /* ISO 9995 Function and Modifier Keys; the first byte is 0xFE. */
4962 #define ISO_FUNCTION_KEY_OFFSET 0xfe00
4964 static const char *const iso_lispy_function_keys
[] =
4966 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe00 */
4967 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe08 */
4968 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe10 */
4969 0, 0, 0, 0, 0, 0, 0, 0, /* 0xfe18 */
4970 "iso-lefttab", /* 0xfe20 */
4971 "iso-move-line-up", "iso-move-line-down",
4972 "iso-partial-line-up", "iso-partial-line-down",
4973 "iso-partial-space-left", "iso-partial-space-right",
4974 "iso-set-margin-left", "iso-set-margin-right", /* 0xffe27, 28 */
4975 "iso-release-margin-left", "iso-release-margin-right",
4976 "iso-release-both-margins",
4977 "iso-fast-cursor-left", "iso-fast-cursor-right",
4978 "iso-fast-cursor-up", "iso-fast-cursor-down",
4979 "iso-continuous-underline", "iso-discontinuous-underline", /* 0xfe30, 31 */
4980 "iso-emphasize", "iso-center-object", "iso-enter", /* ... 0xfe34 */
4983 #endif /* not HAVE_NTGUI */
4985 Lisp_Object Vlispy_mouse_stem
;
4987 static const char *const lispy_wheel_names
[] =
4989 "wheel-up", "wheel-down", "wheel-left", "wheel-right"
4992 /* drag-n-drop events are generated when a set of selected files are
4993 dragged from another application and dropped onto an Emacs window. */
4994 static const char *const lispy_drag_n_drop_names
[] =
4999 /* Scroll bar parts. */
5000 Lisp_Object Qabove_handle
, Qhandle
, Qbelow_handle
;
5001 Lisp_Object Qup
, Qdown
, Qbottom
, Qend_scroll
;
5002 Lisp_Object Qtop
, Qratio
;
5004 /* An array of scroll bar parts, indexed by an enum scroll_bar_part value. */
5005 static Lisp_Object
*const scroll_bar_parts
[] = {
5006 &Qabove_handle
, &Qhandle
, &Qbelow_handle
,
5007 &Qup
, &Qdown
, &Qtop
, &Qbottom
, &Qend_scroll
, &Qratio
5010 /* A vector, indexed by button number, giving the down-going location
5011 of currently depressed buttons, both scroll bar and non-scroll bar.
5013 The elements have the form
5014 (BUTTON-NUMBER MODIFIER-MASK . REST)
5015 where REST is the cdr of a position as it would be reported in the event.
5017 The make_lispy_event function stores positions here to tell the
5018 difference between click and drag events, and to store the starting
5019 location to be included in drag events. */
5021 static Lisp_Object button_down_location
;
5023 /* Information about the most recent up-going button event: Which
5024 button, what location, and what time. */
5026 static int last_mouse_button
;
5027 static int last_mouse_x
;
5028 static int last_mouse_y
;
5029 static unsigned long button_down_time
;
5031 /* The number of clicks in this multiple-click. */
5033 int double_click_count
;
5035 /* X and Y are frame-relative coordinates for a click or wheel event.
5036 Return a Lisp-style event list. */
5039 make_lispy_position (struct frame
*f
, Lisp_Object x
, Lisp_Object y
,
5042 enum window_part part
;
5043 Lisp_Object posn
= Qnil
;
5044 Lisp_Object extra_info
= Qnil
;
5045 /* Coordinate pixel positions to return. */
5046 int xret
= 0, yret
= 0;
5047 /* The window under frame pixel coordinates (x,y) */
5048 Lisp_Object window
= f
5049 ? window_from_coordinates (f
, XINT (x
), XINT (y
), &part
, 0)
5052 if (WINDOWP (window
))
5054 /* It's a click in window window at frame coordinates (x,y) */
5055 struct window
*w
= XWINDOW (window
);
5056 Lisp_Object string_info
= Qnil
;
5057 EMACS_INT textpos
= -1;
5058 int col
= -1, row
= -1;
5059 int dx
= -1, dy
= -1;
5060 int width
= -1, height
= -1;
5061 Lisp_Object object
= Qnil
;
5063 /* Pixel coordinates relative to the window corner. */
5064 int wx
= XINT (x
) - WINDOW_LEFT_EDGE_X (w
);
5065 int wy
= XINT (y
) - WINDOW_TOP_EDGE_Y (w
);
5067 /* For text area clicks, return X, Y relative to the corner of
5068 this text area. Note that dX, dY etc are set below, by
5069 buffer_posn_from_coords. */
5070 if (part
== ON_TEXT
)
5072 xret
= XINT (x
) - window_box_left (w
, TEXT_AREA
);
5073 yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5075 /* For mode line and header line clicks, return X, Y relative to
5076 the left window edge. Use mode_line_string to look for a
5077 string on the click position. */
5078 else if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
5083 posn
= (part
== ON_MODE_LINE
) ? Qmode_line
: Qheader_line
;
5084 /* Note that mode_line_string takes COL, ROW as pixels and
5085 converts them to characters. */
5088 string
= mode_line_string (w
, part
, &col
, &row
, &charpos
,
5089 &object
, &dx
, &dy
, &width
, &height
);
5090 if (STRINGP (string
))
5091 string_info
= Fcons (string
, make_number (charpos
));
5092 textpos
= (w
== XWINDOW (selected_window
)
5093 && current_buffer
== XBUFFER (w
->buffer
))
5094 ? PT
: XMARKER (w
->pointm
)->charpos
;
5099 /* For fringes and margins, Y is relative to the area's (and the
5100 window's) top edge, while X is meaningless. */
5101 else if (part
== ON_LEFT_MARGIN
|| part
== ON_RIGHT_MARGIN
)
5106 posn
= (part
== ON_LEFT_MARGIN
) ? Qleft_margin
: Qright_margin
;
5109 string
= marginal_area_string (w
, part
, &col
, &row
, &charpos
,
5110 &object
, &dx
, &dy
, &width
, &height
);
5111 if (STRINGP (string
))
5112 string_info
= Fcons (string
, make_number (charpos
));
5113 yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5115 else if (part
== ON_LEFT_FRINGE
)
5117 posn
= Qleft_fringe
;
5120 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5121 ? 0 : window_box_width (w
, LEFT_MARGIN_AREA
));
5122 dy
= yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5124 else if (part
== ON_RIGHT_FRINGE
)
5126 posn
= Qright_fringe
;
5129 - window_box_width (w
, LEFT_MARGIN_AREA
)
5130 - window_box_width (w
, TEXT_AREA
)
5131 - (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5132 ? window_box_width (w
, RIGHT_MARGIN_AREA
)
5134 dy
= yret
= wy
- WINDOW_HEADER_LINE_HEIGHT (w
);
5136 else if (part
== ON_VERTICAL_BORDER
)
5138 posn
= Qvertical_line
;
5143 /* Nothing special for part == ON_SCROLL_BAR. */
5145 /* For clicks in the text area, fringes, or margins, call
5146 buffer_posn_from_coords to extract TEXTPOS, the buffer
5147 position nearest to the click. */
5150 Lisp_Object string2
, object2
= Qnil
;
5151 struct display_pos p
;
5153 int width2
, height2
;
5154 /* The pixel X coordinate passed to buffer_posn_from_coords
5155 is the X coordinate relative to the text area for
5156 text-area and right-margin clicks, zero otherwise. */
5158 = (part
== ON_TEXT
) ? xret
5159 : (part
== ON_RIGHT_FRINGE
|| part
== ON_RIGHT_MARGIN
)
5160 ? (XINT (x
) - window_box_left (w
, TEXT_AREA
))
5164 string2
= buffer_posn_from_coords (w
, &x2
, &y2
, &p
,
5165 &object2
, &dx2
, &dy2
,
5167 textpos
= CHARPOS (p
.pos
);
5168 if (col
< 0) col
= x2
;
5169 if (row
< 0) row
= y2
;
5170 if (dx
< 0) dx
= dx2
;
5171 if (dy
< 0) dy
= dy2
;
5172 if (width
< 0) width
= width2
;
5173 if (height
< 0) height
= height2
;
5177 posn
= make_number (textpos
);
5178 if (STRINGP (string2
))
5179 string_info
= Fcons (string2
,
5180 make_number (CHARPOS (p
.string_pos
)));
5186 #ifdef HAVE_WINDOW_SYSTEM
5187 if (IMAGEP (object
))
5189 Lisp_Object image_map
, hotspot
;
5190 if ((image_map
= Fplist_get (XCDR (object
), QCmap
),
5192 && (hotspot
= find_hot_spot (image_map
, dx
, dy
),
5194 && (hotspot
= XCDR (hotspot
), CONSP (hotspot
)))
5195 posn
= XCAR (hotspot
);
5202 Fcons (make_number (dx
), make_number (dy
)),
5203 Fcons (make_number (width
), make_number (height
)));
5206 extra_info
= Fcons (string_info
,
5207 Fcons (make_number (textpos
),
5208 Fcons (Fcons (make_number (col
),
5213 XSETFRAME (window
, f
);
5217 return Fcons (window
,
5219 Fcons (Fcons (make_number (xret
),
5220 make_number (yret
)),
5221 Fcons (make_number (t
),
5225 /* Given a struct input_event, build the lisp event which represents
5226 it. If EVENT is 0, build a mouse movement event from the mouse
5227 movement buffer, which should have a movement event in it.
5229 Note that events must be passed to this function in the order they
5230 are received; this function stores the location of button presses
5231 in order to build drag events when the button is released. */
5234 make_lispy_event (struct input_event
*event
)
5238 switch (SWITCH_ENUM_CAST (event
->kind
))
5240 /* A simple keystroke. */
5241 case ASCII_KEYSTROKE_EVENT
:
5242 case MULTIBYTE_CHAR_KEYSTROKE_EVENT
:
5244 Lisp_Object lispy_c
;
5245 EMACS_INT c
= event
->code
;
5246 if (event
->kind
== ASCII_KEYSTROKE_EVENT
)
5249 eassert (c
== event
->code
);
5250 /* Turn ASCII characters into control characters
5252 if (event
->modifiers
& ctrl_modifier
)
5254 c
= make_ctrl_char (c
);
5255 event
->modifiers
&= ~ctrl_modifier
;
5259 /* Add in the other modifier bits. The shift key was taken care
5260 of by the X code. */
5261 c
|= (event
->modifiers
5262 & (meta_modifier
| alt_modifier
5263 | hyper_modifier
| super_modifier
| ctrl_modifier
));
5264 /* Distinguish Shift-SPC from SPC. */
5265 if ((event
->code
) == 040
5266 && event
->modifiers
& shift_modifier
)
5267 c
|= shift_modifier
;
5268 button_down_time
= 0;
5269 XSETFASTINT (lispy_c
, c
);
5274 /* NS_NONKEY_EVENTs are just like NON_ASCII_KEYSTROKE_EVENTs,
5275 except that they are non-key events (last-nonmenu-event is nil). */
5276 case NS_NONKEY_EVENT
:
5279 /* A function key. The symbol may need to have modifier prefixes
5281 case NON_ASCII_KEYSTROKE_EVENT
:
5282 button_down_time
= 0;
5284 for (i
= 0; i
< sizeof (lispy_accent_codes
) / sizeof (int); i
++)
5285 if (event
->code
== lispy_accent_codes
[i
])
5286 return modify_event_symbol (i
,
5288 Qfunction_key
, Qnil
,
5289 lispy_accent_keys
, &accent_key_syms
,
5290 (sizeof (lispy_accent_keys
)
5291 / sizeof (lispy_accent_keys
[0])));
5295 if (event
->code
>= 0x400 && event
->code
< 0x500)
5296 return modify_event_symbol (event
->code
- 0x400,
5297 event
->modifiers
& ~shift_modifier
,
5298 Qfunction_key
, Qnil
,
5299 lispy_kana_keys
, &func_key_syms
,
5300 (sizeof (lispy_kana_keys
)
5301 / sizeof (lispy_kana_keys
[0])));
5302 #endif /* XK_kana_A */
5305 #ifdef ISO_FUNCTION_KEY_OFFSET
5306 if (event
->code
< FUNCTION_KEY_OFFSET
5307 && event
->code
>= ISO_FUNCTION_KEY_OFFSET
)
5308 return modify_event_symbol (event
->code
- ISO_FUNCTION_KEY_OFFSET
,
5310 Qfunction_key
, Qnil
,
5311 iso_lispy_function_keys
, &func_key_syms
,
5312 (sizeof (iso_lispy_function_keys
)
5313 / sizeof (iso_lispy_function_keys
[0])));
5316 /* Handle system-specific or unknown keysyms. */
5317 if (event
->code
& (1 << 28)
5318 || event
->code
- FUNCTION_KEY_OFFSET
< 0
5319 || (event
->code
- FUNCTION_KEY_OFFSET
5320 >= sizeof lispy_function_keys
/ sizeof *lispy_function_keys
)
5321 || !lispy_function_keys
[event
->code
- FUNCTION_KEY_OFFSET
])
5323 /* We need to use an alist rather than a vector as the cache
5324 since we can't make a vector long enuf. */
5325 if (NILP (KVAR (current_kboard
, system_key_syms
)))
5326 KVAR (current_kboard
, system_key_syms
) = Fcons (Qnil
, Qnil
);
5327 return modify_event_symbol (event
->code
,
5330 KVAR (current_kboard
, Vsystem_key_alist
),
5331 0, &KVAR (current_kboard
, system_key_syms
),
5335 return modify_event_symbol (event
->code
- FUNCTION_KEY_OFFSET
,
5337 Qfunction_key
, Qnil
,
5338 lispy_function_keys
, &func_key_syms
,
5339 (sizeof (lispy_function_keys
)
5340 / sizeof (lispy_function_keys
[0])));
5343 case MULTIMEDIA_KEY_EVENT
:
5344 if (event
->code
< (sizeof (lispy_multimedia_keys
)
5345 / sizeof (lispy_multimedia_keys
[0]))
5346 && event
->code
> 0 && lispy_multimedia_keys
[event
->code
])
5348 return modify_event_symbol (event
->code
, event
->modifiers
,
5349 Qfunction_key
, Qnil
,
5350 lispy_multimedia_keys
, &func_key_syms
,
5351 (sizeof (lispy_multimedia_keys
)
5352 / sizeof (lispy_multimedia_keys
[0])));
5358 /* A mouse click. Figure out where it is, decide whether it's
5359 a press, click or drag, and build the appropriate structure. */
5360 case MOUSE_CLICK_EVENT
:
5361 #ifndef USE_TOOLKIT_SCROLL_BARS
5362 case SCROLL_BAR_CLICK_EVENT
:
5365 int button
= event
->code
;
5367 Lisp_Object position
;
5368 Lisp_Object
*start_pos_ptr
;
5369 Lisp_Object start_pos
;
5373 /* Build the position as appropriate for this mouse click. */
5374 if (event
->kind
== MOUSE_CLICK_EVENT
)
5376 struct frame
*f
= XFRAME (event
->frame_or_window
);
5377 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5381 /* Ignore mouse events that were made on frame that
5382 have been deleted. */
5383 if (! FRAME_LIVE_P (f
))
5386 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK) && ! defined (HAVE_NS)
5387 /* EVENT->x and EVENT->y are frame-relative pixel
5388 coordinates at this place. Under old redisplay, COLUMN
5389 and ROW are set to frame relative glyph coordinates
5390 which are then used to determine whether this click is
5391 in a menu (non-toolkit version). */
5392 pixel_to_glyph_coords (f
, XINT (event
->x
), XINT (event
->y
),
5393 &column
, &row
, NULL
, 1);
5395 /* In the non-toolkit version, clicks on the menu bar
5396 are ordinary button events in the event buffer.
5397 Distinguish them, and invoke the menu.
5399 (In the toolkit version, the toolkit handles the menu bar
5400 and Emacs doesn't know about it until after the user
5401 makes a selection.) */
5402 if (row
>= 0 && row
< FRAME_MENU_BAR_LINES (f
)
5403 && (event
->modifiers
& down_modifier
))
5405 Lisp_Object items
, item
;
5409 /* Find the menu bar item under `column'. */
5411 items
= FRAME_MENU_BAR_ITEMS (f
);
5412 for (i
= 0; i
< XVECTOR (items
)->size
; i
+= 4)
5414 Lisp_Object pos
, string
;
5415 string
= AREF (items
, i
+ 1);
5416 pos
= AREF (items
, i
+ 3);
5419 if (column
>= XINT (pos
)
5420 && column
< XINT (pos
) + SCHARS (string
))
5422 item
= AREF (items
, i
);
5427 /* ELisp manual 2.4b says (x y) are window relative but
5428 code says they are frame-relative. */
5430 = Fcons (event
->frame_or_window
,
5432 Fcons (Fcons (event
->x
, event
->y
),
5433 Fcons (make_number (event
->timestamp
),
5436 return Fcons (item
, Fcons (position
, Qnil
));
5438 #endif /* not USE_X_TOOLKIT && not USE_GTK && not HAVE_NS */
5440 position
= make_lispy_position (f
, event
->x
, event
->y
,
5443 #ifndef USE_TOOLKIT_SCROLL_BARS
5446 /* It's a scrollbar click. */
5448 Lisp_Object portion_whole
;
5451 window
= event
->frame_or_window
;
5452 portion_whole
= Fcons (event
->x
, event
->y
);
5453 part
= *scroll_bar_parts
[(int) event
->part
];
5457 Fcons (Qvertical_scroll_bar
,
5458 Fcons (portion_whole
,
5459 Fcons (make_number (event
->timestamp
),
5460 Fcons (part
, Qnil
)))));
5462 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5464 if (button
>= ASIZE (button_down_location
))
5466 button_down_location
= larger_vector (button_down_location
,
5468 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5471 start_pos_ptr
= &AREF (button_down_location
, button
);
5472 start_pos
= *start_pos_ptr
;
5473 *start_pos_ptr
= Qnil
;
5476 /* On window-system frames, use the value of
5477 double-click-fuzz as is. On other frames, interpret it
5478 as a multiple of 1/8 characters. */
5482 if (WINDOWP (event
->frame_or_window
))
5483 f
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5484 else if (FRAMEP (event
->frame_or_window
))
5485 f
= XFRAME (event
->frame_or_window
);
5489 if (FRAME_WINDOW_P (f
))
5490 fuzz
= double_click_fuzz
;
5492 fuzz
= double_click_fuzz
/ 8;
5494 is_double
= (button
== last_mouse_button
5495 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5496 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5497 && button_down_time
!= 0
5498 && (EQ (Vdouble_click_time
, Qt
)
5499 || (INTEGERP (Vdouble_click_time
)
5500 && ((int)(event
->timestamp
- button_down_time
)
5501 < XINT (Vdouble_click_time
)))));
5504 last_mouse_button
= button
;
5505 last_mouse_x
= XINT (event
->x
);
5506 last_mouse_y
= XINT (event
->y
);
5508 /* If this is a button press, squirrel away the location, so
5509 we can decide later whether it was a click or a drag. */
5510 if (event
->modifiers
& down_modifier
)
5514 double_click_count
++;
5515 event
->modifiers
|= ((double_click_count
> 2)
5520 double_click_count
= 1;
5521 button_down_time
= event
->timestamp
;
5522 *start_pos_ptr
= Fcopy_alist (position
);
5523 ignore_mouse_drag_p
= 0;
5526 /* Now we're releasing a button - check the co-ordinates to
5527 see if this was a click or a drag. */
5528 else if (event
->modifiers
& up_modifier
)
5530 /* If we did not see a down before this up, ignore the up.
5531 Probably this happened because the down event chose a
5532 menu item. It would be an annoyance to treat the
5533 release of the button that chose the menu item as a
5536 if (!CONSP (start_pos
))
5539 event
->modifiers
&= ~up_modifier
;
5542 Lisp_Object new_down
, down
;
5543 EMACS_INT xdiff
= double_click_fuzz
, ydiff
= double_click_fuzz
;
5545 /* The third element of every position
5546 should be the (x,y) pair. */
5547 down
= Fcar (Fcdr (Fcdr (start_pos
)));
5548 new_down
= Fcar (Fcdr (Fcdr (position
)));
5551 && INTEGERP (XCAR (down
)) && INTEGERP (XCDR (down
)))
5553 xdiff
= XINT (XCAR (new_down
)) - XINT (XCAR (down
));
5554 ydiff
= XINT (XCDR (new_down
)) - XINT (XCDR (down
));
5557 if (ignore_mouse_drag_p
)
5559 event
->modifiers
|= click_modifier
;
5560 ignore_mouse_drag_p
= 0;
5562 else if (xdiff
< double_click_fuzz
&& xdiff
> - double_click_fuzz
5563 && ydiff
< double_click_fuzz
&& ydiff
> - double_click_fuzz
5564 /* Maybe the mouse has moved a lot, caused scrolling, and
5565 eventually ended up at the same screen position (but
5566 not buffer position) in which case it is a drag, not
5568 /* FIXME: OTOH if the buffer position has changed
5569 because of a timer or process filter rather than
5570 because of mouse movement, it should be considered as
5571 a click. But mouse-drag-region completely ignores
5572 this case and it hasn't caused any real problem, so
5573 it's probably OK to ignore it as well. */
5574 && EQ (Fcar (Fcdr (start_pos
)), Fcar (Fcdr (position
))))
5575 /* Mouse hasn't moved (much). */
5576 event
->modifiers
|= click_modifier
;
5579 button_down_time
= 0;
5580 event
->modifiers
|= drag_modifier
;
5583 /* Don't check is_double; treat this as multiple
5584 if the down-event was multiple. */
5585 if (double_click_count
> 1)
5586 event
->modifiers
|= ((double_click_count
> 2)
5592 /* Every mouse event should either have the down_modifier or
5593 the up_modifier set. */
5597 /* Get the symbol we should use for the mouse click. */
5600 head
= modify_event_symbol (button
,
5602 Qmouse_click
, Vlispy_mouse_stem
,
5605 XVECTOR (mouse_syms
)->size
);
5606 if (event
->modifiers
& drag_modifier
)
5611 else if (event
->modifiers
& (double_modifier
| triple_modifier
))
5614 Fcons (make_number (double_click_count
),
5624 case HORIZ_WHEEL_EVENT
:
5626 Lisp_Object position
;
5629 /* Build the position as appropriate for this mouse click. */
5630 struct frame
*f
= XFRAME (event
->frame_or_window
);
5632 /* Ignore wheel events that were made on frame that have been
5634 if (! FRAME_LIVE_P (f
))
5637 position
= make_lispy_position (f
, event
->x
, event
->y
,
5640 /* Set double or triple modifiers to indicate the wheel speed. */
5642 /* On window-system frames, use the value of
5643 double-click-fuzz as is. On other frames, interpret it
5644 as a multiple of 1/8 characters. */
5650 if (WINDOWP (event
->frame_or_window
))
5651 fr
= XFRAME (XWINDOW (event
->frame_or_window
)->frame
);
5652 else if (FRAMEP (event
->frame_or_window
))
5653 fr
= XFRAME (event
->frame_or_window
);
5657 fuzz
= FRAME_WINDOW_P (fr
)
5658 ? double_click_fuzz
: double_click_fuzz
/ 8;
5660 if (event
->modifiers
& up_modifier
)
5662 /* Emit a wheel-up event. */
5663 event
->modifiers
&= ~up_modifier
;
5666 else if (event
->modifiers
& down_modifier
)
5668 /* Emit a wheel-down event. */
5669 event
->modifiers
&= ~down_modifier
;
5673 /* Every wheel event should either have the down_modifier or
5674 the up_modifier set. */
5677 if (event
->kind
== HORIZ_WHEEL_EVENT
)
5680 is_double
= (last_mouse_button
== - (1 + symbol_num
)
5681 && (eabs (XINT (event
->x
) - last_mouse_x
) <= fuzz
)
5682 && (eabs (XINT (event
->y
) - last_mouse_y
) <= fuzz
)
5683 && button_down_time
!= 0
5684 && (EQ (Vdouble_click_time
, Qt
)
5685 || (INTEGERP (Vdouble_click_time
)
5686 && ((int)(event
->timestamp
- button_down_time
)
5687 < XINT (Vdouble_click_time
)))));
5690 double_click_count
++;
5691 event
->modifiers
|= ((double_click_count
> 2)
5697 double_click_count
= 1;
5698 event
->modifiers
|= click_modifier
;
5701 button_down_time
= event
->timestamp
;
5702 /* Use a negative value to distinguish wheel from mouse button. */
5703 last_mouse_button
= - (1 + symbol_num
);
5704 last_mouse_x
= XINT (event
->x
);
5705 last_mouse_y
= XINT (event
->y
);
5707 /* Get the symbol we should use for the wheel event. */
5708 head
= modify_event_symbol (symbol_num
,
5714 ASIZE (wheel_syms
));
5717 if (event
->modifiers
& (double_modifier
| triple_modifier
))
5720 Fcons (make_number (double_click_count
),
5729 #ifdef USE_TOOLKIT_SCROLL_BARS
5731 /* We don't have down and up events if using toolkit scroll bars,
5732 so make this always a click event. Store in the `part' of
5733 the Lisp event a symbol which maps to the following actions:
5735 `above_handle' page up
5736 `below_handle' page down
5740 `bottom' bottom of buffer
5741 `handle' thumb has been dragged.
5742 `end-scroll' end of interaction with scroll bar
5744 The incoming input_event contains in its `part' member an
5745 index of type `enum scroll_bar_part' which we can use as an
5746 index in scroll_bar_parts to get the appropriate symbol. */
5748 case SCROLL_BAR_CLICK_EVENT
:
5750 Lisp_Object position
, head
, window
, portion_whole
, part
;
5752 window
= event
->frame_or_window
;
5753 portion_whole
= Fcons (event
->x
, event
->y
);
5754 part
= *scroll_bar_parts
[(int) event
->part
];
5758 Fcons (Qvertical_scroll_bar
,
5759 Fcons (portion_whole
,
5760 Fcons (make_number (event
->timestamp
),
5761 Fcons (part
, Qnil
)))));
5763 /* Always treat scroll bar events as clicks. */
5764 event
->modifiers
|= click_modifier
;
5765 event
->modifiers
&= ~up_modifier
;
5767 if (event
->code
>= ASIZE (mouse_syms
))
5768 mouse_syms
= larger_vector (mouse_syms
, event
->code
+ 1, Qnil
);
5770 /* Get the symbol we should use for the mouse click. */
5771 head
= modify_event_symbol (event
->code
,
5776 XVECTOR (mouse_syms
)->size
);
5777 return Fcons (head
, Fcons (position
, Qnil
));
5780 #endif /* USE_TOOLKIT_SCROLL_BARS */
5782 case DRAG_N_DROP_EVENT
:
5785 Lisp_Object head
, position
;
5788 f
= XFRAME (event
->frame_or_window
);
5791 /* Ignore mouse events that were made on frames that
5792 have been deleted. */
5793 if (! FRAME_LIVE_P (f
))
5796 position
= make_lispy_position (f
, event
->x
, event
->y
,
5799 head
= modify_event_symbol (0, event
->modifiers
,
5801 lispy_drag_n_drop_names
,
5802 &drag_n_drop_syms
, 1);
5808 #endif /* HAVE_MOUSE */
5810 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI) \
5811 || defined(HAVE_NS) || defined (USE_GTK)
5812 case MENU_BAR_EVENT
:
5813 if (EQ (event
->arg
, event
->frame_or_window
))
5814 /* This is the prefix key. We translate this to
5815 `(menu_bar)' because the code in keyboard.c for menu
5816 events, which we use, relies on this. */
5817 return Fcons (Qmenu_bar
, Qnil
);
5821 case SELECT_WINDOW_EVENT
:
5822 /* Make an event (select-window (WINDOW)). */
5823 return Fcons (Qselect_window
,
5824 Fcons (Fcons (event
->frame_or_window
, Qnil
),
5827 case TOOL_BAR_EVENT
:
5828 if (EQ (event
->arg
, event
->frame_or_window
))
5829 /* This is the prefix key. We translate this to
5830 `(tool_bar)' because the code in keyboard.c for tool bar
5831 events, which we use, relies on this. */
5832 return Fcons (Qtool_bar
, Qnil
);
5833 else if (SYMBOLP (event
->arg
))
5834 return apply_modifiers (event
->modifiers
, event
->arg
);
5837 case USER_SIGNAL_EVENT
:
5838 /* A user signal. */
5840 char *name
= find_user_signal_name (event
->code
);
5843 return intern (name
);
5846 case SAVE_SESSION_EVENT
:
5847 return Qsave_session
;
5852 return Fcons (Qdbus_event
, event
->arg
);
5854 #endif /* HAVE_DBUS */
5856 case CONFIG_CHANGED_EVENT
:
5857 return Fcons (Qconfig_changed_event
,
5859 Fcons (event
->frame_or_window
, Qnil
)));
5861 case GPM_CLICK_EVENT
:
5863 FRAME_PTR f
= XFRAME (event
->frame_or_window
);
5864 Lisp_Object head
, position
;
5865 Lisp_Object
*start_pos_ptr
;
5866 Lisp_Object start_pos
;
5867 int button
= event
->code
;
5869 if (button
>= ASIZE (button_down_location
))
5871 button_down_location
= larger_vector (button_down_location
,
5873 mouse_syms
= larger_vector (mouse_syms
, button
+ 1, Qnil
);
5876 start_pos_ptr
= &AREF (button_down_location
, button
);
5877 start_pos
= *start_pos_ptr
;
5879 position
= make_lispy_position (f
, event
->x
, event
->y
,
5882 if (event
->modifiers
& down_modifier
)
5883 *start_pos_ptr
= Fcopy_alist (position
);
5884 else if (event
->modifiers
& (up_modifier
| drag_modifier
))
5886 if (!CONSP (start_pos
))
5888 event
->modifiers
&= ~up_modifier
;
5891 head
= modify_event_symbol (button
,
5893 Qmouse_click
, Vlispy_mouse_stem
,
5896 XVECTOR (mouse_syms
)->size
);
5898 if (event
->modifiers
& drag_modifier
)
5903 else if (event
->modifiers
& double_modifier
)
5906 Fcons (make_number (2),
5908 else if (event
->modifiers
& triple_modifier
)
5911 Fcons (make_number (3),
5918 #endif /* HAVE_GPM */
5920 /* The 'kind' field of the event is something we don't recognize. */
5926 #if defined(HAVE_MOUSE) || defined(HAVE_GPM)
5929 make_lispy_movement (FRAME_PTR frame
, Lisp_Object bar_window
, enum scroll_bar_part part
,
5930 Lisp_Object x
, Lisp_Object y
, unsigned long t
)
5932 /* Is it a scroll bar movement? */
5933 if (frame
&& ! NILP (bar_window
))
5935 Lisp_Object part_sym
;
5937 part_sym
= *scroll_bar_parts
[(int) part
];
5938 return Fcons (Qscroll_bar_movement
,
5939 Fcons (list5 (bar_window
,
5940 Qvertical_scroll_bar
,
5946 /* Or is it an ordinary mouse movement? */
5949 Lisp_Object position
;
5950 position
= make_lispy_position (frame
, x
, y
, t
);
5951 return list2 (Qmouse_movement
, position
);
5955 #endif /* HAVE_MOUSE || HAVE GPM */
5957 /* Construct a switch frame event. */
5959 make_lispy_switch_frame (Lisp_Object frame
)
5961 return Fcons (Qswitch_frame
, Fcons (frame
, Qnil
));
5964 /* Manipulating modifiers. */
5966 /* Parse the name of SYMBOL, and return the set of modifiers it contains.
5968 If MODIFIER_END is non-zero, set *MODIFIER_END to the position in
5969 SYMBOL's name of the end of the modifiers; the string from this
5970 position is the unmodified symbol name.
5972 This doesn't use any caches. */
5975 parse_modifiers_uncached (Lisp_Object symbol
, int *modifier_end
)
5981 CHECK_SYMBOL (symbol
);
5984 name
= SYMBOL_NAME (symbol
);
5986 for (i
= 0; i
+2 <= SBYTES (name
); )
5988 int this_mod_end
= 0;
5991 /* See if the name continues with a modifier word.
5992 Check that the word appears, but don't check what follows it.
5993 Set this_mod and this_mod_end to record what we find. */
5995 switch (SREF (name
, i
))
5997 #define SINGLE_LETTER_MOD(BIT) \
5998 (this_mod_end = i + 1, this_mod = BIT)
6001 SINGLE_LETTER_MOD (alt_modifier
);
6005 SINGLE_LETTER_MOD (ctrl_modifier
);
6009 SINGLE_LETTER_MOD (hyper_modifier
);
6013 SINGLE_LETTER_MOD (meta_modifier
);
6017 SINGLE_LETTER_MOD (shift_modifier
);
6021 SINGLE_LETTER_MOD (super_modifier
);
6024 #undef SINGLE_LETTER_MOD
6026 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6027 if (i + LEN + 1 <= SBYTES (name) \
6028 && ! strncmp (SSDATA (name) + i, NAME, LEN)) \
6030 this_mod_end = i + LEN; \
6035 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6036 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6037 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6041 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6043 #undef MULTI_LETTER_MOD
6047 /* If we found no modifier, stop looking for them. */
6048 if (this_mod_end
== 0)
6051 /* Check there is a dash after the modifier, so that it
6052 really is a modifier. */
6053 if (this_mod_end
>= SBYTES (name
)
6054 || SREF (name
, this_mod_end
) != '-')
6057 /* This modifier is real; look for another. */
6058 modifiers
|= this_mod
;
6059 i
= this_mod_end
+ 1;
6062 /* Should we include the `click' modifier? */
6063 if (! (modifiers
& (down_modifier
| drag_modifier
6064 | double_modifier
| triple_modifier
))
6065 && i
+ 7 == SBYTES (name
)
6066 && strncmp (SSDATA (name
) + i
, "mouse-", 6) == 0
6067 && ('0' <= SREF (name
, i
+ 6) && SREF (name
, i
+ 6) <= '9'))
6068 modifiers
|= click_modifier
;
6070 if (! (modifiers
& (double_modifier
| triple_modifier
))
6071 && i
+ 6 < SBYTES (name
)
6072 && strncmp (SSDATA (name
) + i
, "wheel-", 6) == 0)
6073 modifiers
|= click_modifier
;
6081 /* Return a symbol whose name is the modifier prefixes for MODIFIERS
6082 prepended to the string BASE[0..BASE_LEN-1].
6083 This doesn't use any caches. */
6085 apply_modifiers_uncached (int modifiers
, char *base
, int base_len
, int base_len_byte
)
6087 /* Since BASE could contain nulls, we can't use intern here; we have
6088 to use Fintern, which expects a genuine Lisp_String, and keeps a
6091 = (char *) alloca (sizeof ("A-C-H-M-S-s-down-drag-double-triple-"));
6097 /* Only the event queue may use the `up' modifier; it should always
6098 be turned into a click or drag event before presented to lisp code. */
6099 if (modifiers
& up_modifier
)
6102 if (modifiers
& alt_modifier
) { *p
++ = 'A'; *p
++ = '-'; }
6103 if (modifiers
& ctrl_modifier
) { *p
++ = 'C'; *p
++ = '-'; }
6104 if (modifiers
& hyper_modifier
) { *p
++ = 'H'; *p
++ = '-'; }
6105 if (modifiers
& meta_modifier
) { *p
++ = 'M'; *p
++ = '-'; }
6106 if (modifiers
& shift_modifier
) { *p
++ = 'S'; *p
++ = '-'; }
6107 if (modifiers
& super_modifier
) { *p
++ = 's'; *p
++ = '-'; }
6108 if (modifiers
& double_modifier
) { strcpy (p
, "double-"); p
+= 7; }
6109 if (modifiers
& triple_modifier
) { strcpy (p
, "triple-"); p
+= 7; }
6110 if (modifiers
& down_modifier
) { strcpy (p
, "down-"); p
+= 5; }
6111 if (modifiers
& drag_modifier
) { strcpy (p
, "drag-"); p
+= 5; }
6112 /* The click modifier is denoted by the absence of other modifiers. */
6116 mod_len
= p
- new_mods
;
6120 Lisp_Object new_name
;
6122 new_name
= make_uninit_multibyte_string (mod_len
+ base_len
,
6123 mod_len
+ base_len_byte
);
6124 memcpy (SDATA (new_name
), new_mods
, mod_len
);
6125 memcpy (SDATA (new_name
) + mod_len
, base
, base_len_byte
);
6127 return Fintern (new_name
, Qnil
);
6132 static const char *const modifier_names
[] =
6134 "up", "down", "drag", "click", "double", "triple", 0, 0,
6135 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
6136 0, 0, "alt", "super", "hyper", "shift", "control", "meta"
6138 #define NUM_MOD_NAMES (sizeof (modifier_names) / sizeof (modifier_names[0]))
6140 static Lisp_Object modifier_symbols
;
6142 /* Return the list of modifier symbols corresponding to the mask MODIFIERS. */
6144 lispy_modifier_list (int modifiers
)
6146 Lisp_Object modifier_list
;
6149 modifier_list
= Qnil
;
6150 for (i
= 0; (1<<i
) <= modifiers
&& i
< NUM_MOD_NAMES
; i
++)
6151 if (modifiers
& (1<<i
))
6152 modifier_list
= Fcons (XVECTOR (modifier_symbols
)->contents
[i
],
6155 return modifier_list
;
6159 /* Parse the modifiers on SYMBOL, and return a list like (UNMODIFIED MASK),
6160 where UNMODIFIED is the unmodified form of SYMBOL,
6161 MASK is the set of modifiers present in SYMBOL's name.
6162 This is similar to parse_modifiers_uncached, but uses the cache in
6163 SYMBOL's Qevent_symbol_element_mask property, and maintains the
6164 Qevent_symbol_elements property. */
6166 #define KEY_TO_CHAR(k) (XINT (k) & ((1 << CHARACTERBITS) - 1))
6169 parse_modifiers (Lisp_Object symbol
)
6171 Lisp_Object elements
;
6173 if (INTEGERP (symbol
))
6174 return (Fcons (make_number (KEY_TO_CHAR (symbol
)),
6175 Fcons (make_number (XINT (symbol
) & CHAR_MODIFIER_MASK
),
6177 else if (!SYMBOLP (symbol
))
6180 elements
= Fget (symbol
, Qevent_symbol_element_mask
);
6181 if (CONSP (elements
))
6186 int modifiers
= parse_modifiers_uncached (symbol
, &end
);
6187 Lisp_Object unmodified
;
6190 unmodified
= Fintern (make_string (SSDATA (SYMBOL_NAME (symbol
)) + end
,
6191 SBYTES (SYMBOL_NAME (symbol
)) - end
),
6194 if (modifiers
& ~INTMASK
)
6196 XSETFASTINT (mask
, modifiers
);
6197 elements
= Fcons (unmodified
, Fcons (mask
, Qnil
));
6199 /* Cache the parsing results on SYMBOL. */
6200 Fput (symbol
, Qevent_symbol_element_mask
,
6202 Fput (symbol
, Qevent_symbol_elements
,
6203 Fcons (unmodified
, lispy_modifier_list (modifiers
)));
6205 /* Since we know that SYMBOL is modifiers applied to unmodified,
6206 it would be nice to put that in unmodified's cache.
6207 But we can't, since we're not sure that parse_modifiers is
6214 DEFUN ("internal-event-symbol-parse-modifiers", Fevent_symbol_parse_modifiers
,
6215 Sevent_symbol_parse_modifiers
, 1, 1, 0,
6216 doc
: /* Parse the event symbol. For internal use. */)
6217 (Lisp_Object symbol
)
6219 /* Fill the cache if needed. */
6220 parse_modifiers (symbol
);
6221 /* Ignore the result (which is stored on Qevent_symbol_element_mask)
6222 and use the Lispier representation stored on Qevent_symbol_elements
6224 return Fget (symbol
, Qevent_symbol_elements
);
6227 /* Apply the modifiers MODIFIERS to the symbol BASE.
6228 BASE must be unmodified.
6230 This is like apply_modifiers_uncached, but uses BASE's
6231 Qmodifier_cache property, if present. It also builds
6232 Qevent_symbol_elements properties, since it has that info anyway.
6234 apply_modifiers copies the value of BASE's Qevent_kind property to
6235 the modified symbol. */
6237 apply_modifiers (int modifiers
, Lisp_Object base
)
6239 Lisp_Object cache
, idx
, entry
, new_symbol
;
6241 /* Mask out upper bits. We don't know where this value's been. */
6242 modifiers
&= INTMASK
;
6244 if (INTEGERP (base
))
6245 return make_number (XINT (base
) | modifiers
);
6247 /* The click modifier never figures into cache indices. */
6248 cache
= Fget (base
, Qmodifier_cache
);
6249 XSETFASTINT (idx
, (modifiers
& ~click_modifier
));
6250 entry
= assq_no_quit (idx
, cache
);
6253 new_symbol
= XCDR (entry
);
6256 /* We have to create the symbol ourselves. */
6257 new_symbol
= apply_modifiers_uncached (modifiers
,
6258 SSDATA (SYMBOL_NAME (base
)),
6259 SCHARS (SYMBOL_NAME (base
)),
6260 SBYTES (SYMBOL_NAME (base
)));
6262 /* Add the new symbol to the base's cache. */
6263 entry
= Fcons (idx
, new_symbol
);
6264 Fput (base
, Qmodifier_cache
, Fcons (entry
, cache
));
6266 /* We have the parsing info now for free, so we could add it to
6268 XSETFASTINT (idx, modifiers);
6269 Fput (new_symbol, Qevent_symbol_element_mask,
6270 Fcons (base, Fcons (idx, Qnil)));
6271 Fput (new_symbol, Qevent_symbol_elements,
6272 Fcons (base, lispy_modifier_list (modifiers)));
6273 Sadly, this is only correct if `base' is indeed a base event,
6274 which is not necessarily the case. -stef */
6277 /* Make sure this symbol is of the same kind as BASE.
6279 You'd think we could just set this once and for all when we
6280 intern the symbol above, but reorder_modifiers may call us when
6281 BASE's property isn't set right; we can't assume that just
6282 because it has a Qmodifier_cache property it must have its
6283 Qevent_kind set right as well. */
6284 if (NILP (Fget (new_symbol
, Qevent_kind
)))
6288 kind
= Fget (base
, Qevent_kind
);
6290 Fput (new_symbol
, Qevent_kind
, kind
);
6297 /* Given a symbol whose name begins with modifiers ("C-", "M-", etc),
6298 return a symbol with the modifiers placed in the canonical order.
6299 Canonical order is alphabetical, except for down and drag, which
6300 always come last. The 'click' modifier is never written out.
6302 Fdefine_key calls this to make sure that (for example) C-M-foo
6303 and M-C-foo end up being equivalent in the keymap. */
6306 reorder_modifiers (Lisp_Object symbol
)
6308 /* It's hopefully okay to write the code this way, since everything
6309 will soon be in caches, and no consing will be done at all. */
6312 parsed
= parse_modifiers (symbol
);
6313 return apply_modifiers ((int) XINT (XCAR (XCDR (parsed
))),
6318 /* For handling events, we often want to produce a symbol whose name
6319 is a series of modifier key prefixes ("M-", "C-", etcetera) attached
6320 to some base, like the name of a function key or mouse button.
6321 modify_event_symbol produces symbols of this sort.
6323 NAME_TABLE should point to an array of strings, such that NAME_TABLE[i]
6324 is the name of the i'th symbol. TABLE_SIZE is the number of elements
6327 Alternatively, NAME_ALIST_OR_STEM is either an alist mapping codes
6328 into symbol names, or a string specifying a name stem used to
6329 construct a symbol name or the form `STEM-N', where N is the decimal
6330 representation of SYMBOL_NUM. NAME_ALIST_OR_STEM is used if it is
6331 non-nil; otherwise NAME_TABLE is used.
6333 SYMBOL_TABLE should be a pointer to a Lisp_Object whose value will
6334 persist between calls to modify_event_symbol that it can use to
6335 store a cache of the symbols it's generated for this NAME_TABLE
6336 before. The object stored there may be a vector or an alist.
6338 SYMBOL_NUM is the number of the base name we want from NAME_TABLE.
6340 MODIFIERS is a set of modifier bits (as given in struct input_events)
6341 whose prefixes should be applied to the symbol name.
6343 SYMBOL_KIND is the value to be placed in the event_kind property of
6344 the returned symbol.
6346 The symbols we create are supposed to have an
6347 `event-symbol-elements' property, which lists the modifiers present
6348 in the symbol's name. */
6351 modify_event_symbol (EMACS_INT symbol_num
, unsigned int modifiers
, Lisp_Object symbol_kind
,
6352 Lisp_Object name_alist_or_stem
, const char *const *name_table
,
6353 Lisp_Object
*symbol_table
, unsigned int table_size
)
6356 Lisp_Object symbol_int
;
6358 /* Get rid of the "vendor-specific" bit here. */
6359 XSETINT (symbol_int
, symbol_num
& 0xffffff);
6361 /* Is this a request for a valid symbol? */
6362 if (symbol_num
< 0 || symbol_num
>= table_size
)
6365 if (CONSP (*symbol_table
))
6366 value
= Fcdr (assq_no_quit (symbol_int
, *symbol_table
));
6368 /* If *symbol_table doesn't seem to be initialized properly, fix that.
6369 *symbol_table should be a lisp vector TABLE_SIZE elements long,
6370 where the Nth element is the symbol for NAME_TABLE[N], or nil if
6371 we've never used that symbol before. */
6374 if (! VECTORP (*symbol_table
)
6375 || XVECTOR (*symbol_table
)->size
!= table_size
)
6379 XSETFASTINT (size
, table_size
);
6380 *symbol_table
= Fmake_vector (size
, Qnil
);
6383 value
= XVECTOR (*symbol_table
)->contents
[symbol_num
];
6386 /* Have we already used this symbol before? */
6389 /* No; let's create it. */
6390 if (CONSP (name_alist_or_stem
))
6391 value
= Fcdr_safe (Fassq (symbol_int
, name_alist_or_stem
));
6392 else if (STRINGP (name_alist_or_stem
))
6394 int len
= SBYTES (name_alist_or_stem
);
6395 char *buf
= (char *) alloca (len
+ 50);
6396 sprintf (buf
, "%s-%ld", SDATA (name_alist_or_stem
),
6397 (long) XINT (symbol_int
) + 1);
6398 value
= intern (buf
);
6400 else if (name_table
!= 0 && name_table
[symbol_num
])
6401 value
= intern (name_table
[symbol_num
]);
6403 #ifdef HAVE_WINDOW_SYSTEM
6406 char *name
= x_get_keysym_name (symbol_num
);
6408 value
= intern (name
);
6415 sprintf (buf
, "key-%ld", (long)symbol_num
);
6416 value
= intern (buf
);
6419 if (CONSP (*symbol_table
))
6420 *symbol_table
= Fcons (Fcons (symbol_int
, value
), *symbol_table
);
6422 XVECTOR (*symbol_table
)->contents
[symbol_num
] = value
;
6424 /* Fill in the cache entries for this symbol; this also
6425 builds the Qevent_symbol_elements property, which the user
6427 apply_modifiers (modifiers
& click_modifier
, value
);
6428 Fput (value
, Qevent_kind
, symbol_kind
);
6431 /* Apply modifiers to that symbol. */
6432 return apply_modifiers (modifiers
, value
);
6435 /* Convert a list that represents an event type,
6436 such as (ctrl meta backspace), into the usual representation of that
6437 event type as a number or a symbol. */
6439 DEFUN ("event-convert-list", Fevent_convert_list
, Sevent_convert_list
, 1, 1, 0,
6440 doc
: /* Convert the event description list EVENT-DESC to an event type.
6441 EVENT-DESC should contain one base event type (a character or symbol)
6442 and zero or more modifier names (control, meta, hyper, super, shift, alt,
6443 drag, down, double or triple). The base must be last.
6444 The return value is an event type (a character or symbol) which
6445 has the same base event type and all the specified modifiers. */)
6446 (Lisp_Object event_desc
)
6454 while (CONSP (rest
))
6462 /* Given a symbol, see if it is a modifier name. */
6463 if (SYMBOLP (elt
) && CONSP (rest
))
6464 this = parse_solitary_modifier (elt
);
6468 else if (!NILP (base
))
6469 error ("Two bases given in one event");
6475 /* Let the symbol A refer to the character A. */
6476 if (SYMBOLP (base
) && SCHARS (SYMBOL_NAME (base
)) == 1)
6477 XSETINT (base
, SREF (SYMBOL_NAME (base
), 0));
6479 if (INTEGERP (base
))
6481 /* Turn (shift a) into A. */
6482 if ((modifiers
& shift_modifier
) != 0
6483 && (XINT (base
) >= 'a' && XINT (base
) <= 'z'))
6485 XSETINT (base
, XINT (base
) - ('a' - 'A'));
6486 modifiers
&= ~shift_modifier
;
6489 /* Turn (control a) into C-a. */
6490 if (modifiers
& ctrl_modifier
)
6491 return make_number ((modifiers
& ~ctrl_modifier
)
6492 | make_ctrl_char (XINT (base
)));
6494 return make_number (modifiers
| XINT (base
));
6496 else if (SYMBOLP (base
))
6497 return apply_modifiers (modifiers
, base
);
6500 error ("Invalid base event");
6505 /* Try to recognize SYMBOL as a modifier name.
6506 Return the modifier flag bit, or 0 if not recognized. */
6509 parse_solitary_modifier (Lisp_Object symbol
)
6511 Lisp_Object name
= SYMBOL_NAME (symbol
);
6513 switch (SREF (name
, 0))
6515 #define SINGLE_LETTER_MOD(BIT) \
6516 if (SBYTES (name) == 1) \
6519 #define MULTI_LETTER_MOD(BIT, NAME, LEN) \
6520 if (LEN == SBYTES (name) \
6521 && ! strncmp (SSDATA (name), NAME, LEN)) \
6525 SINGLE_LETTER_MOD (alt_modifier
);
6529 MULTI_LETTER_MOD (alt_modifier
, "alt", 3);
6533 SINGLE_LETTER_MOD (ctrl_modifier
);
6537 MULTI_LETTER_MOD (ctrl_modifier
, "ctrl", 4);
6538 MULTI_LETTER_MOD (ctrl_modifier
, "control", 7);
6542 SINGLE_LETTER_MOD (hyper_modifier
);
6546 MULTI_LETTER_MOD (hyper_modifier
, "hyper", 5);
6550 SINGLE_LETTER_MOD (meta_modifier
);
6554 MULTI_LETTER_MOD (meta_modifier
, "meta", 4);
6558 SINGLE_LETTER_MOD (shift_modifier
);
6562 MULTI_LETTER_MOD (shift_modifier
, "shift", 5);
6563 MULTI_LETTER_MOD (super_modifier
, "super", 5);
6564 SINGLE_LETTER_MOD (super_modifier
);
6568 MULTI_LETTER_MOD (drag_modifier
, "drag", 4);
6569 MULTI_LETTER_MOD (down_modifier
, "down", 4);
6570 MULTI_LETTER_MOD (double_modifier
, "double", 6);
6574 MULTI_LETTER_MOD (triple_modifier
, "triple", 6);
6577 #undef SINGLE_LETTER_MOD
6578 #undef MULTI_LETTER_MOD
6584 /* Return 1 if EVENT is a list whose elements are all integers or symbols.
6585 Such a list is not valid as an event,
6586 but it can be a Lucid-style event type list. */
6589 lucid_event_type_list_p (Lisp_Object object
)
6593 if (! CONSP (object
))
6596 if (EQ (XCAR (object
), Qhelp_echo
)
6597 || EQ (XCAR (object
), Qvertical_line
)
6598 || EQ (XCAR (object
), Qmode_line
)
6599 || EQ (XCAR (object
), Qheader_line
))
6602 for (tail
= object
; CONSP (tail
); tail
= XCDR (tail
))
6606 if (! (INTEGERP (elt
) || SYMBOLP (elt
)))
6613 /* Store into *addr a value nonzero if terminal input chars are available.
6614 Serves the purpose of ioctl (0, FIONREAD, addr)
6615 but works even if FIONREAD does not exist.
6616 (In fact, this may actually read some input.)
6618 If READABLE_EVENTS_DO_TIMERS_NOW is set in FLAGS, actually run
6619 timer events that are ripe.
6620 If READABLE_EVENTS_FILTER_EVENTS is set in FLAGS, ignore internal
6621 events (FOCUS_IN_EVENT).
6622 If READABLE_EVENTS_IGNORE_SQUEEZABLES is set in FLAGS, ignore mouse
6623 movements and toolkit scroll bar thumb drags. */
6626 get_input_pending (int *addr
, int flags
)
6628 /* First of all, have we already counted some input? */
6629 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6631 /* If input is being read as it arrives, and we have none, there is none. */
6632 if (*addr
> 0 || (interrupt_input
&& ! interrupts_deferred
))
6635 /* Try to read some input and see how much we get. */
6637 *addr
= (!NILP (Vquit_flag
) || readable_events (flags
));
6640 /* Interface to read_avail_input, blocking SIGIO or SIGALRM if necessary. */
6643 gobble_input (int expected
)
6646 if (interrupt_input
)
6649 mask
= sigblock (sigmask (SIGIO
));
6650 read_avail_input (expected
);
6654 #ifdef POLL_FOR_INPUT
6655 /* XXX This condition was (read_socket_hook && !interrupt_input),
6656 but read_socket_hook is not global anymore. Let's pretend that
6658 if (!interrupt_input
&& poll_suppress_count
== 0)
6661 mask
= sigblock (sigmask (SIGALRM
));
6662 read_avail_input (expected
);
6668 read_avail_input (expected
);
6671 /* Put a BUFFER_SWITCH_EVENT in the buffer
6672 so that read_key_sequence will notice the new current buffer. */
6675 record_asynch_buffer_change (void)
6677 struct input_event event
;
6681 event
.kind
= BUFFER_SWITCH_EVENT
;
6682 event
.frame_or_window
= Qnil
;
6685 /* We don't need a buffer-switch event unless Emacs is waiting for input.
6686 The purpose of the event is to make read_key_sequence look up the
6687 keymaps again. If we aren't in read_key_sequence, we don't need one,
6688 and the event could cause trouble by messing up (input-pending-p).
6689 Note: Fwaiting_for_user_input_p always returns nil when async
6690 subprocesses aren't supported. */
6691 tem
= Fwaiting_for_user_input_p ();
6695 /* Make sure no interrupt happens while storing the event. */
6697 if (interrupt_input
)
6700 mask
= sigblock (sigmask (SIGIO
));
6701 kbd_buffer_store_event (&event
);
6708 kbd_buffer_store_event (&event
);
6713 /* Read any terminal input already buffered up by the system
6714 into the kbd_buffer, but do not wait.
6716 EXPECTED should be nonzero if the caller knows there is some input.
6718 Returns the number of keyboard chars read, or -1 meaning
6719 this is a bad time to try to read input. */
6722 read_avail_input (int expected
)
6728 /* Store pending user signal events, if any. */
6729 if (store_user_signal_events ())
6732 /* Loop through the available terminals, and call their input hooks. */
6736 struct terminal
*next
= t
->next_terminal
;
6738 if (t
->read_socket_hook
)
6741 struct input_event hold_quit
;
6743 EVENT_INIT (hold_quit
);
6744 hold_quit
.kind
= NO_EVENT
;
6746 /* No need for FIONREAD or fcntl; just say don't wait. */
6747 while (nr
= (*t
->read_socket_hook
) (t
, expected
, &hold_quit
), nr
> 0)
6753 if (nr
== -1) /* Not OK to read input now. */
6757 else if (nr
== -2) /* Non-transient error. */
6759 /* The terminal device terminated; it should be closed. */
6761 /* Kill Emacs if this was our last terminal. */
6762 if (!terminal_list
->next_terminal
)
6763 /* Formerly simply reported no input, but that
6764 sometimes led to a failure of Emacs to terminate.
6765 SIGHUP seems appropriate if we can't reach the
6767 /* ??? Is it really right to send the signal just to
6768 this process rather than to the whole process
6769 group? Perhaps on systems with FIONREAD Emacs is
6770 alone in its group. */
6771 kill (getpid (), SIGHUP
);
6773 /* XXX Is calling delete_terminal safe here? It calls delete_frame. */
6776 XSETTERMINAL (tmp
, t
);
6777 Fdelete_terminal (tmp
, Qnoelisp
);
6781 if (hold_quit
.kind
!= NO_EVENT
)
6782 kbd_buffer_store_event (&hold_quit
);
6791 frame_make_pointer_visible ();
6797 decode_keyboard_code (struct tty_display_info
*tty
,
6798 struct coding_system
*coding
,
6799 unsigned char *buf
, int nbytes
)
6801 unsigned char *src
= buf
;
6802 const unsigned char *p
;
6807 if (tty
->meta_key
!= 2)
6808 for (i
= 0; i
< nbytes
; i
++)
6810 if (coding
->carryover_bytes
> 0)
6812 src
= alloca (coding
->carryover_bytes
+ nbytes
);
6813 memcpy (src
, coding
->carryover
, coding
->carryover_bytes
);
6814 memcpy (src
+ coding
->carryover_bytes
, buf
, nbytes
);
6815 nbytes
+= coding
->carryover_bytes
;
6817 coding
->destination
= alloca (nbytes
* 4);
6818 coding
->dst_bytes
= nbytes
* 4;
6819 decode_coding_c_string (coding
, src
, nbytes
, Qnil
);
6820 if (coding
->produced_char
== 0)
6822 for (i
= 0, p
= coding
->destination
; i
< coding
->produced_char
; i
++)
6824 struct input_event event_buf
;
6826 EVENT_INIT (event_buf
);
6827 event_buf
.code
= STRING_CHAR_ADVANCE (p
);
6829 (ASCII_CHAR_P (event_buf
.code
)
6830 ? ASCII_KEYSTROKE_EVENT
: MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6831 /* See the comment in tty_read_avail_input. */
6832 event_buf
.frame_or_window
= tty
->top_frame
;
6833 event_buf
.arg
= Qnil
;
6834 kbd_buffer_store_event (&event_buf
);
6838 /* This is the tty way of reading available input.
6840 Note that each terminal device has its own `struct terminal' object,
6841 and so this function is called once for each individual termcap
6842 terminal. The first parameter indicates which terminal to read from. */
6845 tty_read_avail_input (struct terminal
*terminal
,
6847 struct input_event
*hold_quit
)
6849 /* Using KBD_BUFFER_SIZE - 1 here avoids reading more than
6850 the kbd_buffer can really hold. That may prevent loss
6851 of characters on some systems when input is stuffed at us. */
6852 unsigned char cbuf
[KBD_BUFFER_SIZE
- 1];
6854 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
6857 int buffer_free
= KBD_BUFFER_SIZE
- kbd_buffer_nr_stored () - 1;
6859 if (kbd_on_hold_p () || buffer_free
<= 0)
6861 #endif /* subprocesses */
6863 if (!terminal
->name
) /* Don't read from a dead terminal. */
6866 if (terminal
->type
!= output_termcap
6867 && terminal
->type
!= output_msdos_raw
)
6870 /* XXX I think the following code should be moved to separate hook
6871 functions in system-dependent files. */
6874 #else /* not WINDOWSNT */
6875 if (! tty
->term_initted
) /* In case we get called during bootstrap. */
6879 return 0; /* The terminal is suspended. */
6882 n_to_read
= dos_keysns ();
6886 cbuf
[0] = dos_keyread ();
6889 #else /* not MSDOS */
6894 struct input_event gpm_hold_quit
;
6895 int gpm
, fd
= gpm_fd
;
6897 EVENT_INIT (gpm_hold_quit
);
6898 gpm_hold_quit
.kind
= NO_EVENT
;
6900 /* gpm==1 if event received.
6901 gpm==0 if the GPM daemon has closed the connection, in which case
6902 Gpm_GetEvent closes gpm_fd and clears it to -1, which is why
6903 we save it in `fd' so close_gpm can remove it from the
6905 gpm==-1 if a protocol error or EWOULDBLOCK; the latter is normal. */
6906 while (gpm
= Gpm_GetEvent (&event
), gpm
== 1) {
6907 nread
+= handle_one_term_event (tty
, &event
, &gpm_hold_quit
);
6910 /* Presumably the GPM daemon has closed the connection. */
6912 if (gpm_hold_quit
.kind
!= NO_EVENT
)
6913 kbd_buffer_store_event (&gpm_hold_quit
);
6917 #endif /* HAVE_GPM */
6919 /* Determine how many characters we should *try* to read. */
6921 /* Find out how much input is available. */
6922 if (ioctl (fileno (tty
->input
), FIONREAD
, &n_to_read
) < 0)
6924 if (! noninteractive
)
6925 return -2; /* Close this terminal. */
6931 if (n_to_read
> sizeof cbuf
)
6932 n_to_read
= sizeof cbuf
;
6933 #else /* no FIONREAD */
6934 #if defined (USG) || defined(CYGWIN)
6935 /* Read some input if available, but don't wait. */
6936 n_to_read
= sizeof cbuf
;
6937 fcntl (fileno (tty
->input
), F_SETFL
, O_NDELAY
);
6944 /* Don't read more than we can store. */
6945 if (n_to_read
> buffer_free
)
6946 n_to_read
= buffer_free
;
6947 #endif /* subprocesses */
6949 /* Now read; for one reason or another, this will not block.
6950 NREAD is set to the number of chars read. */
6953 nread
= emacs_read (fileno (tty
->input
), (char *) cbuf
, n_to_read
);
6954 /* POSIX infers that processes which are not in the session leader's
6955 process group won't get SIGHUP's at logout time. BSDI adheres to
6956 this part standard and returns -1 from read (0) with errno==EIO
6957 when the control tty is taken away.
6958 Jeffrey Honig <jch@bsdi.com> says this is generally safe. */
6959 if (nread
== -1 && errno
== EIO
)
6960 return -2; /* Close this terminal. */
6961 #if defined (AIX) && defined (_BSD)
6962 /* The kernel sometimes fails to deliver SIGHUP for ptys.
6963 This looks incorrect, but it isn't, because _BSD causes
6964 O_NDELAY to be defined in fcntl.h as O_NONBLOCK,
6965 and that causes a value other than 0 when there is no input. */
6967 return -2; /* Close this terminal. */
6971 /* We used to retry the read if it was interrupted.
6972 But this does the wrong thing when O_NDELAY causes
6973 an EAGAIN error. Does anybody know of a situation
6974 where a retry is actually needed? */
6976 nread
< 0 && (errno
== EAGAIN
6990 #if defined (USG) || defined (CYGWIN)
6991 fcntl (fileno (tty
->input
), F_SETFL
, 0);
6992 #endif /* USG or CYGWIN */
6993 #endif /* no FIONREAD */
6998 #endif /* not MSDOS */
6999 #endif /* not WINDOWSNT */
7001 if (TERMINAL_KEYBOARD_CODING (terminal
)->common_flags
7002 & CODING_REQUIRE_DECODING_MASK
)
7004 struct coding_system
*coding
= TERMINAL_KEYBOARD_CODING (terminal
);
7007 /* Decode the key sequence except for those with meta
7009 for (i
= from
= 0; ; i
++)
7010 if (i
== nread
|| (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80)))
7012 struct input_event buf
;
7014 decode_keyboard_code (tty
, coding
, cbuf
+ from
, i
- from
);
7019 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7020 buf
.modifiers
= meta_modifier
;
7021 buf
.code
= cbuf
[i
] & ~0x80;
7022 /* See the comment below. */
7023 buf
.frame_or_window
= tty
->top_frame
;
7025 kbd_buffer_store_event (&buf
);
7031 for (i
= 0; i
< nread
; i
++)
7033 struct input_event buf
;
7035 buf
.kind
= ASCII_KEYSTROKE_EVENT
;
7037 if (tty
->meta_key
== 1 && (cbuf
[i
] & 0x80))
7038 buf
.modifiers
= meta_modifier
;
7039 if (tty
->meta_key
!= 2)
7043 /* Set the frame corresponding to the active tty. Note that the
7044 value of selected_frame is not reliable here, redisplay tends
7045 to temporarily change it. */
7046 buf
.frame_or_window
= tty
->top_frame
;
7049 kbd_buffer_store_event (&buf
);
7050 /* Don't look at input that follows a C-g too closely.
7051 This reduces lossage due to autorepeat on C-g. */
7052 if (buf
.kind
== ASCII_KEYSTROKE_EVENT
7053 && buf
.code
== quit_char
)
7061 handle_async_input (void)
7063 interrupt_input_pending
= 0;
7065 pending_signals
= pending_atimers
;
7067 /* Tell ns_read_socket() it is being called asynchronously so it can avoid
7068 doing anything dangerous. */
7075 nread
= read_avail_input (1);
7076 /* -1 means it's not ok to read the input now.
7077 UNBLOCK_INPUT will read it later; now, avoid infinite loop.
7078 0 means there was no keyboard input available. */
7088 process_pending_signals (void)
7090 if (interrupt_input_pending
)
7091 handle_async_input ();
7092 do_pending_atimers ();
7095 #ifdef SIGIO /* for entire page */
7096 /* Note SIGIO has been undef'd if FIONREAD is missing. */
7099 input_available_signal (int signo
)
7101 /* Must preserve main program's value of errno. */
7102 int old_errno
= errno
;
7103 SIGNAL_THREAD_CHECK (signo
);
7106 interrupt_input_pending
= 1;
7107 pending_signals
= 1;
7110 if (input_available_clear_time
)
7111 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7114 handle_async_input ();
7121 /* Send ourselves a SIGIO.
7123 This function exists so that the UNBLOCK_INPUT macro in
7124 blockinput.h can have some way to take care of input we put off
7125 dealing with, without assuming that every file which uses
7126 UNBLOCK_INPUT also has #included the files necessary to get SIGIO. */
7128 reinvoke_input_signal (void)
7131 handle_async_input ();
7137 /* User signal events. */
7139 struct user_signal_info
7141 /* Signal number. */
7144 /* Name of the signal. */
7147 /* Number of pending signals. */
7150 struct user_signal_info
*next
;
7153 /* List of user signals. */
7154 static struct user_signal_info
*user_signals
= NULL
;
7157 add_user_signal (int sig
, const char *name
)
7159 struct user_signal_info
*p
;
7161 for (p
= user_signals
; p
; p
= p
->next
)
7163 /* Already added. */
7166 p
= xmalloc (sizeof (struct user_signal_info
));
7168 p
->name
= xstrdup (name
);
7170 p
->next
= user_signals
;
7173 signal (sig
, handle_user_signal
);
7177 handle_user_signal (int sig
)
7179 int old_errno
= errno
;
7180 struct user_signal_info
*p
;
7182 SIGNAL_THREAD_CHECK (sig
);
7184 for (p
= user_signals
; p
; p
= p
->next
)
7189 if (interrupt_input
)
7190 kill (getpid (), SIGIO
);
7194 /* Tell wait_reading_process_output that it needs to wake
7195 up and look around. */
7196 if (input_available_clear_time
)
7197 EMACS_SET_SECS_USECS (*input_available_clear_time
, 0, 0);
7206 find_user_signal_name (int sig
)
7208 struct user_signal_info
*p
;
7210 for (p
= user_signals
; p
; p
= p
->next
)
7218 store_user_signal_events (void)
7220 struct user_signal_info
*p
;
7221 struct input_event buf
;
7224 for (p
= user_signals
; p
; p
= p
->next
)
7225 if (p
->npending
> 0)
7231 memset (&buf
, 0, sizeof buf
);
7232 buf
.kind
= USER_SIGNAL_EVENT
;
7233 buf
.frame_or_window
= selected_frame
;
7235 nstored
+= p
->npending
;
7237 mask
= sigblock (sigmask (p
->sig
));
7241 kbd_buffer_store_event (&buf
);
7244 while (p
->npending
> 0);
7252 static void menu_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
7253 static Lisp_Object menu_bar_one_keymap_changed_items
;
7255 /* These variables hold the vector under construction within
7256 menu_bar_items and its subroutines, and the current index
7257 for storing into that vector. */
7258 static Lisp_Object menu_bar_items_vector
;
7259 static int menu_bar_items_index
;
7262 static const char* separator_names
[] = {
7267 "single-dashed-line",
7268 "double-dashed-line",
7270 "shadow-etched-out",
7271 "shadow-etched-in-dash",
7272 "shadow-etched-out-dash",
7273 "shadow-double-etched-in",
7274 "shadow-double-etched-out",
7275 "shadow-double-etched-in-dash",
7276 "shadow-double-etched-out-dash",
7280 /* Return non-zero if LABEL specifies a separator. */
7283 menu_separator_name_p (const char *label
)
7287 else if (strlen (label
) > 3
7288 && strncmp (label
, "--", 2) == 0
7293 for (i
= 0; separator_names
[i
]; ++i
)
7294 if (strcmp (label
, separator_names
[i
]) == 0)
7299 /* It's a separator if it contains only dashes. */
7300 while (*label
== '-')
7302 return (*label
== 0);
7309 /* Return a vector of menu items for a menu bar, appropriate
7310 to the current buffer. Each item has three elements in the vector:
7313 OLD is an old vector we can optionally reuse, or nil. */
7316 menu_bar_items (Lisp_Object old
)
7318 /* The number of keymaps we're scanning right now, and the number of
7319 keymaps we have allocated space for. */
7322 /* maps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
7323 in the current keymaps, or nil where it is not a prefix. */
7326 Lisp_Object def
, tail
;
7333 /* In order to build the menus, we need to call the keymap
7334 accessors. They all call QUIT. But this function is called
7335 during redisplay, during which a quit is fatal. So inhibit
7336 quitting while building the menus.
7337 We do this instead of specbind because (1) errors will clear it anyway
7338 and (2) this avoids risk of specpdl overflow. */
7339 oquit
= Vinhibit_quit
;
7343 menu_bar_items_vector
= old
;
7345 menu_bar_items_vector
= Fmake_vector (make_number (24), Qnil
);
7346 menu_bar_items_index
= 0;
7348 /* Build our list of keymaps.
7349 If we recognize a function key and replace its escape sequence in
7350 keybuf with its symbol, or if the sequence starts with a mouse
7351 click and we need to switch buffers, we jump back here to rebuild
7352 the initial keymaps from the current buffer. */
7356 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7357 if (!NILP (Voverriding_local_map_menu_flag
))
7359 /* Yes, use them (if non-nil) as well as the global map. */
7360 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7362 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
7363 maps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
7364 if (!NILP (Voverriding_local_map
))
7365 maps
[nmaps
++] = Voverriding_local_map
;
7369 /* No, so use major and minor mode keymaps and keymap property.
7370 Note that menu-bar bindings in the local-map and keymap
7371 properties may not work reliable, as they are only
7372 recognized when the menu-bar (or mode-line) is updated,
7373 which does not normally happen after every command. */
7376 nminor
= current_minor_maps (NULL
, &tmaps
);
7377 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7379 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7380 maps
[nmaps
++] = tem
;
7381 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
7383 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7385 maps
[nmaps
++] = current_global_map
;
7388 /* Look up in each map the dummy prefix key `menu-bar'. */
7392 for (mapno
= nmaps
- 1; mapno
>= 0; mapno
--)
7393 if (!NILP (maps
[mapno
]))
7395 def
= get_keymap (access_keymap (maps
[mapno
], Qmenu_bar
, 1, 0, 1),
7399 menu_bar_one_keymap_changed_items
= Qnil
;
7400 map_keymap (def
, menu_bar_item
, Qnil
, NULL
, 1);
7404 /* Move to the end those items that should be at the end. */
7406 for (tail
= Vmenu_bar_final_items
; CONSP (tail
); tail
= XCDR (tail
))
7409 int end
= menu_bar_items_index
;
7411 for (i
= 0; i
< end
; i
+= 4)
7412 if (EQ (XCAR (tail
), XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7414 Lisp_Object tem0
, tem1
, tem2
, tem3
;
7415 /* Move the item at index I to the end,
7416 shifting all the others forward. */
7417 tem0
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 0];
7418 tem1
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 1];
7419 tem2
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7420 tem3
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 3];
7422 memmove (&XVECTOR (menu_bar_items_vector
)->contents
[i
],
7423 &XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7424 (end
- i
- 4) * sizeof (Lisp_Object
));
7425 XVECTOR (menu_bar_items_vector
)->contents
[end
- 4] = tem0
;
7426 XVECTOR (menu_bar_items_vector
)->contents
[end
- 3] = tem1
;
7427 XVECTOR (menu_bar_items_vector
)->contents
[end
- 2] = tem2
;
7428 XVECTOR (menu_bar_items_vector
)->contents
[end
- 1] = tem3
;
7433 /* Add nil, nil, nil, nil at the end. */
7435 int i
= menu_bar_items_index
;
7436 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7437 menu_bar_items_vector
=
7438 larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7439 /* Add this item. */
7440 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7441 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7442 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7443 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Qnil
;
7444 menu_bar_items_index
= i
;
7447 Vinhibit_quit
= oquit
;
7448 return menu_bar_items_vector
;
7451 /* Add one item to menu_bar_items_vector, for KEY, ITEM_STRING and DEF.
7452 If there's already an item for KEY, add this DEF to it. */
7454 Lisp_Object item_properties
;
7457 menu_bar_item (Lisp_Object key
, Lisp_Object item
, Lisp_Object dummy1
, void *dummy2
)
7459 struct gcpro gcpro1
;
7463 if (EQ (item
, Qundefined
))
7465 /* If a map has an explicit `undefined' as definition,
7466 discard any previously made menu bar item. */
7468 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7469 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7471 if (menu_bar_items_index
> i
+ 4)
7472 memmove (&XVECTOR (menu_bar_items_vector
)->contents
[i
],
7473 &XVECTOR (menu_bar_items_vector
)->contents
[i
+ 4],
7474 (menu_bar_items_index
- i
- 4) * sizeof (Lisp_Object
));
7475 menu_bar_items_index
-= 4;
7479 /* If this keymap has already contributed to this KEY,
7480 don't contribute to it a second time. */
7481 tem
= Fmemq (key
, menu_bar_one_keymap_changed_items
);
7482 if (!NILP (tem
) || NILP (item
))
7485 menu_bar_one_keymap_changed_items
7486 = Fcons (key
, menu_bar_one_keymap_changed_items
);
7488 /* We add to menu_bar_one_keymap_changed_items before doing the
7489 parse_menu_item, so that if it turns out it wasn't a menu item,
7490 it still correctly hides any further menu item. */
7492 i
= parse_menu_item (item
, 1);
7497 item
= XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_DEF
];
7499 /* Find any existing item for this KEY. */
7500 for (i
= 0; i
< menu_bar_items_index
; i
+= 4)
7501 if (EQ (key
, XVECTOR (menu_bar_items_vector
)->contents
[i
]))
7504 /* If we did not find this KEY, add it at the end. */
7505 if (i
== menu_bar_items_index
)
7507 /* If vector is too small, get a bigger one. */
7508 if (i
+ 4 > XVECTOR (menu_bar_items_vector
)->size
)
7509 menu_bar_items_vector
= larger_vector (menu_bar_items_vector
, 2 * i
, Qnil
);
7510 /* Add this item. */
7511 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = key
;
7512 XVECTOR (menu_bar_items_vector
)->contents
[i
++]
7513 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
7514 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = Fcons (item
, Qnil
);
7515 XVECTOR (menu_bar_items_vector
)->contents
[i
++] = make_number (0);
7516 menu_bar_items_index
= i
;
7518 /* We did find an item for this KEY. Add ITEM to its list of maps. */
7522 old
= XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2];
7523 /* If the new and the old items are not both keymaps,
7524 the lookup will only find `item'. */
7525 item
= Fcons (item
, KEYMAPP (item
) && KEYMAPP (XCAR (old
)) ? old
: Qnil
);
7526 XVECTOR (menu_bar_items_vector
)->contents
[i
+ 2] = item
;
7530 /* This is used as the handler when calling menu_item_eval_property. */
7532 menu_item_eval_property_1 (Lisp_Object arg
)
7534 /* If we got a quit from within the menu computation,
7535 quit all the way out of it. This takes care of C-] in the debugger. */
7536 if (CONSP (arg
) && EQ (XCAR (arg
), Qquit
))
7537 Fsignal (Qquit
, Qnil
);
7542 /* Evaluate an expression and return the result (or nil if something
7543 went wrong). Used to evaluate dynamic parts of menu items. */
7545 menu_item_eval_property (Lisp_Object sexpr
)
7547 int count
= SPECPDL_INDEX ();
7549 specbind (Qinhibit_redisplay
, Qt
);
7550 val
= internal_condition_case_1 (Feval
, sexpr
, Qerror
,
7551 menu_item_eval_property_1
);
7552 return unbind_to (count
, val
);
7555 /* This function parses a menu item and leaves the result in the
7556 vector item_properties.
7557 ITEM is a key binding, a possible menu item.
7558 INMENUBAR is > 0 when this is considered for an entry in a menu bar
7560 INMENUBAR is < 0 when this is considered for an entry in a keyboard menu.
7561 parse_menu_item returns true if the item is a menu item and false
7565 parse_menu_item (Lisp_Object item
, int inmenubar
)
7567 Lisp_Object def
, tem
, item_string
, start
;
7569 Lisp_Object keyhint
;
7578 /* Create item_properties vector if necessary. */
7579 if (NILP (item_properties
))
7581 = Fmake_vector (make_number (ITEM_PROPERTY_ENABLE
+ 1), Qnil
);
7583 /* Initialize optional entries. */
7584 for (i
= ITEM_PROPERTY_DEF
; i
< ITEM_PROPERTY_ENABLE
; i
++)
7585 ASET (item_properties
, i
, Qnil
);
7586 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7588 /* Save the item here to protect it from GC. */
7589 ASET (item_properties
, ITEM_PROPERTY_ITEM
, item
);
7591 item_string
= XCAR (item
);
7595 if (STRINGP (item_string
))
7597 /* Old format menu item. */
7598 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7600 /* Maybe help string. */
7601 if (CONSP (item
) && STRINGP (XCAR (item
)))
7603 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7608 /* Maybe an obsolete key binding cache. */
7609 if (CONSP (item
) && CONSP (XCAR (item
))
7610 && (NILP (XCAR (XCAR (item
)))
7611 || VECTORP (XCAR (XCAR (item
)))))
7614 /* This is the real definition--the function to run. */
7615 ASET (item_properties
, ITEM_PROPERTY_DEF
, item
);
7617 /* Get enable property, if any. */
7620 tem
= Fget (item
, Qmenu_enable
);
7621 if (!NILP (Venable_disabled_menus_and_buttons
))
7622 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7623 else if (!NILP (tem
))
7624 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7627 else if (EQ (item_string
, Qmenu_item
) && CONSP (item
))
7629 /* New format menu item. */
7630 ASET (item_properties
, ITEM_PROPERTY_NAME
, XCAR (item
));
7631 start
= XCDR (item
);
7634 /* We have a real binding. */
7635 ASET (item_properties
, ITEM_PROPERTY_DEF
, XCAR (start
));
7637 item
= XCDR (start
);
7638 /* Is there an obsolete cache list with key equivalences. */
7639 if (CONSP (item
) && CONSP (XCAR (item
)))
7642 /* Parse properties. */
7643 while (CONSP (item
) && CONSP (XCDR (item
)))
7648 if (EQ (tem
, QCenable
))
7650 if (!NILP (Venable_disabled_menus_and_buttons
))
7651 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, Qt
);
7653 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, XCAR (item
));
7655 else if (EQ (tem
, QCvisible
))
7657 /* If got a visible property and that evaluates to nil
7658 then ignore this item. */
7659 tem
= menu_item_eval_property (XCAR (item
));
7663 else if (EQ (tem
, QChelp
))
7664 ASET (item_properties
, ITEM_PROPERTY_HELP
, XCAR (item
));
7665 else if (EQ (tem
, QCfilter
))
7667 else if (EQ (tem
, QCkey_sequence
))
7670 if (SYMBOLP (tem
) || STRINGP (tem
) || VECTORP (tem
))
7671 /* Be GC protected. Set keyhint to item instead of tem. */
7674 else if (EQ (tem
, QCkeys
))
7677 if (CONSP (tem
) || STRINGP (tem
))
7678 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, tem
);
7680 else if (EQ (tem
, QCbutton
) && CONSP (XCAR (item
)))
7685 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
7687 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
7689 ASET (item_properties
, ITEM_PROPERTY_TYPE
, type
);
7695 else if (inmenubar
|| !NILP (start
))
7699 return 0; /* not a menu item */
7701 /* If item string is not a string, evaluate it to get string.
7702 If we don't get a string, skip this item. */
7703 item_string
= AREF (item_properties
, ITEM_PROPERTY_NAME
);
7704 if (!(STRINGP (item_string
)))
7706 item_string
= menu_item_eval_property (item_string
);
7707 if (!STRINGP (item_string
))
7709 ASET (item_properties
, ITEM_PROPERTY_NAME
, item_string
);
7712 /* If got a filter apply it on definition. */
7713 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7716 def
= menu_item_eval_property (list2 (XCAR (filter
),
7717 list2 (Qquote
, def
)));
7719 ASET (item_properties
, ITEM_PROPERTY_DEF
, def
);
7722 /* Enable or disable selection of item. */
7723 tem
= AREF (item_properties
, ITEM_PROPERTY_ENABLE
);
7726 tem
= menu_item_eval_property (tem
);
7727 if (inmenubar
&& NILP (tem
))
7728 return 0; /* Ignore disabled items in menu bar. */
7729 ASET (item_properties
, ITEM_PROPERTY_ENABLE
, tem
);
7732 /* If we got no definition, this item is just unselectable text which
7733 is OK in a submenu but not in the menubar. */
7735 return (inmenubar
? 0 : 1);
7737 /* See if this is a separate pane or a submenu. */
7738 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7739 tem
= get_keymap (def
, 0, 1);
7740 /* For a subkeymap, just record its details and exit. */
7743 ASET (item_properties
, ITEM_PROPERTY_MAP
, tem
);
7744 ASET (item_properties
, ITEM_PROPERTY_DEF
, tem
);
7748 /* At the top level in the menu bar, do likewise for commands also.
7749 The menu bar does not display equivalent key bindings anyway.
7750 ITEM_PROPERTY_DEF is already set up properly. */
7754 { /* This is a command. See if there is an equivalent key binding. */
7755 Lisp_Object keyeq
= AREF (item_properties
, ITEM_PROPERTY_KEYEQ
);
7757 /* The previous code preferred :key-sequence to :keys, so we
7758 preserve this behavior. */
7759 if (STRINGP (keyeq
) && !CONSP (keyhint
))
7760 keyeq
= concat2 (build_string (" "), Fsubstitute_command_keys (keyeq
));
7763 Lisp_Object prefix
= keyeq
;
7764 Lisp_Object keys
= Qnil
;
7768 def
= XCAR (prefix
);
7769 prefix
= XCDR (prefix
);
7772 def
= AREF (item_properties
, ITEM_PROPERTY_DEF
);
7774 if (CONSP (keyhint
) && !NILP (XCAR (keyhint
)))
7776 keys
= XCAR (keyhint
);
7777 tem
= Fkey_binding (keys
, Qnil
, Qnil
, Qnil
);
7779 /* We have a suggested key. Is it bound to the command? */
7782 /* If the command is an alias for another
7783 (such as lmenu.el set it up), check if the
7784 original command matches the cached command. */
7785 && !(SYMBOLP (def
) && EQ (tem
, XSYMBOL (def
)->function
))))
7790 keys
= Fwhere_is_internal (def
, Qnil
, Qt
, Qnil
, Qnil
);
7794 tem
= Fkey_description (keys
, Qnil
);
7797 if (STRINGP (XCAR (prefix
)))
7798 tem
= concat2 (XCAR (prefix
), tem
);
7799 if (STRINGP (XCDR (prefix
)))
7800 tem
= concat2 (tem
, XCDR (prefix
));
7802 keyeq
= concat2 (build_string (" "), tem
);
7803 /* keyeq = concat3(build_string(" ("),tem,build_string(")")); */
7809 /* If we have an equivalent key binding, use that. */
7810 ASET (item_properties
, ITEM_PROPERTY_KEYEQ
, keyeq
);
7813 /* Include this when menu help is implemented.
7814 tem = XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP];
7815 if (!(NILP (tem) || STRINGP (tem)))
7817 tem = menu_item_eval_property (tem);
7820 XVECTOR (item_properties)->contents[ITEM_PROPERTY_HELP] = tem;
7824 /* Handle radio buttons or toggle boxes. */
7825 tem
= AREF (item_properties
, ITEM_PROPERTY_SELECTED
);
7827 ASET (item_properties
, ITEM_PROPERTY_SELECTED
,
7828 menu_item_eval_property (tem
));
7835 /***********************************************************************
7837 ***********************************************************************/
7839 /* A vector holding tool bar items while they are parsed in function
7840 tool_bar_items. Each item occupies TOOL_BAR_ITEM_NSCLOTS elements
7843 static Lisp_Object tool_bar_items_vector
;
7845 /* A vector holding the result of parse_tool_bar_item. Layout is like
7846 the one for a single item in tool_bar_items_vector. */
7848 static Lisp_Object tool_bar_item_properties
;
7850 /* Next free index in tool_bar_items_vector. */
7852 static int ntool_bar_items
;
7854 /* The symbols `:image' and `:rtl'. */
7856 Lisp_Object QCimage
;
7859 /* Function prototypes. */
7861 static void init_tool_bar_items (Lisp_Object
);
7862 static void process_tool_bar_item (Lisp_Object
, Lisp_Object
, Lisp_Object
, void*);
7863 static int parse_tool_bar_item (Lisp_Object
, Lisp_Object
);
7864 static void append_tool_bar_item (void);
7867 /* Return a vector of tool bar items for keymaps currently in effect.
7868 Reuse vector REUSE if non-nil. Return in *NITEMS the number of
7869 tool bar items found. */
7872 tool_bar_items (Lisp_Object reuse
, int *nitems
)
7881 /* In order to build the menus, we need to call the keymap
7882 accessors. They all call QUIT. But this function is called
7883 during redisplay, during which a quit is fatal. So inhibit
7884 quitting while building the menus. We do this instead of
7885 specbind because (1) errors will clear it anyway and (2) this
7886 avoids risk of specpdl overflow. */
7887 oquit
= Vinhibit_quit
;
7890 /* Initialize tool_bar_items_vector and protect it from GC. */
7891 init_tool_bar_items (reuse
);
7893 /* Build list of keymaps in maps. Set nmaps to the number of maps
7896 /* Should overriding-terminal-local-map and overriding-local-map apply? */
7897 if (!NILP (Voverriding_local_map_menu_flag
))
7899 /* Yes, use them (if non-nil) as well as the global map. */
7900 maps
= (Lisp_Object
*) alloca (3 * sizeof (maps
[0]));
7902 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
7903 maps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
7904 if (!NILP (Voverriding_local_map
))
7905 maps
[nmaps
++] = Voverriding_local_map
;
7909 /* No, so use major and minor mode keymaps and keymap property.
7910 Note that tool-bar bindings in the local-map and keymap
7911 properties may not work reliable, as they are only
7912 recognized when the tool-bar (or mode-line) is updated,
7913 which does not normally happen after every command. */
7916 nminor
= current_minor_maps (NULL
, &tmaps
);
7917 maps
= (Lisp_Object
*) alloca ((nminor
+ 3) * sizeof (maps
[0]));
7919 if (tem
= get_local_map (PT
, current_buffer
, Qkeymap
), !NILP (tem
))
7920 maps
[nmaps
++] = tem
;
7921 memcpy (maps
+ nmaps
, tmaps
, nminor
* sizeof (maps
[0]));
7923 maps
[nmaps
++] = get_local_map (PT
, current_buffer
, Qlocal_map
);
7926 /* Add global keymap at the end. */
7927 maps
[nmaps
++] = current_global_map
;
7929 /* Process maps in reverse order and look up in each map the prefix
7931 for (i
= nmaps
- 1; i
>= 0; --i
)
7932 if (!NILP (maps
[i
]))
7936 keymap
= get_keymap (access_keymap (maps
[i
], Qtool_bar
, 1, 0, 1), 0, 1);
7938 map_keymap (keymap
, process_tool_bar_item
, Qnil
, NULL
, 1);
7941 Vinhibit_quit
= oquit
;
7942 *nitems
= ntool_bar_items
/ TOOL_BAR_ITEM_NSLOTS
;
7943 return tool_bar_items_vector
;
7947 /* Process the definition of KEY which is DEF. */
7950 process_tool_bar_item (Lisp_Object key
, Lisp_Object def
, Lisp_Object data
, void *args
)
7953 struct gcpro gcpro1
, gcpro2
;
7955 /* Protect KEY and DEF from GC because parse_tool_bar_item may call
7959 if (EQ (def
, Qundefined
))
7961 /* If a map has an explicit `undefined' as definition,
7962 discard any previously made item. */
7963 for (i
= 0; i
< ntool_bar_items
; i
+= TOOL_BAR_ITEM_NSLOTS
)
7965 Lisp_Object
*v
= XVECTOR (tool_bar_items_vector
)->contents
+ i
;
7967 if (EQ (key
, v
[TOOL_BAR_ITEM_KEY
]))
7969 if (ntool_bar_items
> i
+ TOOL_BAR_ITEM_NSLOTS
)
7970 memmove (v
, v
+ TOOL_BAR_ITEM_NSLOTS
,
7971 ((ntool_bar_items
- i
- TOOL_BAR_ITEM_NSLOTS
)
7972 * sizeof (Lisp_Object
)));
7973 ntool_bar_items
-= TOOL_BAR_ITEM_NSLOTS
;
7978 else if (parse_tool_bar_item (key
, def
))
7979 /* Append a new tool bar item to tool_bar_items_vector. Accept
7980 more than one definition for the same key. */
7981 append_tool_bar_item ();
7987 /* Parse a tool bar item specification ITEM for key KEY and return the
7988 result in tool_bar_item_properties. Value is zero if ITEM is
7991 ITEM is a list `(menu-item CAPTION BINDING PROPS...)'.
7993 CAPTION is the caption of the item, If it's not a string, it is
7994 evaluated to get a string.
7996 BINDING is the tool bar item's binding. Tool-bar items with keymaps
7997 as binding are currently ignored.
7999 The following properties are recognized:
8003 FORM is evaluated and specifies whether the tool bar item is
8004 enabled or disabled.
8008 FORM is evaluated and specifies whether the tool bar item is visible.
8010 - `:filter FUNCTION'
8012 FUNCTION is invoked with one parameter `(quote BINDING)'. Its
8013 result is stored as the new binding.
8015 - `:button (TYPE SELECTED)'
8017 TYPE must be one of `:radio' or `:toggle'. SELECTED is evaluated
8018 and specifies whether the button is selected (pressed) or not.
8022 IMAGES is either a single image specification or a vector of four
8023 image specifications. See enum tool_bar_item_images.
8025 - `:help HELP-STRING'.
8027 Gives a help string to display for the tool bar item.
8029 - `:label LABEL-STRING'.
8031 A text label to show with the tool bar button if labels are enabled. */
8034 parse_tool_bar_item (Lisp_Object key
, Lisp_Object item
)
8036 /* Access slot with index IDX of vector tool_bar_item_properties. */
8037 #define PROP(IDX) XVECTOR (tool_bar_item_properties)->contents[IDX]
8039 Lisp_Object filter
= Qnil
;
8040 Lisp_Object caption
;
8041 int i
, have_label
= 0;
8043 /* Defininition looks like `(menu-item CAPTION BINDING PROPS...)'.
8044 Rule out items that aren't lists, don't start with
8045 `menu-item' or whose rest following `tool-bar-item' is not a
8050 /* As an exception, allow old-style menu separators. */
8051 if (STRINGP (XCAR (item
)))
8052 item
= Fcons (XCAR (item
), Qnil
);
8053 else if (!EQ (XCAR (item
), Qmenu_item
)
8054 || (item
= XCDR (item
), !CONSP (item
)))
8057 /* Create tool_bar_item_properties vector if necessary. Reset it to
8059 if (VECTORP (tool_bar_item_properties
))
8061 for (i
= 0; i
< TOOL_BAR_ITEM_NSLOTS
; ++i
)
8065 tool_bar_item_properties
8066 = Fmake_vector (make_number (TOOL_BAR_ITEM_NSLOTS
), Qnil
);
8069 PROP (TOOL_BAR_ITEM_KEY
) = key
;
8070 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8072 /* Get the caption of the item. If the caption is not a string,
8073 evaluate it to get a string. If we don't get a string, skip this
8075 caption
= XCAR (item
);
8076 if (!STRINGP (caption
))
8078 caption
= menu_item_eval_property (caption
);
8079 if (!STRINGP (caption
))
8082 PROP (TOOL_BAR_ITEM_CAPTION
) = caption
;
8084 /* If the rest following the caption is not a list, the menu item is
8085 either a separator, or invalid. */
8089 if (menu_separator_name_p (SSDATA (caption
)))
8091 PROP (TOOL_BAR_ITEM_TYPE
) = Qt
;
8092 #if !defined (USE_GTK) && !defined (HAVE_NS)
8093 /* If we use build_desired_tool_bar_string to render the
8094 tool bar, the separator is rendered as an image. */
8095 PROP (TOOL_BAR_ITEM_IMAGES
)
8096 = menu_item_eval_property (Vtool_bar_separator_image_expression
);
8097 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qnil
;
8098 PROP (TOOL_BAR_ITEM_SELECTED_P
) = Qnil
;
8099 PROP (TOOL_BAR_ITEM_CAPTION
) = Qnil
;
8106 /* Store the binding. */
8107 PROP (TOOL_BAR_ITEM_BINDING
) = XCAR (item
);
8110 /* Ignore cached key binding, if any. */
8111 if (CONSP (item
) && CONSP (XCAR (item
)))
8114 /* Process the rest of the properties. */
8115 for (; CONSP (item
) && CONSP (XCDR (item
)); item
= XCDR (XCDR (item
)))
8117 Lisp_Object ikey
, value
;
8120 value
= XCAR (XCDR (item
));
8122 if (EQ (ikey
, QCenable
))
8124 /* `:enable FORM'. */
8125 if (!NILP (Venable_disabled_menus_and_buttons
))
8126 PROP (TOOL_BAR_ITEM_ENABLED_P
) = Qt
;
8128 PROP (TOOL_BAR_ITEM_ENABLED_P
) = value
;
8130 else if (EQ (ikey
, QCvisible
))
8132 /* `:visible FORM'. If got a visible property and that
8133 evaluates to nil then ignore this item. */
8134 if (NILP (menu_item_eval_property (value
)))
8137 else if (EQ (ikey
, QChelp
))
8138 /* `:help HELP-STRING'. */
8139 PROP (TOOL_BAR_ITEM_HELP
) = value
;
8140 else if (EQ (ikey
, QCvert_only
))
8141 /* `:vert-only t/nil'. */
8142 PROP (TOOL_BAR_ITEM_VERT_ONLY
) = value
;
8143 else if (EQ (ikey
, QClabel
))
8145 const char *bad_label
= "!!?GARBLED ITEM?!!";
8146 /* `:label LABEL-STRING'. */
8147 PROP (TOOL_BAR_ITEM_LABEL
) = STRINGP (value
)
8149 : make_string (bad_label
, strlen (bad_label
));
8152 else if (EQ (ikey
, QCfilter
))
8153 /* ':filter FORM'. */
8155 else if (EQ (ikey
, QCbutton
) && CONSP (value
))
8157 /* `:button (TYPE . SELECTED)'. */
8158 Lisp_Object type
, selected
;
8160 type
= XCAR (value
);
8161 selected
= XCDR (value
);
8162 if (EQ (type
, QCtoggle
) || EQ (type
, QCradio
))
8164 PROP (TOOL_BAR_ITEM_SELECTED_P
) = selected
;
8165 PROP (TOOL_BAR_ITEM_TYPE
) = type
;
8168 else if (EQ (ikey
, QCimage
)
8170 || (VECTORP (value
) && XVECTOR (value
)->size
== 4)))
8171 /* Value is either a single image specification or a vector
8172 of 4 such specifications for the different button states. */
8173 PROP (TOOL_BAR_ITEM_IMAGES
) = value
;
8174 else if (EQ (ikey
, Qrtl
))
8176 PROP (TOOL_BAR_ITEM_RTL_IMAGE
) = value
;
8182 /* Try to make one from caption and key. */
8183 Lisp_Object tkey
= PROP (TOOL_BAR_ITEM_KEY
);
8184 Lisp_Object tcapt
= PROP (TOOL_BAR_ITEM_CAPTION
);
8185 const char *label
= SYMBOLP (tkey
) ? SSDATA (SYMBOL_NAME (tkey
)) : "";
8186 const char *capt
= STRINGP (tcapt
) ? SSDATA (tcapt
) : "";
8187 EMACS_INT max_lbl
= 2 * tool_bar_max_label_size
;
8188 char *buf
= (char *) xmalloc (max_lbl
+ 1);
8189 Lisp_Object new_lbl
;
8190 size_t caption_len
= strlen (capt
);
8192 if (caption_len
<= max_lbl
&& capt
[0] != '\0')
8195 while (caption_len
> 0 && buf
[caption_len
- 1] == '.')
8197 buf
[caption_len
] = '\0';
8201 if (strlen (label
) <= max_lbl
&& label
[0] != '\0')
8205 strcpy (buf
, label
);
8207 for (j
= 0; buf
[j
] != '\0'; ++j
)
8215 new_lbl
= Fupcase_initials (make_string (label
, strlen (label
)));
8216 if (SCHARS (new_lbl
) <= tool_bar_max_label_size
)
8217 PROP (TOOL_BAR_ITEM_LABEL
) = new_lbl
;
8219 PROP (TOOL_BAR_ITEM_LABEL
) = make_string ("", 0);
8223 /* If got a filter apply it on binding. */
8225 PROP (TOOL_BAR_ITEM_BINDING
)
8226 = menu_item_eval_property (list2 (filter
,
8228 PROP (TOOL_BAR_ITEM_BINDING
))));
8230 /* See if the binding is a keymap. Give up if it is. */
8231 if (CONSP (get_keymap (PROP (TOOL_BAR_ITEM_BINDING
), 0, 1)))
8234 /* Enable or disable selection of item. */
8235 if (!EQ (PROP (TOOL_BAR_ITEM_ENABLED_P
), Qt
))
8236 PROP (TOOL_BAR_ITEM_ENABLED_P
)
8237 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_ENABLED_P
));
8239 /* Handle radio buttons or toggle boxes. */
8240 if (!NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
)))
8241 PROP (TOOL_BAR_ITEM_SELECTED_P
)
8242 = menu_item_eval_property (PROP (TOOL_BAR_ITEM_SELECTED_P
));
8250 /* Initialize tool_bar_items_vector. REUSE, if non-nil, is a vector
8251 that can be reused. */
8254 init_tool_bar_items (Lisp_Object reuse
)
8256 if (VECTORP (reuse
))
8257 tool_bar_items_vector
= reuse
;
8259 tool_bar_items_vector
= Fmake_vector (make_number (64), Qnil
);
8260 ntool_bar_items
= 0;
8264 /* Append parsed tool bar item properties from
8265 tool_bar_item_properties */
8268 append_tool_bar_item (void)
8270 Lisp_Object
*to
, *from
;
8272 /* Enlarge tool_bar_items_vector if necessary. */
8273 if (ntool_bar_items
+ TOOL_BAR_ITEM_NSLOTS
8274 >= XVECTOR (tool_bar_items_vector
)->size
)
8275 tool_bar_items_vector
8276 = larger_vector (tool_bar_items_vector
,
8277 2 * XVECTOR (tool_bar_items_vector
)->size
, Qnil
);
8279 /* Append entries from tool_bar_item_properties to the end of
8280 tool_bar_items_vector. */
8281 to
= XVECTOR (tool_bar_items_vector
)->contents
+ ntool_bar_items
;
8282 from
= XVECTOR (tool_bar_item_properties
)->contents
;
8283 memcpy (to
, from
, TOOL_BAR_ITEM_NSLOTS
* sizeof *to
);
8284 ntool_bar_items
+= TOOL_BAR_ITEM_NSLOTS
;
8291 /* Read a character using menus based on maps in the array MAPS.
8292 NMAPS is the length of MAPS. Return nil if there are no menus in the maps.
8293 Return t if we displayed a menu but the user rejected it.
8295 PREV_EVENT is the previous input event, or nil if we are reading
8296 the first event of a key sequence.
8298 If USED_MOUSE_MENU is non-null, then we set *USED_MOUSE_MENU to 1
8299 if we used a mouse menu to read the input, or zero otherwise. If
8300 USED_MOUSE_MENU is null, we don't dereference it.
8302 The prompting is done based on the prompt-string of the map
8303 and the strings associated with various map elements.
8305 This can be done with X menus or with menus put in the minibuf.
8306 These are done in different ways, depending on how the input will be read.
8307 Menus using X are done after auto-saving in read-char, getting the input
8308 event from Fx_popup_menu; menus using the minibuf use read_char recursively
8309 and do auto-saving in the inner call of read_char. */
8312 read_char_x_menu_prompt (int nmaps
, Lisp_Object
*maps
, Lisp_Object prev_event
,
8313 int *used_mouse_menu
)
8317 if (used_mouse_menu
)
8318 *used_mouse_menu
= 0;
8320 /* Use local over global Menu maps */
8322 if (! menu_prompting
)
8325 /* Optionally disregard all but the global map. */
8326 if (inhibit_local_menu_bar_menus
)
8328 maps
+= (nmaps
- 1);
8333 /* If we got to this point via a mouse click,
8334 use a real menu for mouse selection. */
8335 if (EVENT_HAS_PARAMETERS (prev_event
)
8336 && !EQ (XCAR (prev_event
), Qmenu_bar
)
8337 && !EQ (XCAR (prev_event
), Qtool_bar
))
8339 /* Display the menu and get the selection. */
8340 Lisp_Object
*realmaps
8341 = (Lisp_Object
*) alloca (nmaps
* sizeof (Lisp_Object
));
8345 /* Use the maps that are not nil. */
8346 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8347 if (!NILP (maps
[mapno
]))
8348 realmaps
[nmaps1
++] = maps
[mapno
];
8350 value
= Fx_popup_menu (prev_event
, Flist (nmaps1
, realmaps
));
8355 record_menu_key (XCAR (value
));
8357 /* If we got multiple events, unread all but
8359 There is no way to prevent those unread events
8360 from showing up later in last_nonmenu_event.
8361 So turn symbol and integer events into lists,
8362 to indicate that they came from a mouse menu,
8363 so that when present in last_nonmenu_event
8364 they won't confuse things. */
8365 for (tem
= XCDR (value
); CONSP (tem
); tem
= XCDR (tem
))
8367 record_menu_key (XCAR (tem
));
8368 if (SYMBOLP (XCAR (tem
))
8369 || INTEGERP (XCAR (tem
)))
8370 XSETCAR (tem
, Fcons (XCAR (tem
), Qdisabled
));
8373 /* If we got more than one event, put all but the first
8374 onto this list to be read later.
8375 Return just the first event now. */
8376 Vunread_command_events
8377 = nconc2 (XCDR (value
), Vunread_command_events
);
8378 value
= XCAR (value
);
8380 else if (NILP (value
))
8382 if (used_mouse_menu
)
8383 *used_mouse_menu
= 1;
8386 #endif /* HAVE_MENUS */
8390 /* Buffer in use so far for the minibuf prompts for menu keymaps.
8391 We make this bigger when necessary, and never free it. */
8392 static char *read_char_minibuf_menu_text
;
8393 /* Size of that buffer. */
8394 static int read_char_minibuf_menu_width
;
8397 read_char_minibuf_menu_prompt (int commandflag
, int nmaps
, Lisp_Object
*maps
)
8400 register Lisp_Object name
;
8402 /* FIXME: Use the minibuffer's frame width. */
8403 int width
= FRAME_COLS (SELECTED_FRAME ()) - 4;
8406 Lisp_Object rest
, vector
;
8412 if (! menu_prompting
)
8415 /* Get the menu name from the first map that has one (a prompt string). */
8416 for (mapno
= 0; mapno
< nmaps
; mapno
++)
8418 name
= Fkeymap_prompt (maps
[mapno
]);
8423 /* If we don't have any menus, just read a character normally. */
8424 if (!STRINGP (name
))
8427 /* Make sure we have a big enough buffer for the menu text. */
8428 width
= max (width
, SBYTES (name
));
8429 if (read_char_minibuf_menu_text
== 0)
8431 read_char_minibuf_menu_width
= width
+ 4;
8432 read_char_minibuf_menu_text
= (char *) xmalloc (width
+ 4);
8434 else if (width
+ 4 > read_char_minibuf_menu_width
)
8436 read_char_minibuf_menu_width
= width
+ 4;
8437 read_char_minibuf_menu_text
8438 = (char *) xrealloc (read_char_minibuf_menu_text
, width
+ 4);
8440 menu
= read_char_minibuf_menu_text
;
8442 /* Prompt string always starts with map's prompt, and a space. */
8443 strcpy (menu
, SSDATA (name
));
8444 nlength
= SBYTES (name
);
8445 menu
[nlength
++] = ':';
8446 menu
[nlength
++] = ' ';
8449 /* Start prompting at start of first map. */
8453 /* Present the documented bindings, a line at a time. */
8460 Lisp_Object orig_defn_macro
;
8462 /* Loop over elements of map. */
8467 /* If reached end of map, start at beginning of next map. */
8471 /* At end of last map, wrap around to first map if just starting,
8472 or end this line if already have something on it. */
8476 if (notfirst
|| nobindings
) break;
8481 /* Look at the next element of the map. */
8483 elt
= XVECTOR (vector
)->contents
[idx
];
8485 elt
= Fcar_safe (rest
);
8487 if (idx
< 0 && VECTORP (elt
))
8489 /* If we found a dense table in the keymap,
8490 advanced past it, but start scanning its contents. */
8491 rest
= Fcdr_safe (rest
);
8497 /* An ordinary element. */
8498 Lisp_Object event
, tem
;
8502 event
= Fcar_safe (elt
); /* alist */
8503 elt
= Fcdr_safe (elt
);
8507 XSETINT (event
, idx
); /* vector */
8510 /* Ignore the element if it has no prompt string. */
8511 if (INTEGERP (event
) && parse_menu_item (elt
, -1))
8513 /* 1 if the char to type matches the string. */
8515 Lisp_Object upcased_event
, downcased_event
;
8516 Lisp_Object desc
= Qnil
;
8518 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_NAME
];
8520 upcased_event
= Fupcase (event
);
8521 downcased_event
= Fdowncase (event
);
8522 char_matches
= (XINT (upcased_event
) == SREF (s
, 0)
8523 || XINT (downcased_event
) == SREF (s
, 0));
8525 desc
= Fsingle_key_description (event
, Qnil
);
8527 #if 0 /* It is redundant to list the equivalent key bindings because
8528 the prefix is what the user has already typed. */
8530 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_KEYEQ
];
8532 /* Insert equivalent keybinding. */
8533 s
= concat2 (s
, tem
);
8536 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_TYPE
];
8537 if (EQ (tem
, QCradio
) || EQ (tem
, QCtoggle
))
8539 /* Insert button prefix. */
8540 Lisp_Object selected
8541 = XVECTOR (item_properties
)->contents
[ITEM_PROPERTY_SELECTED
];
8542 if (EQ (tem
, QCradio
))
8543 tem
= build_string (NILP (selected
) ? "(*) " : "( ) ");
8545 tem
= build_string (NILP (selected
) ? "[X] " : "[ ] ");
8546 s
= concat2 (tem
, s
);
8550 /* If we have room for the prompt string, add it to this line.
8551 If this is the first on the line, always add it. */
8552 if ((SCHARS (s
) + i
+ 2
8553 + (char_matches
? 0 : SCHARS (desc
) + 3))
8559 /* Punctuate between strings. */
8562 strcpy (menu
+ i
, ", ");
8568 /* If the char to type doesn't match the string's
8569 first char, explicitly show what char to type. */
8572 /* Add as much of string as fits. */
8573 thiswidth
= SCHARS (desc
);
8574 if (thiswidth
+ i
> width
)
8575 thiswidth
= width
- i
;
8576 memcpy (menu
+ i
, SDATA (desc
), thiswidth
);
8578 strcpy (menu
+ i
, " = ");
8582 /* Add as much of string as fits. */
8583 thiswidth
= SCHARS (s
);
8584 if (thiswidth
+ i
> width
)
8585 thiswidth
= width
- i
;
8586 memcpy (menu
+ i
, SDATA (s
), thiswidth
);
8592 /* If this element does not fit, end the line now,
8593 and save the element for the next line. */
8594 strcpy (menu
+ i
, "...");
8599 /* Move past this element. */
8600 if (idx
>= 0 && idx
+ 1 >= XVECTOR (vector
)->size
)
8601 /* Handle reaching end of dense table. */
8606 rest
= Fcdr_safe (rest
);
8610 /* Prompt with that and read response. */
8611 message2_nolog (menu
, strlen (menu
),
8612 ! NILP (BVAR (current_buffer
, enable_multibyte_characters
)));
8614 /* Make believe its not a keyboard macro in case the help char
8615 is pressed. Help characters are not recorded because menu prompting
8616 is not used on replay.
8618 orig_defn_macro
= KVAR (current_kboard
, defining_kbd_macro
);
8619 KVAR (current_kboard
, defining_kbd_macro
) = Qnil
;
8621 obj
= read_char (commandflag
, 0, 0, Qt
, 0, NULL
);
8622 while (BUFFERP (obj
));
8623 KVAR (current_kboard
, defining_kbd_macro
) = orig_defn_macro
;
8625 if (!INTEGERP (obj
))
8627 else if (XINT (obj
) == -2)
8632 if (! EQ (obj
, menu_prompt_more_char
)
8633 && (!INTEGERP (menu_prompt_more_char
)
8634 || ! EQ (obj
, make_number (Ctl (XINT (menu_prompt_more_char
))))))
8636 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
)))
8637 store_kbd_macro_char (obj
);
8640 /* Help char - go round again */
8644 /* Reading key sequences. */
8646 /* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
8647 in DEFS[0..NMAPS-1]. Set NEXT[i] to DEFS[i] if DEFS[i] is a
8648 keymap, or nil otherwise. Return the index of the first keymap in
8649 which KEY has any binding, or NMAPS if no map has a binding.
8651 If KEY is a meta ASCII character, treat it like meta-prefix-char
8652 followed by the corresponding non-meta character. Keymaps in
8653 CURRENT with non-prefix bindings for meta-prefix-char become nil in
8656 If KEY has no bindings in any of the CURRENT maps, NEXT is left
8659 NEXT may be the same array as CURRENT. */
8662 follow_key (Lisp_Object key
, int nmaps
, Lisp_Object
*current
, Lisp_Object
*defs
,
8665 int i
, first_binding
;
8667 first_binding
= nmaps
;
8668 for (i
= nmaps
- 1; i
>= 0; i
--)
8670 if (! NILP (current
[i
]))
8672 defs
[i
] = access_keymap (current
[i
], key
, 1, 0, 1);
8673 if (! NILP (defs
[i
]))
8680 /* Given the set of bindings we've found, produce the next set of maps. */
8681 if (first_binding
< nmaps
)
8682 for (i
= 0; i
< nmaps
; i
++)
8683 next
[i
] = NILP (defs
[i
]) ? Qnil
: get_keymap (defs
[i
], 0, 1);
8685 return first_binding
;
8688 /* Structure used to keep track of partial application of key remapping
8689 such as Vfunction_key_map and Vkey_translation_map. */
8690 typedef struct keyremap
8692 /* This is the map originally specified for this use. */
8694 /* This is a submap reached by looking up, in PARENT,
8695 the events from START to END. */
8697 /* Positions [START, END) in the key sequence buffer
8698 are the key that we have scanned so far.
8699 Those events are the ones that we will replace
8700 if PAREHT maps them into a key sequence. */
8704 /* Lookup KEY in MAP.
8705 MAP is a keymap mapping keys to key vectors or functions.
8706 If the mapping is a function and DO_FUNCTION is non-zero, then
8707 the function is called with PROMPT as parameter and its return
8708 value is used as the return value of this function (after checking
8709 that it is indeed a vector). */
8712 access_keymap_keyremap (Lisp_Object map
, Lisp_Object key
, Lisp_Object prompt
,
8717 next
= access_keymap (map
, key
, 1, 0, 1);
8719 /* Handle symbol with autoload definition. */
8720 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8721 && CONSP (XSYMBOL (next
)->function
)
8722 && EQ (XCAR (XSYMBOL (next
)->function
), Qautoload
))
8723 do_autoload (XSYMBOL (next
)->function
, next
);
8725 /* Handle a symbol whose function definition is a keymap
8727 if (SYMBOLP (next
) && !NILP (Ffboundp (next
))
8728 && (ARRAYP (XSYMBOL (next
)->function
)
8729 || KEYMAPP (XSYMBOL (next
)->function
)))
8730 next
= XSYMBOL (next
)->function
;
8732 /* If the keymap gives a function, not an
8733 array, then call the function with one arg and use
8734 its value instead. */
8735 if (SYMBOLP (next
) && !NILP (Ffboundp (next
)) && do_funcall
)
8740 next
= call1 (next
, prompt
);
8741 /* If the function returned something invalid,
8742 barf--don't ignore it.
8743 (To ignore it safely, we would need to gcpro a bunch of
8744 other variables.) */
8745 if (! (VECTORP (next
) || STRINGP (next
)))
8746 error ("Function %s returns invalid key sequence", tem
);
8751 /* Do one step of the key remapping used for function-key-map and
8752 key-translation-map:
8753 KEYBUF is the buffer holding the input events.
8754 BUFSIZE is its maximum size.
8755 FKEY is a pointer to the keyremap structure to use.
8756 INPUT is the index of the last element in KEYBUF.
8757 DOIT if non-zero says that the remapping can actually take place.
8758 DIFF is used to return the number of keys added/removed by the remapping.
8759 PARENT is the root of the keymap.
8760 PROMPT is the prompt to use if the remapping happens through a function.
8761 The return value is non-zero if the remapping actually took place. */
8764 keyremap_step (Lisp_Object
*keybuf
, int bufsize
, volatile keyremap
*fkey
,
8765 int input
, int doit
, int *diff
, Lisp_Object prompt
)
8767 Lisp_Object next
, key
;
8769 key
= keybuf
[fkey
->end
++];
8771 if (KEYMAPP (fkey
->parent
))
8772 next
= access_keymap_keyremap (fkey
->map
, key
, prompt
, doit
);
8776 /* If keybuf[fkey->start..fkey->end] is bound in the
8777 map and we're in a position to do the key remapping, replace it with
8778 the binding and restart with fkey->start at the end. */
8779 if ((VECTORP (next
) || STRINGP (next
)) && doit
)
8781 int len
= XFASTINT (Flength (next
));
8784 *diff
= len
- (fkey
->end
- fkey
->start
);
8786 if (input
+ *diff
>= bufsize
)
8787 error ("Key sequence too long");
8789 /* Shift the keys that follow fkey->end. */
8791 for (i
= fkey
->end
; i
< input
; i
++)
8792 keybuf
[i
+ *diff
] = keybuf
[i
];
8794 for (i
= input
- 1; i
>= fkey
->end
; i
--)
8795 keybuf
[i
+ *diff
] = keybuf
[i
];
8796 /* Overwrite the old keys with the new ones. */
8797 for (i
= 0; i
< len
; i
++)
8798 keybuf
[fkey
->start
+ i
]
8799 = Faref (next
, make_number (i
));
8801 fkey
->start
= fkey
->end
+= *diff
;
8802 fkey
->map
= fkey
->parent
;
8807 fkey
->map
= get_keymap (next
, 0, 1);
8809 /* If we no longer have a bound suffix, try a new position for
8811 if (!CONSP (fkey
->map
))
8813 fkey
->end
= ++fkey
->start
;
8814 fkey
->map
= fkey
->parent
;
8819 /* Read a sequence of keys that ends with a non prefix character,
8820 storing it in KEYBUF, a buffer of size BUFSIZE.
8822 Return the length of the key sequence stored.
8823 Return -1 if the user rejected a command menu.
8825 Echo starting immediately unless `prompt' is 0.
8827 Where a key sequence ends depends on the currently active keymaps.
8828 These include any minor mode keymaps active in the current buffer,
8829 the current buffer's local map, and the global map.
8831 If a key sequence has no other bindings, we check Vfunction_key_map
8832 to see if some trailing subsequence might be the beginning of a
8833 function key's sequence. If so, we try to read the whole function
8834 key, and substitute its symbolic name into the key sequence.
8836 We ignore unbound `down-' mouse clicks. We turn unbound `drag-' and
8837 `double-' events into similar click events, if that would make them
8838 bound. We try to turn `triple-' events first into `double-' events,
8841 If we get a mouse click in a mode line, vertical divider, or other
8842 non-text area, we treat the click as if it were prefixed by the
8843 symbol denoting that area - `mode-line', `vertical-line', or
8846 If the sequence starts with a mouse click, we read the key sequence
8847 with respect to the buffer clicked on, not the current buffer.
8849 If the user switches frames in the midst of a key sequence, we put
8850 off the switch-frame event until later; the next call to
8851 read_char will return it.
8853 If FIX_CURRENT_BUFFER is nonzero, we restore current_buffer
8854 from the selected window's buffer. */
8857 read_key_sequence (Lisp_Object
*keybuf
, int bufsize
, Lisp_Object prompt
,
8858 int dont_downcase_last
, int can_return_switch_frame
,
8859 int fix_current_buffer
)
8861 Lisp_Object from_string
;
8862 int count
= SPECPDL_INDEX ();
8864 /* How many keys there are in the current key sequence. */
8867 /* The length of the echo buffer when we started reading, and
8868 the length of this_command_keys when we started reading. */
8872 /* The number of keymaps we're scanning right now, and the number of
8873 keymaps we have allocated space for. */
8875 int nmaps_allocated
= 0;
8877 /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
8878 the current keymaps. */
8879 Lisp_Object
*defs
= NULL
;
8881 /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
8882 in the current keymaps, or nil where it is not a prefix. */
8883 Lisp_Object
*submaps
= NULL
;
8885 /* The local map to start out with at start of key sequence. */
8886 Lisp_Object orig_local_map
;
8888 /* The map from the `keymap' property to start out with at start of
8890 Lisp_Object orig_keymap
;
8892 /* 1 if we have already considered switching to the local-map property
8893 of the place where a mouse click occurred. */
8894 int localized_local_map
= 0;
8896 /* The index in submaps[] of the first keymap that has a binding for
8897 this key sequence. In other words, the lowest i such that
8898 submaps[i] is non-nil. */
8900 /* Index of the first key that has no binding.
8901 It is useless to try fkey.start larger than that. */
8904 /* If t < mock_input, then KEYBUF[t] should be read as the next
8907 We use this to recover after recognizing a function key. Once we
8908 realize that a suffix of the current key sequence is actually a
8909 function key's escape sequence, we replace the suffix with the
8910 function key's binding from Vfunction_key_map. Now keybuf
8911 contains a new and different key sequence, so the echo area,
8912 this_command_keys, and the submaps and defs arrays are wrong. In
8913 this situation, we set mock_input to t, set t to 0, and jump to
8914 restart_sequence; the loop will read keys from keybuf up until
8915 mock_input, thus rebuilding the state; and then it will resume
8916 reading characters from the keyboard. */
8919 /* If the sequence is unbound in submaps[], then
8920 keybuf[fkey.start..fkey.end-1] is a prefix in Vfunction_key_map,
8921 and fkey.map is its binding.
8923 These might be > t, indicating that all function key scanning
8924 should hold off until t reaches them. We do this when we've just
8925 recognized a function key, to avoid searching for the function
8926 key's again in Vfunction_key_map. */
8929 /* Likewise, for key_translation_map and input-decode-map. */
8930 keyremap keytran
, indec
;
8932 /* Non-zero if we are trying to map a key by changing an upper-case
8933 letter to lower case, or a shifted function key to an unshifted
8935 int shift_translated
= 0;
8937 /* If we receive a `switch-frame' or `select-window' event in the middle of
8938 a key sequence, we put it off for later.
8939 While we're reading, we keep the event here. */
8940 Lisp_Object delayed_switch_frame
;
8942 /* See the comment below... */
8943 #if defined (GOBBLE_FIRST_EVENT)
8944 Lisp_Object first_event
;
8947 Lisp_Object original_uppercase
;
8948 int original_uppercase_position
= -1;
8950 /* Gets around Microsoft compiler limitations. */
8953 struct buffer
*starting_buffer
;
8955 /* List of events for which a fake prefix key has been generated. */
8956 Lisp_Object fake_prefixed_keys
= Qnil
;
8958 #if defined (GOBBLE_FIRST_EVENT)
8962 struct gcpro outer_gcpro1
;
8964 GCPRO1_VAR (fake_prefixed_keys
, outer_gcpro1
);
8965 raw_keybuf_count
= 0;
8967 last_nonmenu_event
= Qnil
;
8969 delayed_switch_frame
= Qnil
;
8975 /* Install the string STR as the beginning of the string of
8976 echoing, so that it serves as a prompt for the next
8978 KVAR (current_kboard
, echo_string
) = prompt
;
8979 current_kboard
->echo_after_prompt
= SCHARS (prompt
);
8982 else if (cursor_in_echo_area
8983 && (FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
8984 && NILP (Fzerop (Vecho_keystrokes
)))
8985 /* This doesn't put in a dash if the echo buffer is empty, so
8986 you don't always see a dash hanging out in the minibuffer. */
8990 /* Record the initial state of the echo area and this_command_keys;
8991 we will need to restore them if we replay a key sequence. */
8993 echo_start
= echo_length ();
8994 keys_start
= this_command_key_count
;
8995 this_single_command_key_start
= keys_start
;
8997 #if defined (GOBBLE_FIRST_EVENT)
8998 /* This doesn't quite work, because some of the things that read_char
8999 does cannot safely be bypassed. It seems too risky to try to make
9002 /* Read the first char of the sequence specially, before setting
9003 up any keymaps, in case a filter runs and switches buffers on us. */
9004 first_event
= read_char (NILP (prompt
), 0, submaps
, last_nonmenu_event
,
9006 #endif /* GOBBLE_FIRST_EVENT */
9008 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9009 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9012 /* We jump here when we need to reinitialize fkey and keytran; this
9013 happens if we switch keyboards between rescans. */
9014 replay_entire_sequence
:
9016 indec
.map
= indec
.parent
= KVAR (current_kboard
, Vinput_decode_map
);
9017 fkey
.map
= fkey
.parent
= KVAR (current_kboard
, Vlocal_function_key_map
);
9018 keytran
.map
= keytran
.parent
= Vkey_translation_map
;
9019 indec
.start
= indec
.end
= 0;
9020 fkey
.start
= fkey
.end
= 0;
9021 keytran
.start
= keytran
.end
= 0;
9023 /* We jump here when the key sequence has been thoroughly changed, and
9024 we need to rescan it starting from the beginning. When we jump here,
9025 keybuf[0..mock_input] holds the sequence we should reread. */
9028 starting_buffer
= current_buffer
;
9029 first_unbound
= bufsize
+ 1;
9031 /* Build our list of keymaps.
9032 If we recognize a function key and replace its escape sequence in
9033 keybuf with its symbol, or if the sequence starts with a mouse
9034 click and we need to switch buffers, we jump back here to rebuild
9035 the initial keymaps from the current buffer. */
9038 if (!NILP (KVAR (current_kboard
, Voverriding_terminal_local_map
)))
9040 if (2 > nmaps_allocated
)
9042 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9043 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9044 nmaps_allocated
= 2;
9046 submaps
[nmaps
++] = KVAR (current_kboard
, Voverriding_terminal_local_map
);
9048 else if (!NILP (Voverriding_local_map
))
9050 if (2 > nmaps_allocated
)
9052 submaps
= (Lisp_Object
*) alloca (2 * sizeof (submaps
[0]));
9053 defs
= (Lisp_Object
*) alloca (2 * sizeof (defs
[0]));
9054 nmaps_allocated
= 2;
9056 submaps
[nmaps
++] = Voverriding_local_map
;
9064 nminor
= current_minor_maps (0, &maps
);
9065 total
= nminor
+ (!NILP (orig_keymap
) ? 3 : 2);
9067 if (total
> nmaps_allocated
)
9069 submaps
= (Lisp_Object
*) alloca (total
* sizeof (submaps
[0]));
9070 defs
= (Lisp_Object
*) alloca (total
* sizeof (defs
[0]));
9071 nmaps_allocated
= total
;
9074 if (!NILP (orig_keymap
))
9075 submaps
[nmaps
++] = orig_keymap
;
9077 memcpy (submaps
+ nmaps
, maps
, nminor
* sizeof (submaps
[0]));
9081 submaps
[nmaps
++] = orig_local_map
;
9083 submaps
[nmaps
++] = current_global_map
;
9085 /* Find an accurate initial value for first_binding. */
9086 for (first_binding
= 0; first_binding
< nmaps
; first_binding
++)
9087 if (! NILP (submaps
[first_binding
]))
9090 /* Start from the beginning in keybuf. */
9093 /* These are no-ops the first time through, but if we restart, they
9094 revert the echo area and this_command_keys to their original state. */
9095 this_command_key_count
= keys_start
;
9096 if (INTERACTIVE
&& t
< mock_input
)
9097 echo_truncate (echo_start
);
9099 /* If the best binding for the current key sequence is a keymap, or
9100 we may be looking at a function key's escape sequence, keep on
9102 while (first_binding
< nmaps
9103 /* Keep reading as long as there's a prefix binding. */
9104 ? !NILP (submaps
[first_binding
])
9105 /* Don't return in the middle of a possible function key sequence,
9106 if the only bindings we found were via case conversion.
9107 Thus, if ESC O a has a function-key-map translation
9108 and ESC o has a binding, don't return after ESC O,
9109 so that we can translate ESC O plus the next character. */
9110 : (/* indec.start < t || fkey.start < t || */ keytran
.start
< t
))
9113 int used_mouse_menu
= 0;
9115 /* Where the last real key started. If we need to throw away a
9116 key that has expanded into more than one element of keybuf
9117 (say, a mouse click on the mode line which is being treated
9118 as [mode-line (mouse-...)], then we backtrack to this point
9120 int last_real_key_start
;
9122 /* These variables are analogous to echo_start and keys_start;
9123 while those allow us to restart the entire key sequence,
9124 echo_local_start and keys_local_start allow us to throw away
9126 int echo_local_start
, keys_local_start
, local_first_binding
;
9128 eassert (indec
.end
== t
|| (indec
.end
> t
&& indec
.end
<= mock_input
));
9129 eassert (indec
.start
<= indec
.end
);
9130 eassert (fkey
.start
<= fkey
.end
);
9131 eassert (keytran
.start
<= keytran
.end
);
9132 /* key-translation-map is applied *after* function-key-map
9133 which is itself applied *after* input-decode-map. */
9134 eassert (fkey
.end
<= indec
.start
);
9135 eassert (keytran
.end
<= fkey
.start
);
9137 if (/* first_unbound < indec.start && first_unbound < fkey.start && */
9138 first_unbound
< keytran
.start
)
9139 { /* The prefix upto first_unbound has no binding and has
9140 no translation left to do either, so we know it's unbound.
9141 If we don't stop now, we risk staying here indefinitely
9142 (if the user keeps entering fkey or keytran prefixes
9143 like C-c ESC ESC ESC ESC ...) */
9145 for (i
= first_unbound
+ 1; i
< t
; i
++)
9146 keybuf
[i
- first_unbound
- 1] = keybuf
[i
];
9147 mock_input
= t
- first_unbound
- 1;
9148 indec
.end
= indec
.start
-= first_unbound
+ 1;
9149 indec
.map
= indec
.parent
;
9150 fkey
.end
= fkey
.start
-= first_unbound
+ 1;
9151 fkey
.map
= fkey
.parent
;
9152 keytran
.end
= keytran
.start
-= first_unbound
+ 1;
9153 keytran
.map
= keytran
.parent
;
9154 goto replay_sequence
;
9158 error ("Key sequence too long");
9161 echo_local_start
= echo_length ();
9162 keys_local_start
= this_command_key_count
;
9163 local_first_binding
= first_binding
;
9166 /* These are no-ops, unless we throw away a keystroke below and
9167 jumped back up to replay_key; in that case, these restore the
9168 variables to their original state, allowing us to replay the
9170 if (INTERACTIVE
&& t
< mock_input
)
9171 echo_truncate (echo_local_start
);
9172 this_command_key_count
= keys_local_start
;
9173 first_binding
= local_first_binding
;
9175 /* By default, assume each event is "real". */
9176 last_real_key_start
= t
;
9178 /* Does mock_input indicate that we are re-reading a key sequence? */
9182 add_command_key (key
);
9183 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9184 && NILP (Fzerop (Vecho_keystrokes
)))
9188 /* If not, we should actually read a character. */
9192 KBOARD
*interrupted_kboard
= current_kboard
;
9193 struct frame
*interrupted_frame
= SELECTED_FRAME ();
9194 key
= read_char (NILP (prompt
), nmaps
,
9195 (Lisp_Object
*) submaps
, last_nonmenu_event
,
9196 &used_mouse_menu
, NULL
);
9197 if ((INTEGERP (key
) && XINT (key
) == -2) /* wrong_kboard_jmpbuf */
9198 /* When switching to a new tty (with a new keyboard),
9199 read_char returns the new buffer, rather than -2
9200 (Bug#5095). This is because `terminal-init-xterm'
9201 calls read-char, which eats the wrong_kboard_jmpbuf
9202 return. Any better way to fix this? -- cyd */
9203 || (interrupted_kboard
!= current_kboard
))
9208 for (k
= all_kboards
; k
; k
= k
->next_kboard
)
9209 if (k
== interrupted_kboard
)
9214 /* Don't touch interrupted_kboard when it's been
9216 delayed_switch_frame
= Qnil
;
9217 goto replay_entire_sequence
;
9220 if (!NILP (delayed_switch_frame
))
9222 KVAR (interrupted_kboard
, kbd_queue
)
9223 = Fcons (delayed_switch_frame
,
9224 KVAR (interrupted_kboard
, kbd_queue
));
9225 delayed_switch_frame
= Qnil
;
9229 KVAR (interrupted_kboard
, kbd_queue
)
9230 = Fcons (keybuf
[--t
], KVAR (interrupted_kboard
, kbd_queue
));
9232 /* If the side queue is non-empty, ensure it begins with a
9233 switch-frame, so we'll replay it in the right context. */
9234 if (CONSP (KVAR (interrupted_kboard
, kbd_queue
))
9235 && (key
= XCAR (KVAR (interrupted_kboard
, kbd_queue
)),
9236 !(EVENT_HAS_PARAMETERS (key
)
9237 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)),
9241 XSETFRAME (frame
, interrupted_frame
);
9242 KVAR (interrupted_kboard
, kbd_queue
)
9243 = Fcons (make_lispy_switch_frame (frame
),
9244 KVAR (interrupted_kboard
, kbd_queue
));
9247 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9248 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9249 goto replay_entire_sequence
;
9253 /* read_char returns t when it shows a menu and the user rejects it.
9257 unbind_to (count
, Qnil
);
9258 UNGCPRO_VAR (outer_gcpro1
);
9262 /* read_char returns -1 at the end of a macro.
9263 Emacs 18 handles this by returning immediately with a
9264 zero, so that's what we'll do. */
9265 if (INTEGERP (key
) && XINT (key
) == -1)
9268 /* The Microsoft C compiler can't handle the goto that
9274 /* If the current buffer has been changed from under us, the
9275 keymap may have changed, so replay the sequence. */
9278 timer_resume_idle ();
9281 /* Reset the current buffer from the selected window
9282 in case something changed the former and not the latter.
9283 This is to be more consistent with the behavior
9284 of the command_loop_1. */
9285 if (fix_current_buffer
)
9287 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9289 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
9290 Fset_buffer (XWINDOW (selected_window
)->buffer
);
9293 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9294 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9295 goto replay_sequence
;
9298 /* If we have a quit that was typed in another frame, and
9299 quit_throw_to_read_char switched buffers,
9300 replay to get the right keymap. */
9302 && XINT (key
) == quit_char
9303 && current_buffer
!= starting_buffer
)
9306 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9310 orig_local_map
= get_local_map (PT
, current_buffer
, Qlocal_map
);
9311 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9312 goto replay_sequence
;
9317 if (EVENT_HAS_PARAMETERS (key
)
9318 /* Either a `switch-frame' or a `select-window' event. */
9319 && EQ (EVENT_HEAD_KIND (EVENT_HEAD (key
)), Qswitch_frame
))
9321 /* If we're at the beginning of a key sequence, and the caller
9322 says it's okay, go ahead and return this event. If we're
9323 in the midst of a key sequence, delay it until the end. */
9324 if (t
> 0 || !can_return_switch_frame
)
9326 delayed_switch_frame
= key
;
9332 ASET (raw_keybuf
, raw_keybuf_count
, key
);
9336 /* Clicks in non-text areas get prefixed by the symbol
9337 in their CHAR-ADDRESS field. For example, a click on
9338 the mode line is prefixed by the symbol `mode-line'.
9340 Furthermore, key sequences beginning with mouse clicks
9341 are read using the keymaps of the buffer clicked on, not
9342 the current buffer. So we may have to switch the buffer
9345 When we turn one event into two events, we must make sure
9346 that neither of the two looks like the original--so that,
9347 if we replay the events, they won't be expanded again.
9348 If not for this, such reexpansion could happen either here
9349 or when user programs play with this-command-keys. */
9350 if (EVENT_HAS_PARAMETERS (key
))
9355 kind
= EVENT_HEAD_KIND (EVENT_HEAD (key
));
9356 if (EQ (kind
, Qmouse_click
))
9358 Lisp_Object window
, posn
;
9360 window
= POSN_WINDOW (EVENT_START (key
));
9361 posn
= POSN_POSN (EVENT_START (key
));
9364 || (!NILP (fake_prefixed_keys
)
9365 && !NILP (Fmemq (key
, fake_prefixed_keys
))))
9367 /* We're looking a second time at an event for which
9368 we generated a fake prefix key. Set
9369 last_real_key_start appropriately. */
9371 last_real_key_start
= t
- 1;
9374 /* Key sequences beginning with mouse clicks are
9375 read using the keymaps in the buffer clicked on,
9376 not the current buffer. If we're at the
9377 beginning of a key sequence, switch buffers. */
9378 if (last_real_key_start
== 0
9380 && BUFFERP (XWINDOW (window
)->buffer
)
9381 && XBUFFER (XWINDOW (window
)->buffer
) != current_buffer
)
9383 XVECTOR (raw_keybuf
)->contents
[raw_keybuf_count
++] = key
;
9387 /* Arrange to go back to the original buffer once we're
9388 done reading the key sequence. Note that we can't
9389 use save_excursion_{save,restore} here, because they
9390 save point as well as the current buffer; we don't
9391 want to save point, because redisplay may change it,
9392 to accommodate a Fset_window_start or something. We
9393 don't want to do this at the top of the function,
9394 because we may get input from a subprocess which
9395 wants to change the selected window and stuff (say,
9397 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
9399 if (! FRAME_LIVE_P (XFRAME (selected_frame
)))
9401 set_buffer_internal (XBUFFER (XWINDOW (window
)->buffer
));
9402 orig_local_map
= get_local_map (PT
, current_buffer
,
9404 orig_keymap
= get_local_map (PT
, current_buffer
, Qkeymap
);
9405 goto replay_sequence
;
9408 /* For a mouse click, get the local text-property keymap
9409 of the place clicked on, rather than point. */
9410 if (last_real_key_start
== 0
9411 && CONSP (XCDR (key
))
9412 && ! localized_local_map
)
9414 Lisp_Object map_here
, start
, pos
;
9416 localized_local_map
= 1;
9417 start
= EVENT_START (key
);
9419 if (CONSP (start
) && POSN_INBUFFER_P (start
))
9421 pos
= POSN_BUFFER_POSN (start
);
9423 && XINT (pos
) >= BEGV
9424 && XINT (pos
) <= ZV
)
9426 map_here
= get_local_map (XINT (pos
),
9427 current_buffer
, Qlocal_map
);
9428 if (!EQ (map_here
, orig_local_map
))
9430 orig_local_map
= map_here
;
9431 ++localized_local_map
;
9434 map_here
= get_local_map (XINT (pos
),
9435 current_buffer
, Qkeymap
);
9436 if (!EQ (map_here
, orig_keymap
))
9438 orig_keymap
= map_here
;
9439 ++localized_local_map
;
9442 if (localized_local_map
> 1)
9447 goto replay_sequence
;
9453 /* Expand mode-line and scroll-bar events into two events:
9454 use posn as a fake prefix key. */
9456 && (NILP (fake_prefixed_keys
)
9457 || NILP (Fmemq (key
, fake_prefixed_keys
))))
9459 if (t
+ 1 >= bufsize
)
9460 error ("Key sequence too long");
9463 keybuf
[t
+ 1] = key
;
9466 /* Record that a fake prefix key has been generated
9467 for KEY. Don't modify the event; this would
9468 prevent proper action when the event is pushed
9469 back into unread-command-events. */
9470 fake_prefixed_keys
= Fcons (key
, fake_prefixed_keys
);
9472 /* If on a mode line string with a local keymap,
9473 reconsider the key sequence with that keymap. */
9474 if (string
= POSN_STRING (EVENT_START (key
)),
9475 (CONSP (string
) && STRINGP (XCAR (string
))))
9477 Lisp_Object pos
, map
, map2
;
9479 pos
= XCDR (string
);
9480 string
= XCAR (string
);
9482 && XINT (pos
) < SCHARS (string
))
9484 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9486 orig_local_map
= map
;
9487 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9490 if (!NILP (map
) || !NILP (map2
))
9491 goto replay_sequence
;
9497 else if (NILP (from_string
)
9498 && (string
= POSN_STRING (EVENT_START (key
)),
9499 (CONSP (string
) && STRINGP (XCAR (string
)))))
9501 /* For a click on a string, i.e. overlay string or a
9502 string displayed via the `display' property,
9503 consider `local-map' and `keymap' properties of
9505 Lisp_Object pos
, map
, map2
;
9507 pos
= XCDR (string
);
9508 string
= XCAR (string
);
9510 && XINT (pos
) < SCHARS (string
))
9512 map
= Fget_text_property (pos
, Qlocal_map
, string
);
9514 orig_local_map
= map
;
9515 map2
= Fget_text_property (pos
, Qkeymap
, string
);
9519 if (!NILP (map
) || !NILP (map2
))
9521 from_string
= string
;
9524 goto replay_sequence
;
9529 else if (CONSP (XCDR (key
))
9530 && CONSP (EVENT_START (key
))
9531 && CONSP (XCDR (EVENT_START (key
))))
9535 posn
= POSN_POSN (EVENT_START (key
));
9536 /* Handle menu-bar events:
9537 insert the dummy prefix event `menu-bar'. */
9538 if (EQ (posn
, Qmenu_bar
) || EQ (posn
, Qtool_bar
))
9540 if (t
+ 1 >= bufsize
)
9541 error ("Key sequence too long");
9545 /* Zap the position in key, so we know that we've
9546 expanded it, and don't try to do so again. */
9547 POSN_SET_POSN (EVENT_START (key
),
9548 Fcons (posn
, Qnil
));
9551 goto replay_sequence
;
9553 else if (CONSP (posn
))
9555 /* We're looking at the second event of a
9556 sequence which we expanded before. Set
9557 last_real_key_start appropriately. */
9558 if (last_real_key_start
== t
&& t
> 0)
9559 last_real_key_start
= t
- 1;
9564 /* We have finally decided that KEY is something we might want
9566 first_binding
= (follow_key (key
,
9567 nmaps
- first_binding
,
9568 submaps
+ first_binding
,
9569 defs
+ first_binding
,
9570 submaps
+ first_binding
)
9573 /* If KEY wasn't bound, we'll try some fallbacks. */
9574 if (first_binding
< nmaps
)
9575 /* This is needed for the following scenario:
9576 event 0: a down-event that gets dropped by calling replay_key.
9577 event 1: some normal prefix like C-h.
9578 After event 0, first_unbound is 0, after event 1 indec.start,
9579 fkey.start, and keytran.start are all 1, so when we see that
9580 C-h is bound, we need to update first_unbound. */
9581 first_unbound
= max (t
+ 1, first_unbound
);
9586 /* Remember the position to put an upper bound on indec.start. */
9587 first_unbound
= min (t
, first_unbound
);
9589 head
= EVENT_HEAD (key
);
9590 if (help_char_p (head
) && t
> 0)
9592 read_key_sequence_cmd
= Vprefix_help_command
;
9594 last_nonmenu_event
= key
;
9595 /* The Microsoft C compiler can't handle the goto that
9603 Lisp_Object breakdown
;
9606 breakdown
= parse_modifiers (head
);
9607 modifiers
= XINT (XCAR (XCDR (breakdown
)));
9608 /* Attempt to reduce an unbound mouse event to a simpler
9609 event that is bound:
9610 Drags reduce to clicks.
9611 Double-clicks reduce to clicks.
9612 Triple-clicks reduce to double-clicks, then to clicks.
9613 Down-clicks are eliminated.
9614 Double-downs reduce to downs, then are eliminated.
9615 Triple-downs reduce to double-downs, then to downs,
9616 then are eliminated. */
9617 if (modifiers
& (down_modifier
| drag_modifier
9618 | double_modifier
| triple_modifier
))
9620 while (modifiers
& (down_modifier
| drag_modifier
9621 | double_modifier
| triple_modifier
))
9623 Lisp_Object new_head
, new_click
;
9624 if (modifiers
& triple_modifier
)
9625 modifiers
^= (double_modifier
| triple_modifier
);
9626 else if (modifiers
& double_modifier
)
9627 modifiers
&= ~double_modifier
;
9628 else if (modifiers
& drag_modifier
)
9629 modifiers
&= ~drag_modifier
;
9632 /* Dispose of this `down' event by simply jumping
9633 back to replay_key, to get another event.
9635 Note that if this event came from mock input,
9636 then just jumping back to replay_key will just
9637 hand it to us again. So we have to wipe out any
9640 We could delete keybuf[t] and shift everything
9641 after that to the left by one spot, but we'd also
9642 have to fix up any variable that points into
9643 keybuf, and shifting isn't really necessary
9646 Adding prefixes for non-textual mouse clicks
9647 creates two characters of mock input, and both
9648 must be thrown away. If we're only looking at
9649 the prefix now, we can just jump back to
9650 replay_key. On the other hand, if we've already
9651 processed the prefix, and now the actual click
9652 itself is giving us trouble, then we've lost the
9653 state of the keymaps we want to backtrack to, and
9654 we need to replay the whole sequence to rebuild
9657 Beyond that, only function key expansion could
9658 create more than two keys, but that should never
9659 generate mouse events, so it's okay to zero
9660 mock_input in that case too.
9662 FIXME: The above paragraph seems just plain
9663 wrong, if you consider things like
9664 xterm-mouse-mode. -stef
9666 Isn't this just the most wonderful code ever? */
9668 /* If mock_input > t + 1, the above simplification
9669 will actually end up dropping keys on the floor.
9670 This is probably OK for now, but even
9671 if mock_input <= t + 1, we need to adjust indec,
9673 Typical case [header-line down-mouse-N]:
9674 mock_input = 2, t = 1, fkey.end = 1,
9675 last_real_key_start = 0. */
9676 if (indec
.end
> last_real_key_start
)
9678 indec
.end
= indec
.start
9679 = min (last_real_key_start
, indec
.start
);
9680 indec
.map
= indec
.parent
;
9681 if (fkey
.end
> last_real_key_start
)
9683 fkey
.end
= fkey
.start
9684 = min (last_real_key_start
, fkey
.start
);
9685 fkey
.map
= fkey
.parent
;
9686 if (keytran
.end
> last_real_key_start
)
9688 keytran
.end
= keytran
.start
9689 = min (last_real_key_start
, keytran
.start
);
9690 keytran
.map
= keytran
.parent
;
9694 if (t
== last_real_key_start
)
9701 mock_input
= last_real_key_start
;
9702 goto replay_sequence
;
9707 = apply_modifiers (modifiers
, XCAR (breakdown
));
9709 = Fcons (new_head
, Fcons (EVENT_START (key
), Qnil
));
9711 /* Look for a binding for this new key. follow_key
9712 promises that it didn't munge submaps the
9713 last time we called it, since key was unbound. */
9715 = (follow_key (new_click
,
9716 nmaps
- local_first_binding
,
9717 submaps
+ local_first_binding
,
9718 defs
+ local_first_binding
,
9719 submaps
+ local_first_binding
)
9720 + local_first_binding
);
9722 /* If that click is bound, go for it. */
9723 if (first_binding
< nmaps
)
9728 /* Otherwise, we'll leave key set to the drag event. */
9735 /* Normally, last_nonmenu_event gets the previous key we read.
9736 But when a mouse popup menu is being used,
9737 we don't update last_nonmenu_event; it continues to hold the mouse
9738 event that preceded the first level of menu. */
9739 if (!used_mouse_menu
)
9740 last_nonmenu_event
= key
;
9742 /* Record what part of this_command_keys is the current key sequence. */
9743 this_single_command_key_start
= this_command_key_count
- t
;
9745 /* Look for this sequence in input-decode-map.
9746 Scan from indec.end until we find a bound suffix. */
9747 while (indec
.end
< t
)
9749 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9752 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9753 done
= keyremap_step (keybuf
, bufsize
, &indec
, max (t
, mock_input
),
9758 mock_input
= diff
+ max (t
, mock_input
);
9759 goto replay_sequence
;
9763 if (first_binding
< nmaps
&& NILP (submaps
[first_binding
])
9764 && indec
.start
>= t
)
9765 /* There is a binding and it's not a prefix.
9766 (and it doesn't have any input-decode-map translation pending).
9767 There is thus no function-key in this sequence.
9768 Moving fkey.start is important in this case to allow keytran.start
9769 to go over the sequence before we return (since we keep the
9770 invariant that keytran.end <= fkey.start). */
9773 (fkey
.start
= fkey
.end
= t
, fkey
.map
= fkey
.parent
);
9776 /* If the sequence is unbound, see if we can hang a function key
9777 off the end of it. */
9778 /* Continue scan from fkey.end until we find a bound suffix. */
9779 while (fkey
.end
< indec
.start
)
9781 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9784 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9785 done
= keyremap_step (keybuf
, bufsize
, &fkey
,
9786 max (t
, mock_input
),
9787 /* If there's a binding (i.e.
9788 first_binding >= nmaps) we don't want
9789 to apply this function-key-mapping. */
9790 fkey
.end
+ 1 == t
&& first_binding
>= nmaps
,
9795 mock_input
= diff
+ max (t
, mock_input
);
9796 /* Adjust the input-decode-map counters. */
9798 indec
.start
+= diff
;
9800 goto replay_sequence
;
9804 /* Look for this sequence in key-translation-map.
9805 Scan from keytran.end until we find a bound suffix. */
9806 while (keytran
.end
< fkey
.start
)
9808 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9811 GCPRO4 (indec
.map
, fkey
.map
, keytran
.map
, delayed_switch_frame
);
9812 done
= keyremap_step (keybuf
, bufsize
, &keytran
, max (t
, mock_input
),
9817 mock_input
= diff
+ max (t
, mock_input
);
9818 /* Adjust the function-key-map and input-decode-map counters. */
9820 indec
.start
+= diff
;
9824 goto replay_sequence
;
9828 /* If KEY is not defined in any of the keymaps,
9829 and cannot be part of a function key or translation,
9830 and is an upper case letter
9831 use the corresponding lower-case letter instead. */
9832 if (first_binding
>= nmaps
9833 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
9835 && ((CHARACTERP (make_number (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9836 && UPPERCASEP (XINT (key
) & ~CHAR_MODIFIER_MASK
))
9837 || (XINT (key
) & shift_modifier
)))
9839 Lisp_Object new_key
;
9841 original_uppercase
= key
;
9842 original_uppercase_position
= t
- 1;
9844 if (XINT (key
) & shift_modifier
)
9845 XSETINT (new_key
, XINT (key
) & ~shift_modifier
);
9847 XSETINT (new_key
, (DOWNCASE (XINT (key
) & ~CHAR_MODIFIER_MASK
)
9848 | (XINT (key
) & CHAR_MODIFIER_MASK
)));
9850 /* We have to do this unconditionally, regardless of whether
9851 the lower-case char is defined in the keymaps, because they
9852 might get translated through function-key-map. */
9853 keybuf
[t
- 1] = new_key
;
9854 mock_input
= max (t
, mock_input
);
9855 shift_translated
= 1;
9857 goto replay_sequence
;
9859 /* If KEY is not defined in any of the keymaps,
9860 and cannot be part of a function key or translation,
9861 and is a shifted function key,
9862 use the corresponding unshifted function key instead. */
9863 if (first_binding
>= nmaps
9864 && /* indec.start >= t && fkey.start >= t && */ keytran
.start
>= t
)
9866 Lisp_Object breakdown
= parse_modifiers (key
);
9868 = CONSP (breakdown
) ? (XINT (XCAR (XCDR (breakdown
)))) : 0;
9870 if (modifiers
& shift_modifier
9871 /* Treat uppercase keys as shifted. */
9873 && (KEY_TO_CHAR (key
)
9874 < XCHAR_TABLE (BVAR (current_buffer
, downcase_table
))->size
)
9875 && UPPERCASEP (KEY_TO_CHAR (key
))))
9878 = (modifiers
& shift_modifier
9879 ? apply_modifiers (modifiers
& ~shift_modifier
,
9881 : make_number (DOWNCASE (KEY_TO_CHAR (key
)) | modifiers
));
9883 original_uppercase
= key
;
9884 original_uppercase_position
= t
- 1;
9886 /* We have to do this unconditionally, regardless of whether
9887 the lower-case char is defined in the keymaps, because they
9888 might get translated through function-key-map. */
9889 keybuf
[t
- 1] = new_key
;
9890 mock_input
= max (t
, mock_input
);
9891 /* Reset fkey (and consequently keytran) to apply
9892 function-key-map on the result, so that S-backspace is
9893 correctly mapped to DEL (via backspace). OTOH,
9894 input-decode-map doesn't need to go through it again. */
9895 fkey
.start
= fkey
.end
= 0;
9896 keytran
.start
= keytran
.end
= 0;
9897 shift_translated
= 1;
9899 goto replay_sequence
;
9904 read_key_sequence_cmd
= (first_binding
< nmaps
9905 ? defs
[first_binding
]
9908 unread_switch_frame
= delayed_switch_frame
;
9909 unbind_to (count
, Qnil
);
9911 /* Don't downcase the last character if the caller says don't.
9912 Don't downcase it if the result is undefined, either. */
9913 if ((dont_downcase_last
|| first_binding
>= nmaps
)
9915 && t
- 1 == original_uppercase_position
)
9917 keybuf
[t
- 1] = original_uppercase
;
9918 shift_translated
= 0;
9921 if (shift_translated
)
9922 Vthis_command_keys_shift_translated
= Qt
;
9924 /* Occasionally we fabricate events, perhaps by expanding something
9925 according to function-key-map, or by adding a prefix symbol to a
9926 mouse click in the scroll bar or modeline. In this cases, return
9927 the entire generated key sequence, even if we hit an unbound
9928 prefix or a definition before the end. This means that you will
9929 be able to push back the event properly, and also means that
9930 read-key-sequence will always return a logical unit.
9933 for (; t
< mock_input
; t
++)
9935 if ((FLOATP (Vecho_keystrokes
) || INTEGERP (Vecho_keystrokes
))
9936 && NILP (Fzerop (Vecho_keystrokes
)))
9937 echo_char (keybuf
[t
]);
9938 add_command_key (keybuf
[t
]);
9941 UNGCPRO_VAR (outer_gcpro1
);
9945 DEFUN ("read-key-sequence", Fread_key_sequence
, Sread_key_sequence
, 1, 5, 0,
9946 doc
: /* Read a sequence of keystrokes and return as a string or vector.
9947 The sequence is sufficient to specify a non-prefix command in the
9948 current local and global maps.
9950 First arg PROMPT is a prompt string. If nil, do not prompt specially.
9951 Second (optional) arg CONTINUE-ECHO, if non-nil, means this key echos
9952 as a continuation of the previous key.
9954 The third (optional) arg DONT-DOWNCASE-LAST, if non-nil, means do not
9955 convert the last event to lower case. (Normally any upper case event
9956 is converted to lower case if the original event is undefined and the lower
9957 case equivalent is defined.) A non-nil value is appropriate for reading
9958 a key sequence to be defined.
9960 A C-g typed while in this function is treated like any other character,
9961 and `quit-flag' is not set.
9963 If the key sequence starts with a mouse click, then the sequence is read
9964 using the keymaps of the buffer of the window clicked in, not the buffer
9965 of the selected window as normal.
9967 `read-key-sequence' drops unbound button-down events, since you normally
9968 only care about the click or drag events which follow them. If a drag
9969 or multi-click event is unbound, but the corresponding click event would
9970 be bound, `read-key-sequence' turns the event into a click event at the
9971 drag's starting position. This means that you don't have to distinguish
9972 between click and drag, double, or triple events unless you want to.
9974 `read-key-sequence' prefixes mouse events on mode lines, the vertical
9975 lines separating windows, and scroll bars with imaginary keys
9976 `mode-line', `vertical-line', and `vertical-scroll-bar'.
9978 Optional fourth argument CAN-RETURN-SWITCH-FRAME non-nil means that this
9979 function will process a switch-frame event if the user switches frames
9980 before typing anything. If the user switches frames in the middle of a
9981 key sequence, or at the start of the sequence but CAN-RETURN-SWITCH-FRAME
9982 is nil, then the event will be put off until after the current key sequence.
9984 `read-key-sequence' checks `function-key-map' for function key
9985 sequences, where they wouldn't conflict with ordinary bindings. See
9986 `function-key-map' for more details.
9988 The optional fifth argument CMD-LOOP, if non-nil, means
9989 that this key sequence is being read by something that will
9990 read commands one after another. It should be nil if the caller
9991 will read just one key sequence. */)
9992 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object cmd_loop
)
9994 Lisp_Object keybuf
[30];
9996 struct gcpro gcpro1
;
9997 int count
= SPECPDL_INDEX ();
10000 CHECK_STRING (prompt
);
10003 specbind (Qinput_method_exit_on_first_char
,
10004 (NILP (cmd_loop
) ? Qt
: Qnil
));
10005 specbind (Qinput_method_use_echo_area
,
10006 (NILP (cmd_loop
) ? Qt
: Qnil
));
10008 memset (keybuf
, 0, sizeof keybuf
);
10009 GCPRO1 (keybuf
[0]);
10010 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10012 if (NILP (continue_echo
))
10014 this_command_key_count
= 0;
10015 this_command_key_count_reset
= 0;
10016 this_single_command_key_start
= 0;
10019 #ifdef HAVE_WINDOW_SYSTEM
10020 if (display_hourglass_p
)
10021 cancel_hourglass ();
10024 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10025 prompt
, ! NILP (dont_downcase_last
),
10026 ! NILP (can_return_switch_frame
), 0);
10028 #if 0 /* The following is fine for code reading a key sequence and
10029 then proceeding with a lenghty computation, but it's not good
10030 for code reading keys in a loop, like an input method. */
10031 #ifdef HAVE_WINDOW_SYSTEM
10032 if (display_hourglass_p
)
10033 start_hourglass ();
10043 return unbind_to (count
, make_event_array (i
, keybuf
));
10046 DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector
,
10047 Sread_key_sequence_vector
, 1, 5, 0,
10048 doc
: /* Like `read-key-sequence' but always return a vector. */)
10049 (Lisp_Object prompt
, Lisp_Object continue_echo
, Lisp_Object dont_downcase_last
, Lisp_Object can_return_switch_frame
, Lisp_Object cmd_loop
)
10051 Lisp_Object keybuf
[30];
10053 struct gcpro gcpro1
;
10054 int count
= SPECPDL_INDEX ();
10056 if (!NILP (prompt
))
10057 CHECK_STRING (prompt
);
10060 specbind (Qinput_method_exit_on_first_char
,
10061 (NILP (cmd_loop
) ? Qt
: Qnil
));
10062 specbind (Qinput_method_use_echo_area
,
10063 (NILP (cmd_loop
) ? Qt
: Qnil
));
10065 memset (keybuf
, 0, sizeof keybuf
);
10066 GCPRO1 (keybuf
[0]);
10067 gcpro1
.nvars
= (sizeof keybuf
/sizeof (keybuf
[0]));
10069 if (NILP (continue_echo
))
10071 this_command_key_count
= 0;
10072 this_command_key_count_reset
= 0;
10073 this_single_command_key_start
= 0;
10076 #ifdef HAVE_WINDOW_SYSTEM
10077 if (display_hourglass_p
)
10078 cancel_hourglass ();
10081 i
= read_key_sequence (keybuf
, (sizeof keybuf
/sizeof (keybuf
[0])),
10082 prompt
, ! NILP (dont_downcase_last
),
10083 ! NILP (can_return_switch_frame
), 0);
10085 #ifdef HAVE_WINDOW_SYSTEM
10086 if (display_hourglass_p
)
10087 start_hourglass ();
10096 return unbind_to (count
, Fvector (i
, keybuf
));
10099 DEFUN ("command-execute", Fcommand_execute
, Scommand_execute
, 1, 4, 0,
10100 doc
: /* Execute CMD as an editor command.
10101 CMD must be a symbol that satisfies the `commandp' predicate.
10102 Optional second arg RECORD-FLAG non-nil
10103 means unconditionally put this command in `command-history'.
10104 Otherwise, that is done only if an arg is read using the minibuffer.
10105 The argument KEYS specifies the value to use instead of (this-command-keys)
10106 when reading the arguments; if it is nil, (this-command-keys) is used.
10107 The argument SPECIAL, if non-nil, means that this command is executing
10108 a special event, so ignore the prefix argument and don't clear it. */)
10109 (Lisp_Object cmd
, Lisp_Object record_flag
, Lisp_Object keys
, Lisp_Object special
)
10111 register Lisp_Object final
;
10112 register Lisp_Object tem
;
10113 Lisp_Object prefixarg
;
10115 debug_on_next_call
= 0;
10117 if (NILP (special
))
10119 prefixarg
= KVAR (current_kboard
, Vprefix_arg
);
10120 Vcurrent_prefix_arg
= prefixarg
;
10121 KVAR (current_kboard
, Vprefix_arg
) = Qnil
;
10128 tem
= Fget (cmd
, Qdisabled
);
10129 if (!NILP (tem
) && !NILP (Vrun_hooks
))
10131 tem
= Fsymbol_value (Qdisabled_command_function
);
10133 return call1 (Vrun_hooks
, Qdisabled_command_function
);
10139 final
= Findirect_function (cmd
, Qnil
);
10141 if (CONSP (final
) && (tem
= Fcar (final
), EQ (tem
, Qautoload
)))
10143 struct gcpro gcpro1
, gcpro2
;
10145 GCPRO2 (cmd
, prefixarg
);
10146 do_autoload (final
, cmd
);
10153 if (STRINGP (final
) || VECTORP (final
))
10155 /* If requested, place the macro in the command history. For
10156 other sorts of commands, call-interactively takes care of
10158 if (!NILP (record_flag
))
10161 = Fcons (Fcons (Qexecute_kbd_macro
,
10162 Fcons (final
, Fcons (prefixarg
, Qnil
))),
10165 /* Don't keep command history around forever. */
10166 if (NUMBERP (Vhistory_length
) && XINT (Vhistory_length
) > 0)
10168 tem
= Fnthcdr (Vhistory_length
, Vcommand_history
);
10170 XSETCDR (tem
, Qnil
);
10174 return Fexecute_kbd_macro (final
, prefixarg
, Qnil
);
10177 if (CONSP (final
) || SUBRP (final
) || COMPILEDP (final
))
10178 /* Don't call Fcall_interactively directly because we want to make
10179 sure the backtrace has an entry for `call-interactively'.
10180 For the same reason, pass `cmd' rather than `final'. */
10181 return call3 (Qcall_interactively
, cmd
, record_flag
, keys
);
10188 DEFUN ("execute-extended-command", Fexecute_extended_command
, Sexecute_extended_command
,
10190 doc
: /* Read function name, then read its arguments and call it.
10192 To pass a numeric argument to the command you are invoking with, specify
10193 the numeric argument to this command.
10195 Noninteractively, the argument PREFIXARG is the prefix argument to
10196 give to the command you invoke, if it asks for an argument. */)
10197 (Lisp_Object prefixarg
)
10199 Lisp_Object function
;
10200 EMACS_INT saved_last_point_position
;
10201 Lisp_Object saved_keys
, saved_last_point_position_buffer
;
10202 Lisp_Object bindings
, value
;
10203 struct gcpro gcpro1
, gcpro2
, gcpro3
;
10204 #ifdef HAVE_WINDOW_SYSTEM
10205 /* The call to Fcompleting_read will start and cancel the hourglass,
10206 but if the hourglass was already scheduled, this means that no
10207 hourglass will be shown for the actual M-x command itself.
10208 So we restart it if it is already scheduled. Note that checking
10209 hourglass_shown_p is not enough, normally the hourglass is not shown,
10210 just scheduled to be shown. */
10211 int hstarted
= hourglass_started ();
10214 saved_keys
= Fvector (this_command_key_count
,
10215 XVECTOR (this_command_keys
)->contents
);
10216 saved_last_point_position_buffer
= last_point_position_buffer
;
10217 saved_last_point_position
= last_point_position
;
10218 GCPRO3 (saved_keys
, prefixarg
, saved_last_point_position_buffer
);
10220 function
= call0 (intern ("read-extended-command"));
10222 #ifdef HAVE_WINDOW_SYSTEM
10223 if (hstarted
) start_hourglass ();
10226 if (STRINGP (function
) && SCHARS (function
) == 0)
10227 error ("No command name given");
10229 /* Set this_command_keys to the concatenation of saved_keys and
10230 function, followed by a RET. */
10235 this_command_key_count
= 0;
10236 this_command_key_count_reset
= 0;
10237 this_single_command_key_start
= 0;
10239 keys
= XVECTOR (saved_keys
)->contents
;
10240 for (i
= 0; i
< XVECTOR (saved_keys
)->size
; i
++)
10241 add_command_key (keys
[i
]);
10243 for (i
= 0; i
< SCHARS (function
); i
++)
10244 add_command_key (Faref (function
, make_number (i
)));
10246 add_command_key (make_number ('\015'));
10249 last_point_position
= saved_last_point_position
;
10250 last_point_position_buffer
= saved_last_point_position_buffer
;
10254 function
= Fintern (function
, Qnil
);
10255 KVAR (current_kboard
, Vprefix_arg
) = prefixarg
;
10256 Vthis_command
= function
;
10257 real_this_command
= function
;
10259 /* If enabled, show which key runs this command. */
10260 if (!NILP (Vsuggest_key_bindings
)
10261 && NILP (Vexecuting_kbd_macro
)
10262 && SYMBOLP (function
))
10263 bindings
= Fwhere_is_internal (function
, Voverriding_local_map
,
10269 GCPRO3 (bindings
, value
, function
);
10270 value
= Fcommand_execute (function
, Qt
, Qnil
, Qnil
);
10272 /* If the command has a key binding, print it now. */
10273 if (!NILP (bindings
)
10274 && ! (VECTORP (bindings
) && EQ (Faref (bindings
, make_number (0)),
10277 /* But first wait, and skip the message if there is input. */
10278 Lisp_Object waited
;
10280 /* If this command displayed something in the echo area;
10281 wait a few seconds, then display our suggestion message. */
10282 if (NILP (echo_area_buffer
[0]))
10283 waited
= sit_for (make_number (0), 0, 2);
10284 else if (NUMBERP (Vsuggest_key_bindings
))
10285 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10287 waited
= sit_for (make_number (2), 0, 2);
10289 if (!NILP (waited
) && ! CONSP (Vunread_command_events
))
10291 Lisp_Object binding
;
10293 int message_p
= push_message ();
10294 int count
= SPECPDL_INDEX ();
10296 record_unwind_protect (pop_message_unwind
, Qnil
);
10297 binding
= Fkey_description (bindings
, Qnil
);
10300 = (char *) alloca (SCHARS (SYMBOL_NAME (function
))
10303 sprintf (newmessage
, "You can run the command `%s' with %s",
10304 SDATA (SYMBOL_NAME (function
)),
10306 message2_nolog (newmessage
,
10307 strlen (newmessage
),
10308 STRING_MULTIBYTE (binding
));
10309 if (NUMBERP (Vsuggest_key_bindings
))
10310 waited
= sit_for (Vsuggest_key_bindings
, 0, 2);
10312 waited
= sit_for (make_number (2), 0, 2);
10314 if (!NILP (waited
) && message_p
)
10315 restore_message ();
10317 unbind_to (count
, Qnil
);
10321 RETURN_UNGCPRO (value
);
10325 /* Return nonzero if input events are pending. */
10328 detect_input_pending (void)
10330 if (!input_pending
)
10331 get_input_pending (&input_pending
, 0);
10333 return input_pending
;
10336 /* Return nonzero if input events other than mouse movements are
10340 detect_input_pending_ignore_squeezables (void)
10342 if (!input_pending
)
10343 get_input_pending (&input_pending
, READABLE_EVENTS_IGNORE_SQUEEZABLES
);
10345 return input_pending
;
10348 /* Return nonzero if input events are pending, and run any pending timers. */
10351 detect_input_pending_run_timers (int do_display
)
10353 int old_timers_run
= timers_run
;
10355 if (!input_pending
)
10356 get_input_pending (&input_pending
, READABLE_EVENTS_DO_TIMERS_NOW
);
10358 if (old_timers_run
!= timers_run
&& do_display
)
10360 redisplay_preserve_echo_area (8);
10361 /* The following fixes a bug when using lazy-lock with
10362 lazy-lock-defer-on-the-fly set to t, i.e. when fontifying
10363 from an idle timer function. The symptom of the bug is that
10364 the cursor sometimes doesn't become visible until the next X
10365 event is processed. --gerd. */
10367 Lisp_Object tail
, frame
;
10368 FOR_EACH_FRAME (tail
, frame
)
10369 if (FRAME_RIF (XFRAME (frame
)))
10370 FRAME_RIF (XFRAME (frame
))->flush_display (XFRAME (frame
));
10374 return input_pending
;
10377 /* This is called in some cases before a possible quit.
10378 It cases the next call to detect_input_pending to recompute input_pending.
10379 So calling this function unnecessarily can't do any harm. */
10382 clear_input_pending (void)
10387 /* Return nonzero if there are pending requeued events.
10388 This isn't used yet. The hope is to make wait_reading_process_output
10389 call it, and return if it runs Lisp code that unreads something.
10390 The problem is, kbd_buffer_get_event needs to be fixed to know what
10391 to do in that case. It isn't trivial. */
10394 requeued_events_pending_p (void)
10396 return (!NILP (Vunread_command_events
) || unread_command_char
!= -1);
10400 DEFUN ("input-pending-p", Finput_pending_p
, Sinput_pending_p
, 0, 0, 0,
10401 doc
: /* Return t if command input is currently available with no wait.
10402 Actually, the value is nil only if we can be sure that no input is available;
10403 if there is a doubt, the value is t. */)
10406 if (!NILP (Vunread_command_events
) || unread_command_char
!= -1
10407 || !NILP (Vunread_post_input_method_events
)
10408 || !NILP (Vunread_input_method_events
))
10411 get_input_pending (&input_pending
,
10412 READABLE_EVENTS_DO_TIMERS_NOW
10413 | READABLE_EVENTS_FILTER_EVENTS
);
10414 return input_pending
> 0 ? Qt
: Qnil
;
10417 DEFUN ("recent-keys", Frecent_keys
, Srecent_keys
, 0, 0, 0,
10418 doc
: /* Return vector of last 300 events, not counting those from keyboard macros. */)
10421 Lisp_Object
*keys
= XVECTOR (recent_keys
)->contents
;
10424 if (total_keys
< NUM_RECENT_KEYS
)
10425 return Fvector (total_keys
, keys
);
10428 val
= Fvector (NUM_RECENT_KEYS
, keys
);
10429 memcpy (XVECTOR (val
)->contents
, keys
+ recent_keys_index
,
10430 (NUM_RECENT_KEYS
- recent_keys_index
) * sizeof (Lisp_Object
));
10431 memcpy (XVECTOR (val
)->contents
+ NUM_RECENT_KEYS
- recent_keys_index
,
10432 keys
, recent_keys_index
* sizeof (Lisp_Object
));
10437 DEFUN ("this-command-keys", Fthis_command_keys
, Sthis_command_keys
, 0, 0, 0,
10438 doc
: /* Return the key sequence that invoked this command.
10439 However, if the command has called `read-key-sequence', it returns
10440 the last key sequence that has been read.
10441 The value is a string or a vector.
10443 See also `this-command-keys-vector'. */)
10446 return make_event_array (this_command_key_count
,
10447 XVECTOR (this_command_keys
)->contents
);
10450 DEFUN ("this-command-keys-vector", Fthis_command_keys_vector
, Sthis_command_keys_vector
, 0, 0, 0,
10451 doc
: /* Return the key sequence that invoked this command, as a vector.
10452 However, if the command has called `read-key-sequence', it returns
10453 the last key sequence that has been read.
10455 See also `this-command-keys'. */)
10458 return Fvector (this_command_key_count
,
10459 XVECTOR (this_command_keys
)->contents
);
10462 DEFUN ("this-single-command-keys", Fthis_single_command_keys
,
10463 Sthis_single_command_keys
, 0, 0, 0,
10464 doc
: /* Return the key sequence that invoked this command.
10465 More generally, it returns the last key sequence read, either by
10466 the command loop or by `read-key-sequence'.
10467 Unlike `this-command-keys', this function's value
10468 does not include prefix arguments.
10469 The value is always a vector. */)
10472 return Fvector (this_command_key_count
10473 - this_single_command_key_start
,
10474 (XVECTOR (this_command_keys
)->contents
10475 + this_single_command_key_start
));
10478 DEFUN ("this-single-command-raw-keys", Fthis_single_command_raw_keys
,
10479 Sthis_single_command_raw_keys
, 0, 0, 0,
10480 doc
: /* Return the raw events that were read for this command.
10481 More generally, it returns the last key sequence read, either by
10482 the command loop or by `read-key-sequence'.
10483 Unlike `this-single-command-keys', this function's value
10484 shows the events before all translations (except for input methods).
10485 The value is always a vector. */)
10488 return Fvector (raw_keybuf_count
,
10489 (XVECTOR (raw_keybuf
)->contents
));
10492 DEFUN ("reset-this-command-lengths", Freset_this_command_lengths
,
10493 Sreset_this_command_lengths
, 0, 0, 0,
10494 doc
: /* Make the unread events replace the last command and echo.
10495 Used in `universal-argument-other-key'.
10497 `universal-argument-other-key' rereads the event just typed.
10498 It then gets translated through `function-key-map'.
10499 The translated event has to replace the real events,
10500 both in the value of (this-command-keys) and in echoing.
10501 To achieve this, `universal-argument-other-key' calls
10502 `reset-this-command-lengths', which discards the record of reading
10503 these events the first time. */)
10506 this_command_key_count
= before_command_key_count
;
10507 if (this_command_key_count
< this_single_command_key_start
)
10508 this_single_command_key_start
= this_command_key_count
;
10510 echo_truncate (before_command_echo_length
);
10512 /* Cause whatever we put into unread-command-events
10513 to echo as if it were being freshly read from the keyboard. */
10514 this_command_key_count_reset
= 1;
10519 DEFUN ("clear-this-command-keys", Fclear_this_command_keys
,
10520 Sclear_this_command_keys
, 0, 1, 0,
10521 doc
: /* Clear out the vector that `this-command-keys' returns.
10522 Also clear the record of the last 100 events, unless optional arg
10523 KEEP-RECORD is non-nil. */)
10524 (Lisp_Object keep_record
)
10528 this_command_key_count
= 0;
10529 this_command_key_count_reset
= 0;
10531 if (NILP (keep_record
))
10533 for (i
= 0; i
< XVECTOR (recent_keys
)->size
; ++i
)
10534 XVECTOR (recent_keys
)->contents
[i
] = Qnil
;
10536 recent_keys_index
= 0;
10541 DEFUN ("recursion-depth", Frecursion_depth
, Srecursion_depth
, 0, 0, 0,
10542 doc
: /* Return the current depth in recursive edits. */)
10546 XSETFASTINT (temp
, command_loop_level
+ minibuf_level
);
10550 DEFUN ("open-dribble-file", Fopen_dribble_file
, Sopen_dribble_file
, 1, 1,
10551 "FOpen dribble file: ",
10552 doc
: /* Start writing all keyboard characters to a dribble file called FILE.
10553 If FILE is nil, close any open dribble file. */)
10565 file
= Fexpand_file_name (file
, Qnil
);
10566 dribble
= fopen (SSDATA (file
), "w");
10568 report_file_error ("Opening dribble", Fcons (file
, Qnil
));
10573 DEFUN ("discard-input", Fdiscard_input
, Sdiscard_input
, 0, 0, 0,
10574 doc
: /* Discard the contents of the terminal input buffer.
10575 Also end any kbd macro being defined. */)
10578 if (!NILP (KVAR (current_kboard
, defining_kbd_macro
)))
10580 /* Discard the last command from the macro. */
10581 Fcancel_kbd_macro_events ();
10585 update_mode_lines
++;
10587 Vunread_command_events
= Qnil
;
10588 unread_command_char
= -1;
10590 discard_tty_input ();
10592 kbd_fetch_ptr
= kbd_store_ptr
;
10598 DEFUN ("suspend-emacs", Fsuspend_emacs
, Ssuspend_emacs
, 0, 1, "",
10599 doc
: /* Stop Emacs and return to superior process. You can resume later.
10600 If `cannot-suspend' is non-nil, or if the system doesn't support job
10601 control, run a subshell instead.
10603 If optional arg STUFFSTRING is non-nil, its characters are stuffed
10604 to be read as terminal input by Emacs's parent, after suspension.
10606 Before suspending, run the normal hook `suspend-hook'.
10607 After resumption run the normal hook `suspend-resume-hook'.
10609 Some operating systems cannot stop the Emacs process and resume it later.
10610 On such systems, Emacs starts a subshell instead of suspending. */)
10611 (Lisp_Object stuffstring
)
10613 int count
= SPECPDL_INDEX ();
10614 int old_height
, old_width
;
10616 struct gcpro gcpro1
;
10618 if (tty_list
&& tty_list
->next
)
10619 error ("There are other tty frames open; close them before suspending Emacs");
10621 if (!NILP (stuffstring
))
10622 CHECK_STRING (stuffstring
);
10624 /* Run the functions in suspend-hook. */
10625 if (!NILP (Vrun_hooks
))
10626 call1 (Vrun_hooks
, intern ("suspend-hook"));
10628 GCPRO1 (stuffstring
);
10629 get_tty_size (fileno (CURTTY ()->input
), &old_width
, &old_height
);
10630 reset_all_sys_modes ();
10631 /* sys_suspend can get an error if it tries to fork a subshell
10632 and the system resources aren't available for that. */
10633 record_unwind_protect ((Lisp_Object (*) (Lisp_Object
)) init_all_sys_modes
,
10635 stuff_buffered_input (stuffstring
);
10636 if (cannot_suspend
)
10640 unbind_to (count
, Qnil
);
10642 /* Check if terminal/window size has changed.
10643 Note that this is not useful when we are running directly
10644 with a window system; but suspend should be disabled in that case. */
10645 get_tty_size (fileno (CURTTY ()->input
), &width
, &height
);
10646 if (width
!= old_width
|| height
!= old_height
)
10647 change_frame_size (SELECTED_FRAME (), height
, width
, 0, 0, 0);
10649 /* Run suspend-resume-hook. */
10650 if (!NILP (Vrun_hooks
))
10651 call1 (Vrun_hooks
, intern ("suspend-resume-hook"));
10657 /* If STUFFSTRING is a string, stuff its contents as pending terminal input.
10658 Then in any case stuff anything Emacs has read ahead and not used. */
10661 stuff_buffered_input (Lisp_Object stuffstring
)
10663 #ifdef SIGTSTP /* stuff_char is defined if SIGTSTP. */
10664 register unsigned char *p
;
10666 if (STRINGP (stuffstring
))
10668 register EMACS_INT count
;
10670 p
= SDATA (stuffstring
);
10671 count
= SBYTES (stuffstring
);
10672 while (count
-- > 0)
10677 /* Anything we have read ahead, put back for the shell to read. */
10678 /* ?? What should this do when we have multiple keyboards??
10679 Should we ignore anything that was typed in at the "wrong" kboard?
10681 rms: we should stuff everything back into the kboard
10683 for (; kbd_fetch_ptr
!= kbd_store_ptr
; kbd_fetch_ptr
++)
10686 if (kbd_fetch_ptr
== kbd_buffer
+ KBD_BUFFER_SIZE
)
10687 kbd_fetch_ptr
= kbd_buffer
;
10688 if (kbd_fetch_ptr
->kind
== ASCII_KEYSTROKE_EVENT
)
10689 stuff_char (kbd_fetch_ptr
->code
);
10691 clear_event (kbd_fetch_ptr
);
10695 #endif /* SIGTSTP */
10699 set_waiting_for_input (struct timeval
*time_to_clear
)
10701 input_available_clear_time
= time_to_clear
;
10703 /* Tell handle_interrupt to throw back to read_char, */
10704 waiting_for_input
= 1;
10706 /* If handle_interrupt was called before and buffered a C-g,
10707 make it run again now, to avoid timing error. */
10708 if (!NILP (Vquit_flag
))
10709 quit_throw_to_read_char ();
10713 clear_waiting_for_input (void)
10715 /* Tell handle_interrupt not to throw back to read_char, */
10716 waiting_for_input
= 0;
10717 input_available_clear_time
= 0;
10720 /* The SIGINT handler.
10722 If we have a frame on the controlling tty, we assume that the
10723 SIGINT was generated by C-g, so we call handle_interrupt.
10724 Otherwise, the handler kills Emacs. */
10727 interrupt_signal (int signalnum
) /* If we don't have an argument, some */
10728 /* compilers complain in signal calls. */
10730 /* Must preserve main program's value of errno. */
10731 int old_errno
= errno
;
10732 struct terminal
*terminal
;
10734 SIGNAL_THREAD_CHECK (signalnum
);
10736 /* See if we have an active terminal on our controlling tty. */
10737 terminal
= get_named_tty ("/dev/tty");
10740 /* If there are no frames there, let's pretend that we are a
10741 well-behaving UN*X program and quit. */
10742 Fkill_emacs (Qnil
);
10746 /* Otherwise, the SIGINT was probably generated by C-g. */
10748 /* Set internal_last_event_frame to the top frame of the
10749 controlling tty, if we have a frame there. We disable the
10750 interrupt key on secondary ttys, so the SIGINT must have come
10751 from the controlling tty. */
10752 internal_last_event_frame
= terminal
->display_info
.tty
->top_frame
;
10754 handle_interrupt ();
10760 /* This routine is called at interrupt level in response to C-g.
10762 It is called from the SIGINT handler or kbd_buffer_store_event.
10764 If `waiting_for_input' is non zero, then unless `echoing' is
10765 nonzero, immediately throw back to read_char.
10767 Otherwise it sets the Lisp variable quit-flag not-nil. This causes
10768 eval to throw, when it gets a chance. If quit-flag is already
10769 non-nil, it stops the job right away. */
10772 handle_interrupt (void)
10778 /* XXX This code needs to be revised for multi-tty support. */
10779 if (!NILP (Vquit_flag
) && get_named_tty ("/dev/tty"))
10781 /* If SIGINT isn't blocked, don't let us be interrupted by
10782 another SIGINT, it might be harmful due to non-reentrancy
10783 in I/O functions. */
10784 sigblock (sigmask (SIGINT
));
10787 reset_all_sys_modes ();
10789 #ifdef SIGTSTP /* Support possible in later USG versions */
10791 * On systems which can suspend the current process and return to the original
10792 * shell, this command causes the user to end up back at the shell.
10793 * The "Auto-save" and "Abort" questions are not asked until
10794 * the user elects to return to emacs, at which point he can save the current
10795 * job and either dump core or continue.
10799 /* Perhaps should really fork an inferior shell?
10800 But that would not provide any way to get back
10801 to the original shell, ever. */
10802 printf ("No support for stopping a process on this operating system;\n");
10803 printf ("you can continue or abort.\n");
10804 #endif /* not SIGTSTP */
10806 /* We must remain inside the screen area when the internal terminal
10807 is used. Note that [Enter] is not echoed by dos. */
10808 cursor_to (SELECTED_FRAME (), 0, 0);
10810 /* It doesn't work to autosave while GC is in progress;
10811 the code used for auto-saving doesn't cope with the mark bit. */
10812 if (!gc_in_progress
)
10814 printf ("Auto-save? (y or n) ");
10816 if (((c
= getchar ()) & ~040) == 'Y')
10818 Fdo_auto_save (Qt
, Qnil
);
10820 printf ("\r\nAuto-save done");
10821 #else /* not MSDOS */
10822 printf ("Auto-save done\n");
10823 #endif /* not MSDOS */
10825 while (c
!= '\n') c
= getchar ();
10829 /* During GC, it must be safe to reenable quitting again. */
10830 Vinhibit_quit
= Qnil
;
10833 #endif /* not MSDOS */
10834 printf ("Garbage collection in progress; cannot auto-save now\r\n");
10835 printf ("but will instead do a real quit after garbage collection ends\r\n");
10840 printf ("\r\nAbort? (y or n) ");
10841 #else /* not MSDOS */
10842 printf ("Abort (and dump core)? (y or n) ");
10843 #endif /* not MSDOS */
10845 if (((c
= getchar ()) & ~040) == 'Y')
10847 while (c
!= '\n') c
= getchar ();
10849 printf ("\r\nContinuing...\r\n");
10850 #else /* not MSDOS */
10851 printf ("Continuing...\n");
10852 #endif /* not MSDOS */
10854 init_all_sys_modes ();
10859 /* If executing a function that wants to be interrupted out of
10860 and the user has not deferred quitting by binding `inhibit-quit'
10861 then quit right away. */
10862 if (immediate_quit
&& NILP (Vinhibit_quit
))
10864 struct gl_state_s saved
;
10865 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10867 immediate_quit
= 0;
10870 GCPRO4 (saved
.object
, saved
.global_code
,
10871 saved
.current_syntax_table
, saved
.old_prop
);
10872 Fsignal (Qquit
, Qnil
);
10873 /* FIXME: AFAIK, `quit' can never return, so this code is dead! */
10878 /* Else request quit when it's safe */
10882 /* TODO: The longjmp in this call throws the NS event loop integration off,
10883 and it seems to do fine without this. Probably some attention
10884 needs to be paid to the setting of waiting_for_input in
10885 wait_reading_process_output() under HAVE_NS because of the call
10886 to ns_select there (needed because otherwise events aren't picked up
10887 outside of polling since we don't get SIGIO like X and we don't have a
10888 separate event loop thread like W32. */
10890 if (waiting_for_input
&& !echoing
)
10891 quit_throw_to_read_char ();
10895 /* Handle a C-g by making read_char return C-g. */
10898 quit_throw_to_read_char (void)
10901 /* Prevent another signal from doing this before we finish. */
10902 clear_waiting_for_input ();
10905 Vunread_command_events
= Qnil
;
10906 unread_command_char
= -1;
10908 #if 0 /* Currently, sit_for is called from read_char without turning
10909 off polling. And that can call set_waiting_for_input.
10910 It seems to be harmless. */
10911 #ifdef POLL_FOR_INPUT
10912 /* May be > 1 if in recursive minibuffer. */
10913 if (poll_suppress_count
== 0)
10917 if (FRAMEP (internal_last_event_frame
)
10918 && !EQ (internal_last_event_frame
, selected_frame
))
10919 do_switch_frame (make_lispy_switch_frame (internal_last_event_frame
),
10922 _longjmp (getcjmp
, 1);
10925 DEFUN ("set-input-interrupt-mode", Fset_input_interrupt_mode
, Sset_input_interrupt_mode
, 1, 1, 0,
10926 doc
: /* Set interrupt mode of reading keyboard input.
10927 If INTERRUPT is non-nil, Emacs will use input interrupts;
10928 otherwise Emacs uses CBREAK mode.
10930 See also `current-input-mode'. */)
10931 (Lisp_Object interrupt
)
10933 int new_interrupt_input
;
10935 /* Note SIGIO has been undef'd if FIONREAD is missing. */
10936 #ifdef HAVE_X_WINDOWS
10937 if (x_display_list
!= NULL
)
10939 /* When using X, don't give the user a real choice,
10940 because we haven't implemented the mechanisms to support it. */
10941 new_interrupt_input
= 1;
10944 #endif /* HAVE_X_WINDOWS */
10945 new_interrupt_input
= !NILP (interrupt
);
10946 #else /* not SIGIO */
10947 new_interrupt_input
= 0;
10948 #endif /* not SIGIO */
10950 if (new_interrupt_input
!= interrupt_input
)
10952 #ifdef POLL_FOR_INPUT
10956 /* this causes startup screen to be restored and messes with the mouse */
10957 reset_all_sys_modes ();
10958 interrupt_input
= new_interrupt_input
;
10959 init_all_sys_modes ();
10961 interrupt_input
= new_interrupt_input
;
10964 #ifdef POLL_FOR_INPUT
10965 poll_suppress_count
= 1;
10972 DEFUN ("set-output-flow-control", Fset_output_flow_control
, Sset_output_flow_control
, 1, 2, 0,
10973 doc
: /* Enable or disable ^S/^Q flow control for output to TERMINAL.
10974 If FLOW is non-nil, flow control is enabled and you cannot use C-s or
10975 C-q in key sequences.
10977 This setting only has an effect on tty terminals and only when
10978 Emacs reads input in CBREAK mode; see `set-input-interrupt-mode'.
10980 See also `current-input-mode'. */)
10981 (Lisp_Object flow
, Lisp_Object terminal
)
10983 struct terminal
*t
= get_terminal (terminal
, 1);
10984 struct tty_display_info
*tty
;
10985 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
10987 tty
= t
->display_info
.tty
;
10989 if (tty
->flow_control
!= !NILP (flow
))
10992 /* this causes startup screen to be restored and messes with the mouse */
10993 reset_sys_modes (tty
);
10996 tty
->flow_control
= !NILP (flow
);
10999 init_sys_modes (tty
);
11005 DEFUN ("set-input-meta-mode", Fset_input_meta_mode
, Sset_input_meta_mode
, 1, 2, 0,
11006 doc
: /* Enable or disable 8-bit input on TERMINAL.
11007 If META is t, Emacs will accept 8-bit input, and interpret the 8th
11008 bit as the Meta modifier.
11010 If META is nil, Emacs will ignore the top bit, on the assumption it is
11013 Otherwise, Emacs will accept and pass through 8-bit input without
11014 specially interpreting the top bit.
11016 This setting only has an effect on tty terminal devices.
11018 Optional parameter TERMINAL specifies the tty terminal device to use.
11019 It may be a terminal object, a frame, or nil for the terminal used by
11020 the currently selected frame.
11022 See also `current-input-mode'. */)
11023 (Lisp_Object meta
, Lisp_Object terminal
)
11025 struct terminal
*t
= get_terminal (terminal
, 1);
11026 struct tty_display_info
*tty
;
11029 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11031 tty
= t
->display_info
.tty
;
11035 else if (EQ (meta
, Qt
))
11040 if (tty
->meta_key
!= new_meta
)
11043 /* this causes startup screen to be restored and messes with the mouse */
11044 reset_sys_modes (tty
);
11047 tty
->meta_key
= new_meta
;
11050 init_sys_modes (tty
);
11056 DEFUN ("set-quit-char", Fset_quit_char
, Sset_quit_char
, 1, 1, 0,
11057 doc
: /* Specify character used for quitting.
11058 QUIT must be an ASCII character.
11060 This function only has an effect on the controlling tty of the Emacs
11063 See also `current-input-mode'. */)
11066 struct terminal
*t
= get_named_tty ("/dev/tty");
11067 struct tty_display_info
*tty
;
11068 if (t
== NULL
|| (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
))
11070 tty
= t
->display_info
.tty
;
11072 if (NILP (quit
) || !INTEGERP (quit
) || XINT (quit
) < 0 || XINT (quit
) > 0400)
11073 error ("QUIT must be an ASCII character");
11076 /* this causes startup screen to be restored and messes with the mouse */
11077 reset_sys_modes (tty
);
11080 /* Don't let this value be out of range. */
11081 quit_char
= XINT (quit
) & (tty
->meta_key
== 0 ? 0177 : 0377);
11084 init_sys_modes (tty
);
11090 DEFUN ("set-input-mode", Fset_input_mode
, Sset_input_mode
, 3, 4, 0,
11091 doc
: /* Set mode of reading keyboard input.
11092 First arg INTERRUPT non-nil means use input interrupts;
11093 nil means use CBREAK mode.
11094 Second arg FLOW non-nil means use ^S/^Q flow control for output to terminal
11095 (no effect except in CBREAK mode).
11096 Third arg META t means accept 8-bit input (for a Meta key).
11097 META nil means ignore the top bit, on the assumption it is parity.
11098 Otherwise, accept 8-bit input and don't use the top bit for Meta.
11099 Optional fourth arg QUIT if non-nil specifies character to use for quitting.
11100 See also `current-input-mode'. */)
11101 (Lisp_Object interrupt
, Lisp_Object flow
, Lisp_Object meta
, Lisp_Object quit
)
11103 Fset_input_interrupt_mode (interrupt
);
11104 Fset_output_flow_control (flow
, Qnil
);
11105 Fset_input_meta_mode (meta
, Qnil
);
11107 Fset_quit_char (quit
);
11111 DEFUN ("current-input-mode", Fcurrent_input_mode
, Scurrent_input_mode
, 0, 0, 0,
11112 doc
: /* Return information about the way Emacs currently reads keyboard input.
11113 The value is a list of the form (INTERRUPT FLOW META QUIT), where
11114 INTERRUPT is non-nil if Emacs is using interrupt-driven input; if
11115 nil, Emacs is using CBREAK mode.
11116 FLOW is non-nil if Emacs uses ^S/^Q flow control for output to the
11117 terminal; this does not apply if Emacs uses interrupt-driven input.
11118 META is t if accepting 8-bit input with 8th bit as Meta flag.
11119 META nil means ignoring the top bit, on the assumption it is parity.
11120 META is neither t nor nil if accepting 8-bit input and using
11121 all 8 bits as the character code.
11122 QUIT is the character Emacs currently uses to quit.
11123 The elements of this list correspond to the arguments of
11124 `set-input-mode'. */)
11127 Lisp_Object val
[4];
11128 struct frame
*sf
= XFRAME (selected_frame
);
11130 val
[0] = interrupt_input
? Qt
: Qnil
;
11131 if (FRAME_TERMCAP_P (sf
) || FRAME_MSDOS_P (sf
))
11133 val
[1] = FRAME_TTY (sf
)->flow_control
? Qt
: Qnil
;
11134 val
[2] = (FRAME_TTY (sf
)->meta_key
== 2
11136 : (CURTTY ()->meta_key
== 1 ? Qt
: Qnil
));
11143 XSETFASTINT (val
[3], quit_char
);
11145 return Flist (sizeof (val
) / sizeof (val
[0]), val
);
11148 DEFUN ("posn-at-x-y", Fposn_at_x_y
, Sposn_at_x_y
, 2, 4, 0,
11149 doc
: /* Return position information for pixel coordinates X and Y.
11150 By default, X and Y are relative to text area of the selected window.
11151 Optional third arg FRAME-OR-WINDOW non-nil specifies frame or window.
11152 If optional fourth arg WHOLE is non-nil, X is relative to the left
11153 edge of the window.
11155 The return value is similar to a mouse click position:
11156 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11157 IMAGE (DX . DY) (WIDTH . HEIGHT))
11158 The `posn-' functions access elements of such lists. */)
11159 (Lisp_Object x
, Lisp_Object y
, Lisp_Object frame_or_window
, Lisp_Object whole
)
11164 if (NILP (frame_or_window
))
11165 frame_or_window
= selected_window
;
11167 if (WINDOWP (frame_or_window
))
11171 CHECK_LIVE_WINDOW (frame_or_window
);
11173 w
= XWINDOW (frame_or_window
);
11174 XSETINT (x
, (XINT (x
)
11175 + WINDOW_LEFT_EDGE_X (w
)
11177 ? window_box_left_offset (w
, TEXT_AREA
)
11179 XSETINT (y
, WINDOW_TO_FRAME_PIXEL_Y (w
, XINT (y
)));
11180 frame_or_window
= w
->frame
;
11183 CHECK_LIVE_FRAME (frame_or_window
);
11185 return make_lispy_position (XFRAME (frame_or_window
), x
, y
, 0);
11188 DEFUN ("posn-at-point", Fposn_at_point
, Sposn_at_point
, 0, 2, 0,
11189 doc
: /* Return position information for buffer POS in WINDOW.
11190 POS defaults to point in WINDOW; WINDOW defaults to the selected window.
11192 Return nil if position is not visible in window. Otherwise,
11193 the return value is similar to that returned by `event-start' for
11194 a mouse click at the upper left corner of the glyph corresponding
11195 to the given buffer position:
11196 (WINDOW AREA-OR-POS (X . Y) TIMESTAMP OBJECT POS (COL . ROW)
11197 IMAGE (DX . DY) (WIDTH . HEIGHT))
11198 The `posn-' functions access elements of such lists. */)
11199 (Lisp_Object pos
, Lisp_Object window
)
11204 window
= selected_window
;
11206 tem
= Fpos_visible_in_window_p (pos
, window
, Qt
);
11209 Lisp_Object x
= XCAR (tem
);
11210 Lisp_Object y
= XCAR (XCDR (tem
));
11212 /* Point invisible due to hscrolling? */
11215 tem
= Fposn_at_x_y (x
, y
, window
, Qnil
);
11223 * Set up a new kboard object with reasonable initial values.
11226 init_kboard (KBOARD
*kb
)
11228 KVAR (kb
, Voverriding_terminal_local_map
) = Qnil
;
11229 KVAR (kb
, Vlast_command
) = Qnil
;
11230 KVAR (kb
, Vreal_last_command
) = Qnil
;
11231 KVAR (kb
, Vkeyboard_translate_table
) = Qnil
;
11232 KVAR (kb
, Vlast_repeatable_command
) = Qnil
;
11233 KVAR (kb
, Vprefix_arg
) = Qnil
;
11234 KVAR (kb
, Vlast_prefix_arg
) = Qnil
;
11235 KVAR (kb
, kbd_queue
) = Qnil
;
11236 kb
->kbd_queue_has_data
= 0;
11237 kb
->immediate_echo
= 0;
11238 KVAR (kb
, echo_string
) = Qnil
;
11239 kb
->echo_after_prompt
= -1;
11240 kb
->kbd_macro_buffer
= 0;
11241 kb
->kbd_macro_bufsize
= 0;
11242 KVAR (kb
, defining_kbd_macro
) = Qnil
;
11243 KVAR (kb
, Vlast_kbd_macro
) = Qnil
;
11244 kb
->reference_count
= 0;
11245 KVAR (kb
, Vsystem_key_alist
) = Qnil
;
11246 KVAR (kb
, system_key_syms
) = Qnil
;
11247 KVAR (kb
, Vwindow_system
) = Qt
; /* Unset. */
11248 KVAR (kb
, Vinput_decode_map
) = Fmake_sparse_keymap (Qnil
);
11249 KVAR (kb
, Vlocal_function_key_map
) = Fmake_sparse_keymap (Qnil
);
11250 Fset_keymap_parent (KVAR (kb
, Vlocal_function_key_map
), Vfunction_key_map
);
11251 KVAR (kb
, Vdefault_minibuffer_frame
) = Qnil
;
11255 * Destroy the contents of a kboard object, but not the object itself.
11256 * We use this just before deleting it, or if we're going to initialize
11257 * it a second time.
11260 wipe_kboard (KBOARD
*kb
)
11262 xfree (kb
->kbd_macro_buffer
);
11265 /* Free KB and memory referenced from it. */
11268 delete_kboard (KBOARD
*kb
)
11272 for (kbp
= &all_kboards
; *kbp
!= kb
; kbp
= &(*kbp
)->next_kboard
)
11275 *kbp
= kb
->next_kboard
;
11277 /* Prevent a dangling reference to KB. */
11278 if (kb
== current_kboard
11279 && FRAMEP (selected_frame
)
11280 && FRAME_LIVE_P (XFRAME (selected_frame
)))
11282 current_kboard
= FRAME_KBOARD (XFRAME (selected_frame
));
11284 if (current_kboard
== kb
)
11293 init_keyboard (void)
11295 /* This is correct before outermost invocation of the editor loop */
11296 command_loop_level
= -1;
11297 immediate_quit
= 0;
11298 quit_char
= Ctl ('g');
11299 Vunread_command_events
= Qnil
;
11300 unread_command_char
= -1;
11301 EMACS_SET_SECS_USECS (timer_idleness_start_time
, -1, -1);
11303 recent_keys_index
= 0;
11304 kbd_fetch_ptr
= kbd_buffer
;
11305 kbd_store_ptr
= kbd_buffer
;
11306 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11307 do_mouse_tracking
= Qnil
;
11310 interrupt_input_blocked
= 0;
11311 interrupt_input_pending
= 0;
11313 pending_signals
= 0;
11316 /* This means that command_loop_1 won't try to select anything the first
11318 internal_last_event_frame
= Qnil
;
11319 Vlast_event_frame
= internal_last_event_frame
;
11321 current_kboard
= initial_kboard
;
11322 /* Re-initialize the keyboard again. */
11323 wipe_kboard (current_kboard
);
11324 init_kboard (current_kboard
);
11325 /* A value of nil for Vwindow_system normally means a tty, but we also use
11326 it for the initial terminal since there is no window system there. */
11327 KVAR (current_kboard
, Vwindow_system
) = Qnil
;
11329 if (!noninteractive
)
11331 /* Before multi-tty support, these handlers used to be installed
11332 only if the current session was a tty session. Now an Emacs
11333 session may have multiple display types, so we always handle
11334 SIGINT. There is special code in interrupt_signal to exit
11335 Emacs on SIGINT when there are no termcap frames on the
11336 controlling terminal. */
11337 signal (SIGINT
, interrupt_signal
);
11339 /* For systems with SysV TERMIO, C-g is set up for both SIGINT and
11340 SIGQUIT and we can't tell which one it will give us. */
11341 signal (SIGQUIT
, interrupt_signal
);
11342 #endif /* not DOS_NT */
11344 /* Note SIGIO has been undef'd if FIONREAD is missing. */
11346 if (!noninteractive
)
11347 signal (SIGIO
, input_available_signal
);
11350 /* Use interrupt input by default, if it works and noninterrupt input
11351 has deficiencies. */
11353 #ifdef INTERRUPT_INPUT
11354 interrupt_input
= 1;
11356 interrupt_input
= 0;
11362 if (keyboard_init_hook
)
11363 (*keyboard_init_hook
) ();
11365 #ifdef POLL_FOR_INPUT
11367 poll_suppress_count
= 1;
11372 /* This type's only use is in syms_of_keyboard, to initialize the
11373 event header symbols and put properties on them. */
11374 struct event_head
{
11380 static const struct event_head head_table
[] = {
11381 {&Qmouse_movement
, "mouse-movement", &Qmouse_movement
},
11382 {&Qscroll_bar_movement
, "scroll-bar-movement", &Qmouse_movement
},
11383 {&Qswitch_frame
, "switch-frame", &Qswitch_frame
},
11384 {&Qdelete_frame
, "delete-frame", &Qdelete_frame
},
11385 {&Qiconify_frame
, "iconify-frame", &Qiconify_frame
},
11386 {&Qmake_frame_visible
, "make-frame-visible", &Qmake_frame_visible
},
11387 /* `select-window' should be handled just like `switch-frame'
11388 in read_key_sequence. */
11389 {&Qselect_window
, "select-window", &Qswitch_frame
}
11393 syms_of_keyboard (void)
11395 pending_funcalls
= Qnil
;
11396 staticpro (&pending_funcalls
);
11398 Vlispy_mouse_stem
= make_pure_c_string ("mouse");
11399 staticpro (&Vlispy_mouse_stem
);
11402 QCimage
= intern_c_string (":image");
11403 staticpro (&QCimage
);
11405 staticpro (&Qhelp_echo
);
11406 Qhelp_echo
= intern_c_string ("help-echo");
11409 Qrtl
= intern_c_string (":rtl");
11411 staticpro (&item_properties
);
11412 item_properties
= Qnil
;
11414 staticpro (&tool_bar_item_properties
);
11415 tool_bar_item_properties
= Qnil
;
11416 staticpro (&tool_bar_items_vector
);
11417 tool_bar_items_vector
= Qnil
;
11419 staticpro (&real_this_command
);
11420 real_this_command
= Qnil
;
11422 Qtimer_event_handler
= intern_c_string ("timer-event-handler");
11423 staticpro (&Qtimer_event_handler
);
11425 Qdisabled_command_function
= intern_c_string ("disabled-command-function");
11426 staticpro (&Qdisabled_command_function
);
11428 Qself_insert_command
= intern_c_string ("self-insert-command");
11429 staticpro (&Qself_insert_command
);
11431 Qforward_char
= intern_c_string ("forward-char");
11432 staticpro (&Qforward_char
);
11434 Qbackward_char
= intern_c_string ("backward-char");
11435 staticpro (&Qbackward_char
);
11437 Qdisabled
= intern_c_string ("disabled");
11438 staticpro (&Qdisabled
);
11440 Qundefined
= intern_c_string ("undefined");
11441 staticpro (&Qundefined
);
11443 Qpre_command_hook
= intern_c_string ("pre-command-hook");
11444 staticpro (&Qpre_command_hook
);
11446 Qpost_command_hook
= intern_c_string ("post-command-hook");
11447 staticpro (&Qpost_command_hook
);
11449 Qdeferred_action_function
= intern_c_string ("deferred-action-function");
11450 staticpro (&Qdeferred_action_function
);
11452 Qcommand_hook_internal
= intern_c_string ("command-hook-internal");
11453 staticpro (&Qcommand_hook_internal
);
11455 Qfunction_key
= intern_c_string ("function-key");
11456 staticpro (&Qfunction_key
);
11457 Qmouse_click
= intern_c_string ("mouse-click");
11458 staticpro (&Qmouse_click
);
11459 #if defined (WINDOWSNT)
11460 Qlanguage_change
= intern_c_string ("language-change");
11461 staticpro (&Qlanguage_change
);
11463 Qdrag_n_drop
= intern_c_string ("drag-n-drop");
11464 staticpro (&Qdrag_n_drop
);
11466 Qsave_session
= intern_c_string ("save-session");
11467 staticpro (&Qsave_session
);
11470 Qdbus_event
= intern_c_string ("dbus-event");
11471 staticpro (&Qdbus_event
);
11474 Qconfig_changed_event
= intern_c_string ("config-changed-event");
11475 staticpro (&Qconfig_changed_event
);
11477 Qmenu_enable
= intern_c_string ("menu-enable");
11478 staticpro (&Qmenu_enable
);
11479 QCenable
= intern_c_string (":enable");
11480 staticpro (&QCenable
);
11481 QCvisible
= intern_c_string (":visible");
11482 staticpro (&QCvisible
);
11483 QChelp
= intern_c_string (":help");
11484 staticpro (&QChelp
);
11485 QCfilter
= intern_c_string (":filter");
11486 staticpro (&QCfilter
);
11487 QCbutton
= intern_c_string (":button");
11488 staticpro (&QCbutton
);
11489 QCkeys
= intern_c_string (":keys");
11490 staticpro (&QCkeys
);
11491 QCkey_sequence
= intern_c_string (":key-sequence");
11492 staticpro (&QCkey_sequence
);
11493 QCtoggle
= intern_c_string (":toggle");
11494 staticpro (&QCtoggle
);
11495 QCradio
= intern_c_string (":radio");
11496 staticpro (&QCradio
);
11497 QClabel
= intern_c_string (":label");
11498 staticpro (&QClabel
);
11499 QCvert_only
= intern_c_string (":vert-only");
11500 staticpro (&QCvert_only
);
11502 Qmode_line
= intern_c_string ("mode-line");
11503 staticpro (&Qmode_line
);
11504 Qvertical_line
= intern_c_string ("vertical-line");
11505 staticpro (&Qvertical_line
);
11506 Qvertical_scroll_bar
= intern_c_string ("vertical-scroll-bar");
11507 staticpro (&Qvertical_scroll_bar
);
11508 Qmenu_bar
= intern_c_string ("menu-bar");
11509 staticpro (&Qmenu_bar
);
11511 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11512 Qmouse_fixup_help_message
= intern_c_string ("mouse-fixup-help-message");
11513 staticpro (&Qmouse_fixup_help_message
);
11516 Qabove_handle
= intern_c_string ("above-handle");
11517 staticpro (&Qabove_handle
);
11518 Qhandle
= intern_c_string ("handle");
11519 staticpro (&Qhandle
);
11520 Qbelow_handle
= intern_c_string ("below-handle");
11521 staticpro (&Qbelow_handle
);
11522 Qup
= intern_c_string ("up");
11524 Qdown
= intern_c_string ("down");
11525 staticpro (&Qdown
);
11526 Qtop
= intern_c_string ("top");
11528 Qbottom
= intern_c_string ("bottom");
11529 staticpro (&Qbottom
);
11530 Qend_scroll
= intern_c_string ("end-scroll");
11531 staticpro (&Qend_scroll
);
11532 Qratio
= intern_c_string ("ratio");
11533 staticpro (&Qratio
);
11535 Qevent_kind
= intern_c_string ("event-kind");
11536 staticpro (&Qevent_kind
);
11537 Qevent_symbol_elements
= intern_c_string ("event-symbol-elements");
11538 staticpro (&Qevent_symbol_elements
);
11539 Qevent_symbol_element_mask
= intern_c_string ("event-symbol-element-mask");
11540 staticpro (&Qevent_symbol_element_mask
);
11541 Qmodifier_cache
= intern_c_string ("modifier-cache");
11542 staticpro (&Qmodifier_cache
);
11544 Qrecompute_lucid_menubar
= intern_c_string ("recompute-lucid-menubar");
11545 staticpro (&Qrecompute_lucid_menubar
);
11546 Qactivate_menubar_hook
= intern_c_string ("activate-menubar-hook");
11547 staticpro (&Qactivate_menubar_hook
);
11549 Qpolling_period
= intern_c_string ("polling-period");
11550 staticpro (&Qpolling_period
);
11552 Qinput_method_function
= intern_c_string ("input-method-function");
11553 staticpro (&Qinput_method_function
);
11555 Qx_set_selection
= intern_c_string ("x-set-selection");
11556 staticpro (&Qx_set_selection
);
11557 QPRIMARY
= intern_c_string ("PRIMARY");
11558 staticpro (&QPRIMARY
);
11559 Qhandle_switch_frame
= intern_c_string ("handle-switch-frame");
11560 staticpro (&Qhandle_switch_frame
);
11562 Qinput_method_exit_on_first_char
= intern_c_string ("input-method-exit-on-first-char");
11563 staticpro (&Qinput_method_exit_on_first_char
);
11564 Qinput_method_use_echo_area
= intern_c_string ("input-method-use-echo-area");
11565 staticpro (&Qinput_method_use_echo_area
);
11567 Fset (Qinput_method_exit_on_first_char
, Qnil
);
11568 Fset (Qinput_method_use_echo_area
, Qnil
);
11570 last_point_position_buffer
= Qnil
;
11571 last_point_position_window
= Qnil
;
11574 const struct event_head
*p
;
11576 for (p
= head_table
;
11577 p
< head_table
+ (sizeof (head_table
) / sizeof (head_table
[0]));
11580 *p
->var
= intern_c_string (p
->name
);
11581 staticpro (p
->var
);
11582 Fput (*p
->var
, Qevent_kind
, *p
->kind
);
11583 Fput (*p
->var
, Qevent_symbol_elements
, Fcons (*p
->var
, Qnil
));
11587 button_down_location
= Fmake_vector (make_number (5), Qnil
);
11588 staticpro (&button_down_location
);
11589 mouse_syms
= Fmake_vector (make_number (5), Qnil
);
11590 staticpro (&mouse_syms
);
11591 wheel_syms
= Fmake_vector (make_number (sizeof (lispy_wheel_names
)
11592 / sizeof (lispy_wheel_names
[0])),
11594 staticpro (&wheel_syms
);
11598 int len
= sizeof (modifier_names
) / sizeof (modifier_names
[0]);
11600 modifier_symbols
= Fmake_vector (make_number (len
), Qnil
);
11601 for (i
= 0; i
< len
; i
++)
11602 if (modifier_names
[i
])
11603 XVECTOR (modifier_symbols
)->contents
[i
] = intern_c_string (modifier_names
[i
]);
11604 staticpro (&modifier_symbols
);
11607 recent_keys
= Fmake_vector (make_number (NUM_RECENT_KEYS
), Qnil
);
11608 staticpro (&recent_keys
);
11610 this_command_keys
= Fmake_vector (make_number (40), Qnil
);
11611 staticpro (&this_command_keys
);
11613 raw_keybuf
= Fmake_vector (make_number (30), Qnil
);
11614 staticpro (&raw_keybuf
);
11616 Qextended_command_history
= intern_c_string ("extended-command-history");
11617 Fset (Qextended_command_history
, Qnil
);
11618 staticpro (&Qextended_command_history
);
11620 accent_key_syms
= Qnil
;
11621 staticpro (&accent_key_syms
);
11623 func_key_syms
= Qnil
;
11624 staticpro (&func_key_syms
);
11626 drag_n_drop_syms
= Qnil
;
11627 staticpro (&drag_n_drop_syms
);
11629 unread_switch_frame
= Qnil
;
11630 staticpro (&unread_switch_frame
);
11632 internal_last_event_frame
= Qnil
;
11633 staticpro (&internal_last_event_frame
);
11635 read_key_sequence_cmd
= Qnil
;
11636 staticpro (&read_key_sequence_cmd
);
11638 menu_bar_one_keymap_changed_items
= Qnil
;
11639 staticpro (&menu_bar_one_keymap_changed_items
);
11641 menu_bar_items_vector
= Qnil
;
11642 staticpro (&menu_bar_items_vector
);
11644 help_form_saved_window_configs
= Qnil
;
11645 staticpro (&help_form_saved_window_configs
);
11647 defsubr (&Scurrent_idle_time
);
11648 defsubr (&Sevent_symbol_parse_modifiers
);
11649 defsubr (&Sevent_convert_list
);
11650 defsubr (&Sread_key_sequence
);
11651 defsubr (&Sread_key_sequence_vector
);
11652 defsubr (&Srecursive_edit
);
11653 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
11654 defsubr (&Strack_mouse
);
11656 defsubr (&Sinput_pending_p
);
11657 defsubr (&Scommand_execute
);
11658 defsubr (&Srecent_keys
);
11659 defsubr (&Sthis_command_keys
);
11660 defsubr (&Sthis_command_keys_vector
);
11661 defsubr (&Sthis_single_command_keys
);
11662 defsubr (&Sthis_single_command_raw_keys
);
11663 defsubr (&Sreset_this_command_lengths
);
11664 defsubr (&Sclear_this_command_keys
);
11665 defsubr (&Ssuspend_emacs
);
11666 defsubr (&Sabort_recursive_edit
);
11667 defsubr (&Sexit_recursive_edit
);
11668 defsubr (&Srecursion_depth
);
11669 defsubr (&Stop_level
);
11670 defsubr (&Sdiscard_input
);
11671 defsubr (&Sopen_dribble_file
);
11672 defsubr (&Sset_input_interrupt_mode
);
11673 defsubr (&Sset_output_flow_control
);
11674 defsubr (&Sset_input_meta_mode
);
11675 defsubr (&Sset_quit_char
);
11676 defsubr (&Sset_input_mode
);
11677 defsubr (&Scurrent_input_mode
);
11678 defsubr (&Sexecute_extended_command
);
11679 defsubr (&Sposn_at_point
);
11680 defsubr (&Sposn_at_x_y
);
11682 DEFVAR_LISP ("last-command-event", last_command_event
,
11683 doc
: /* Last input event that was part of a command. */);
11685 DEFVAR_LISP ("last-nonmenu-event", last_nonmenu_event
,
11686 doc
: /* Last input event in a command, except for mouse menu events.
11687 Mouse menus give back keys that don't look like mouse events;
11688 this variable holds the actual mouse event that led to the menu,
11689 so that you can determine whether the command was run by mouse or not. */);
11691 DEFVAR_LISP ("last-input-event", last_input_event
,
11692 doc
: /* Last input event. */);
11694 DEFVAR_LISP ("unread-command-events", Vunread_command_events
,
11695 doc
: /* List of events to be read as the command input.
11696 These events are processed first, before actual keyboard input.
11697 Events read from this list are not normally added to `this-command-keys',
11698 as they will already have been added once as they were read for the first time.
11699 An element of the form (t . EVENT) forces EVENT to be added to that list. */);
11700 Vunread_command_events
= Qnil
;
11702 DEFVAR_INT ("unread-command-char", unread_command_char
,
11703 doc
: /* If not -1, an object to be read as next command input event. */);
11705 DEFVAR_LISP ("unread-post-input-method-events", Vunread_post_input_method_events
,
11706 doc
: /* List of events to be processed as input by input methods.
11707 These events are processed before `unread-command-events'
11708 and actual keyboard input, but are not given to `input-method-function'. */);
11709 Vunread_post_input_method_events
= Qnil
;
11711 DEFVAR_LISP ("unread-input-method-events", Vunread_input_method_events
,
11712 doc
: /* List of events to be processed as input by input methods.
11713 These events are processed after `unread-command-events', but
11714 before actual keyboard input.
11715 If there's an active input method, the events are given to
11716 `input-method-function'. */);
11717 Vunread_input_method_events
= Qnil
;
11719 DEFVAR_LISP ("meta-prefix-char", meta_prefix_char
,
11720 doc
: /* Meta-prefix character code.
11721 Meta-foo as command input turns into this character followed by foo. */);
11722 XSETINT (meta_prefix_char
, 033);
11724 DEFVAR_KBOARD ("last-command", Vlast_command
,
11725 doc
: /* The last command executed.
11726 Normally a symbol with a function definition, but can be whatever was found
11727 in the keymap, or whatever the variable `this-command' was set to by that
11730 The value `mode-exit' is special; it means that the previous command
11731 read an event that told it to exit, and it did so and unread that event.
11732 In other words, the present command is the event that made the previous
11735 The value `kill-region' is special; it means that the previous command
11736 was a kill command.
11738 `last-command' has a separate binding for each terminal device.
11739 See Info node `(elisp)Multiple Terminals'. */);
11741 DEFVAR_KBOARD ("real-last-command", Vreal_last_command
,
11742 doc
: /* Same as `last-command', but never altered by Lisp code. */);
11744 DEFVAR_KBOARD ("last-repeatable-command", Vlast_repeatable_command
,
11745 doc
: /* Last command that may be repeated.
11746 The last command executed that was not bound to an input event.
11747 This is the command `repeat' will try to repeat. */);
11749 DEFVAR_LISP ("this-command", Vthis_command
,
11750 doc
: /* The command now being executed.
11751 The command can set this variable; whatever is put here
11752 will be in `last-command' during the following command. */);
11753 Vthis_command
= Qnil
;
11755 DEFVAR_LISP ("this-command-keys-shift-translated",
11756 Vthis_command_keys_shift_translated
,
11757 doc
: /* Non-nil if the key sequence activating this command was shift-translated.
11758 Shift-translation occurs when there is no binding for the key sequence
11759 as entered, but a binding was found by changing an upper-case letter
11760 to lower-case, or a shifted function key to an unshifted one. */);
11761 Vthis_command_keys_shift_translated
= Qnil
;
11763 DEFVAR_LISP ("this-original-command", Vthis_original_command
,
11764 doc
: /* The command bound to the current key sequence before remapping.
11765 It equals `this-command' if the original command was not remapped through
11766 any of the active keymaps. Otherwise, the value of `this-command' is the
11767 result of looking up the original command in the active keymaps. */);
11768 Vthis_original_command
= Qnil
;
11770 DEFVAR_INT ("auto-save-interval", auto_save_interval
,
11771 doc
: /* *Number of input events between auto-saves.
11772 Zero means disable autosaving due to number of characters typed. */);
11773 auto_save_interval
= 300;
11775 DEFVAR_LISP ("auto-save-timeout", Vauto_save_timeout
,
11776 doc
: /* *Number of seconds idle time before auto-save.
11777 Zero or nil means disable auto-saving due to idleness.
11778 After auto-saving due to this many seconds of idle time,
11779 Emacs also does a garbage collection if that seems to be warranted. */);
11780 XSETFASTINT (Vauto_save_timeout
, 30);
11782 DEFVAR_LISP ("echo-keystrokes", Vecho_keystrokes
,
11783 doc
: /* *Nonzero means echo unfinished commands after this many seconds of pause.
11784 The value may be integer or floating point. */);
11785 Vecho_keystrokes
= make_number (1);
11787 DEFVAR_INT ("polling-period", polling_period
,
11788 doc
: /* *Interval between polling for input during Lisp execution.
11789 The reason for polling is to make C-g work to stop a running program.
11790 Polling is needed only when using X windows and SIGIO does not work.
11791 Polling is automatically disabled in all other cases. */);
11792 polling_period
= 2;
11794 DEFVAR_LISP ("double-click-time", Vdouble_click_time
,
11795 doc
: /* *Maximum time between mouse clicks to make a double-click.
11796 Measured in milliseconds. The value nil means disable double-click
11797 recognition; t means double-clicks have no time limit and are detected
11798 by position only. */);
11799 Vdouble_click_time
= make_number (500);
11801 DEFVAR_INT ("double-click-fuzz", double_click_fuzz
,
11802 doc
: /* *Maximum mouse movement between clicks to make a double-click.
11803 On window-system frames, value is the number of pixels the mouse may have
11804 moved horizontally or vertically between two clicks to make a double-click.
11805 On non window-system frames, value is interpreted in units of 1/8 characters
11808 This variable is also the threshold for motion of the mouse
11809 to count as a drag. */);
11810 double_click_fuzz
= 3;
11812 DEFVAR_BOOL ("inhibit-local-menu-bar-menus", inhibit_local_menu_bar_menus
,
11813 doc
: /* *Non-nil means inhibit local map menu bar menus. */);
11814 inhibit_local_menu_bar_menus
= 0;
11816 DEFVAR_INT ("num-input-keys", num_input_keys
,
11817 doc
: /* Number of complete key sequences read as input so far.
11818 This includes key sequences read from keyboard macros.
11819 The number is effectively the number of interactive command invocations. */);
11820 num_input_keys
= 0;
11822 DEFVAR_INT ("num-nonmacro-input-events", num_nonmacro_input_events
,
11823 doc
: /* Number of input events read from the keyboard so far.
11824 This does not include events generated by keyboard macros. */);
11825 num_nonmacro_input_events
= 0;
11827 DEFVAR_LISP ("last-event-frame", Vlast_event_frame
,
11828 doc
: /* The frame in which the most recently read event occurred.
11829 If the last event came from a keyboard macro, this is set to `macro'. */);
11830 Vlast_event_frame
= Qnil
;
11832 /* This variable is set up in sysdep.c. */
11833 DEFVAR_LISP ("tty-erase-char", Vtty_erase_char
,
11834 doc
: /* The ERASE character as set by the user with stty. */);
11836 DEFVAR_LISP ("help-char", Vhelp_char
,
11837 doc
: /* Character to recognize as meaning Help.
11838 When it is read, do `(eval help-form)', and display result if it's a string.
11839 If the value of `help-form' is nil, this char can be read normally. */);
11840 XSETINT (Vhelp_char
, Ctl ('H'));
11842 DEFVAR_LISP ("help-event-list", Vhelp_event_list
,
11843 doc
: /* List of input events to recognize as meaning Help.
11844 These work just like the value of `help-char' (see that). */);
11845 Vhelp_event_list
= Qnil
;
11847 DEFVAR_LISP ("help-form", Vhelp_form
,
11848 doc
: /* Form to execute when character `help-char' is read.
11849 If the form returns a string, that string is displayed.
11850 If `help-form' is nil, the help char is not recognized. */);
11853 DEFVAR_LISP ("prefix-help-command", Vprefix_help_command
,
11854 doc
: /* Command to run when `help-char' character follows a prefix key.
11855 This command is used only when there is no actual binding
11856 for that character after that prefix key. */);
11857 Vprefix_help_command
= Qnil
;
11859 DEFVAR_LISP ("top-level", Vtop_level
,
11860 doc
: /* Form to evaluate when Emacs starts up.
11861 Useful to set before you dump a modified Emacs. */);
11864 DEFVAR_KBOARD ("keyboard-translate-table", Vkeyboard_translate_table
,
11865 doc
: /* Translate table for local keyboard input, or nil.
11866 If non-nil, the value should be a char-table. Each character read
11867 from the keyboard is looked up in this char-table. If the value found
11868 there is non-nil, then it is used instead of the actual input character.
11870 The value can also be a string or vector, but this is considered obsolete.
11871 If it is a string or vector of length N, character codes N and up are left
11872 untranslated. In a vector, an element which is nil means "no translation".
11874 This is applied to the characters supplied to input methods, not their
11875 output. See also `translation-table-for-input'.
11877 This variable has a separate binding for each terminal.
11878 See Info node `(elisp)Multiple Terminals'. */);
11880 DEFVAR_BOOL ("cannot-suspend", cannot_suspend
,
11881 doc
: /* Non-nil means to always spawn a subshell instead of suspending.
11882 \(Even if the operating system has support for stopping a process.\) */);
11883 cannot_suspend
= 0;
11885 DEFVAR_BOOL ("menu-prompting", menu_prompting
,
11886 doc
: /* Non-nil means prompt with menus when appropriate.
11887 This is done when reading from a keymap that has a prompt string,
11888 for elements that have prompt strings.
11889 The menu is displayed on the screen
11890 if X menus were enabled at configuration
11891 time and the previous event was a mouse click prefix key.
11892 Otherwise, menu prompting uses the echo area. */);
11893 menu_prompting
= 1;
11895 DEFVAR_LISP ("menu-prompt-more-char", menu_prompt_more_char
,
11896 doc
: /* Character to see next line of menu prompt.
11897 Type this character while in a menu prompt to rotate around the lines of it. */);
11898 XSETINT (menu_prompt_more_char
, ' ');
11900 DEFVAR_INT ("extra-keyboard-modifiers", extra_keyboard_modifiers
,
11901 doc
: /* A mask of additional modifier keys to use with every keyboard character.
11902 Emacs applies the modifiers of the character stored here to each keyboard
11903 character it reads. For example, after evaluating the expression
11904 (setq extra-keyboard-modifiers ?\\C-x)
11905 all input characters will have the control modifier applied to them.
11907 Note that the character ?\\C-@, equivalent to the integer zero, does
11908 not count as a control character; rather, it counts as a character
11909 with no modifiers; thus, setting `extra-keyboard-modifiers' to zero
11910 cancels any modification. */);
11911 extra_keyboard_modifiers
= 0;
11913 DEFVAR_LISP ("deactivate-mark", Vdeactivate_mark
,
11914 doc
: /* If an editing command sets this to t, deactivate the mark afterward.
11915 The command loop sets this to nil before each command,
11916 and tests the value when the command returns.
11917 Buffer modification stores t in this variable. */);
11918 Vdeactivate_mark
= Qnil
;
11919 Qdeactivate_mark
= intern_c_string ("deactivate-mark");
11920 staticpro (&Qdeactivate_mark
);
11922 DEFVAR_LISP ("command-hook-internal", Vcommand_hook_internal
,
11923 doc
: /* Temporary storage of `pre-command-hook' or `post-command-hook'. */);
11924 Vcommand_hook_internal
= Qnil
;
11926 DEFVAR_LISP ("pre-command-hook", Vpre_command_hook
,
11927 doc
: /* Normal hook run before each command is executed.
11928 If an unhandled error happens in running this hook,
11929 the hook value is set to nil, since otherwise the error
11930 might happen repeatedly and make Emacs nonfunctional. */);
11931 Vpre_command_hook
= Qnil
;
11933 DEFVAR_LISP ("post-command-hook", Vpost_command_hook
,
11934 doc
: /* Normal hook run after each command is executed.
11935 If an unhandled error happens in running this hook,
11936 the hook value is set to nil, since otherwise the error
11937 might happen repeatedly and make Emacs nonfunctional. */);
11938 Vpost_command_hook
= Qnil
;
11941 DEFVAR_LISP ("echo-area-clear-hook", ...,
11942 doc
: /* Normal hook run when clearing the echo area. */);
11944 Qecho_area_clear_hook
= intern_c_string ("echo-area-clear-hook");
11945 staticpro (&Qecho_area_clear_hook
);
11946 Fset (Qecho_area_clear_hook
, Qnil
);
11948 DEFVAR_LISP ("lucid-menu-bar-dirty-flag", Vlucid_menu_bar_dirty_flag
,
11949 doc
: /* Non-nil means menu bar, specified Lucid style, needs to be recomputed. */);
11950 Vlucid_menu_bar_dirty_flag
= Qnil
;
11952 DEFVAR_LISP ("menu-bar-final-items", Vmenu_bar_final_items
,
11953 doc
: /* List of menu bar items to move to the end of the menu bar.
11954 The elements of the list are event types that may have menu bar bindings. */);
11955 Vmenu_bar_final_items
= Qnil
;
11957 DEFVAR_LISP ("tool-bar-separator-image-expression", Vtool_bar_separator_image_expression
,
11958 doc
: /* Expression evaluating to the image spec for a tool-bar separator.
11959 This is used internally by graphical displays that do not render
11960 tool-bar separators natively. Otherwise it is unused (e.g. on GTK). */);
11961 Vtool_bar_separator_image_expression
= Qnil
;
11963 DEFVAR_KBOARD ("overriding-terminal-local-map",
11964 Voverriding_terminal_local_map
,
11965 doc
: /* Per-terminal keymap that overrides all other local keymaps.
11966 If this variable is non-nil, it is used as a keymap instead of the
11967 buffer's local map, and the minor mode keymaps and text property keymaps.
11968 It also replaces `overriding-local-map'.
11970 This variable is intended to let commands such as `universal-argument'
11971 set up a different keymap for reading the next command.
11973 `overriding-terminal-local-map' has a separate binding for each
11975 See Info node `(elisp)Multiple Terminals'. */);
11977 DEFVAR_LISP ("overriding-local-map", Voverriding_local_map
,
11978 doc
: /* Keymap that overrides all other local keymaps.
11979 If this variable is non-nil, it is used as a keymap--replacing the
11980 buffer's local map, the minor mode keymaps, and char property keymaps. */);
11981 Voverriding_local_map
= Qnil
;
11983 DEFVAR_LISP ("overriding-local-map-menu-flag", Voverriding_local_map_menu_flag
,
11984 doc
: /* Non-nil means `overriding-local-map' applies to the menu bar.
11985 Otherwise, the menu bar continues to reflect the buffer's local map
11986 and the minor mode maps regardless of `overriding-local-map'. */);
11987 Voverriding_local_map_menu_flag
= Qnil
;
11989 DEFVAR_LISP ("special-event-map", Vspecial_event_map
,
11990 doc
: /* Keymap defining bindings for special events to execute at low level. */);
11991 Vspecial_event_map
= Fcons (intern_c_string ("keymap"), Qnil
);
11993 DEFVAR_LISP ("track-mouse", do_mouse_tracking
,
11994 doc
: /* *Non-nil means generate motion events for mouse motion. */);
11996 DEFVAR_KBOARD ("system-key-alist", Vsystem_key_alist
,
11997 doc
: /* Alist of system-specific X windows key symbols.
11998 Each element should have the form (N . SYMBOL) where N is the
11999 numeric keysym code (sans the \"system-specific\" bit 1<<28)
12000 and SYMBOL is its name.
12002 `system-key-alist' has a separate binding for each terminal device.
12003 See Info node `(elisp)Multiple Terminals'. */);
12005 DEFVAR_KBOARD ("local-function-key-map", Vlocal_function_key_map
,
12006 doc
: /* Keymap that translates key sequences to key sequences during input.
12007 This is used mainly for mapping key sequences into some preferred
12008 key events (symbols).
12010 The `read-key-sequence' function replaces any subsequence bound by
12011 `local-function-key-map' with its binding. More precisely, when the
12012 active keymaps have no binding for the current key sequence but
12013 `local-function-key-map' binds a suffix of the sequence to a vector or
12014 string, `read-key-sequence' replaces the matching suffix with its
12015 binding, and continues with the new sequence.
12017 If the binding is a function, it is called with one argument (the prompt)
12018 and its return value (a key sequence) is used.
12020 The events that come from bindings in `local-function-key-map' are not
12021 themselves looked up in `local-function-key-map'.
12023 For example, suppose `local-function-key-map' binds `ESC O P' to [f1].
12024 Typing `ESC O P' to `read-key-sequence' would return [f1]. Typing
12025 `C-x ESC O P' would return [?\\C-x f1]. If [f1] were a prefix key,
12026 typing `ESC O P x' would return [f1 x].
12028 `local-function-key-map' has a separate binding for each terminal
12029 device. See Info node `(elisp)Multiple Terminals'. If you need to
12030 define a binding on all terminals, change `function-key-map'
12031 instead. Initially, `local-function-key-map' is an empty keymap that
12032 has `function-key-map' as its parent on all terminal devices. */);
12034 DEFVAR_KBOARD ("input-decode-map", Vinput_decode_map
,
12035 doc
: /* Keymap that decodes input escape sequences.
12036 This is used mainly for mapping ASCII function key sequences into
12037 real Emacs function key events (symbols).
12039 The `read-key-sequence' function replaces any subsequence bound by
12040 `input-decode-map' with its binding. Contrary to `function-key-map',
12041 this map applies its rebinding regardless of the presence of an ordinary
12042 binding. So it is more like `key-translation-map' except that it applies
12043 before `function-key-map' rather than after.
12045 If the binding is a function, it is called with one argument (the prompt)
12046 and its return value (a key sequence) is used.
12048 The events that come from bindings in `input-decode-map' are not
12049 themselves looked up in `input-decode-map'.
12051 This variable is keyboard-local. */);
12053 DEFVAR_LISP ("function-key-map", Vfunction_key_map
,
12054 doc
: /* The parent keymap of all `local-function-key-map' instances.
12055 Function key definitions that apply to all terminal devices should go
12056 here. If a mapping is defined in both the current
12057 `local-function-key-map' binding and this variable, then the local
12058 definition will take precendence. */);
12059 Vfunction_key_map
= Fmake_sparse_keymap (Qnil
);
12061 DEFVAR_LISP ("key-translation-map", Vkey_translation_map
,
12062 doc
: /* Keymap of key translations that can override keymaps.
12063 This keymap works like `function-key-map', but comes after that,
12064 and its non-prefix bindings override ordinary bindings.
12065 Another difference is that it is global rather than keyboard-local. */);
12066 Vkey_translation_map
= Fmake_sparse_keymap (Qnil
);
12068 DEFVAR_LISP ("deferred-action-list", Vdeferred_action_list
,
12069 doc
: /* List of deferred actions to be performed at a later time.
12070 The precise format isn't relevant here; we just check whether it is nil. */);
12071 Vdeferred_action_list
= Qnil
;
12073 DEFVAR_LISP ("deferred-action-function", Vdeferred_action_function
,
12074 doc
: /* Function to call to handle deferred actions, after each command.
12075 This function is called with no arguments after each command
12076 whenever `deferred-action-list' is non-nil. */);
12077 Vdeferred_action_function
= Qnil
;
12079 DEFVAR_LISP ("suggest-key-bindings", Vsuggest_key_bindings
,
12080 doc
: /* *Non-nil means show the equivalent key-binding when M-x command has one.
12081 The value can be a length of time to show the message for.
12082 If the value is non-nil and not a number, we wait 2 seconds. */);
12083 Vsuggest_key_bindings
= Qt
;
12085 DEFVAR_LISP ("timer-list", Vtimer_list
,
12086 doc
: /* List of active absolute time timers in order of increasing time. */);
12087 Vtimer_list
= Qnil
;
12089 DEFVAR_LISP ("timer-idle-list", Vtimer_idle_list
,
12090 doc
: /* List of active idle-time timers in order of increasing time. */);
12091 Vtimer_idle_list
= Qnil
;
12093 DEFVAR_LISP ("input-method-function", Vinput_method_function
,
12094 doc
: /* If non-nil, the function that implements the current input method.
12095 It's called with one argument, a printing character that was just read.
12096 \(That means a character with code 040...0176.)
12097 Typically this function uses `read-event' to read additional events.
12098 When it does so, it should first bind `input-method-function' to nil
12099 so it will not be called recursively.
12101 The function should return a list of zero or more events
12102 to be used as input. If it wants to put back some events
12103 to be reconsidered, separately, by the input method,
12104 it can add them to the beginning of `unread-command-events'.
12106 The input method function can find in `input-method-previous-message'
12107 the previous echo area message.
12109 The input method function should refer to the variables
12110 `input-method-use-echo-area' and `input-method-exit-on-first-char'
12111 for guidance on what to do. */);
12112 Vinput_method_function
= Qnil
;
12114 DEFVAR_LISP ("input-method-previous-message",
12115 Vinput_method_previous_message
,
12116 doc
: /* When `input-method-function' is called, hold the previous echo area message.
12117 This variable exists because `read-event' clears the echo area
12118 before running the input method. It is nil if there was no message. */);
12119 Vinput_method_previous_message
= Qnil
;
12121 DEFVAR_LISP ("show-help-function", Vshow_help_function
,
12122 doc
: /* If non-nil, the function that implements the display of help.
12123 It's called with one argument, the help string to display. */);
12124 Vshow_help_function
= Qnil
;
12126 DEFVAR_LISP ("disable-point-adjustment", Vdisable_point_adjustment
,
12127 doc
: /* If non-nil, suppress point adjustment after executing a command.
12129 After a command is executed, if point is moved into a region that has
12130 special properties (e.g. composition, display), we adjust point to
12131 the boundary of the region. But, when a command sets this variable to
12132 non-nil, we suppress the point adjustment.
12134 This variable is set to nil before reading a command, and is checked
12135 just after executing the command. */);
12136 Vdisable_point_adjustment
= Qnil
;
12138 DEFVAR_LISP ("global-disable-point-adjustment",
12139 Vglobal_disable_point_adjustment
,
12140 doc
: /* *If non-nil, always suppress point adjustment.
12142 The default value is nil, in which case, point adjustment are
12143 suppressed only after special commands that set
12144 `disable-point-adjustment' (which see) to non-nil. */);
12145 Vglobal_disable_point_adjustment
= Qnil
;
12147 DEFVAR_LISP ("minibuffer-message-timeout", Vminibuffer_message_timeout
,
12148 doc
: /* *How long to display an echo-area message when the minibuffer is active.
12149 If the value is not a number, such messages don't time out. */);
12150 Vminibuffer_message_timeout
= make_number (2);
12152 DEFVAR_LISP ("throw-on-input", Vthrow_on_input
,
12153 doc
: /* If non-nil, any keyboard input throws to this symbol.
12154 The value of that variable is passed to `quit-flag' and later causes a
12155 peculiar kind of quitting. */);
12156 Vthrow_on_input
= Qnil
;
12158 DEFVAR_LISP ("command-error-function", Vcommand_error_function
,
12159 doc
: /* If non-nil, function to output error messages.
12160 The arguments are the error data, a list of the form
12161 (SIGNALED-CONDITIONS . SIGNAL-DATA)
12162 such as just as `condition-case' would bind its variable to,
12163 the context (a string which normally goes at the start of the message),
12164 and the Lisp function within which the error was signaled. */);
12165 Vcommand_error_function
= Qnil
;
12167 DEFVAR_LISP ("enable-disabled-menus-and-buttons",
12168 Venable_disabled_menus_and_buttons
,
12169 doc
: /* If non-nil, don't ignore events produced by disabled menu items and tool-bar.
12171 Help functions bind this to allow help on disabled menu items
12172 and tool-bar buttons. */);
12173 Venable_disabled_menus_and_buttons
= Qnil
;
12175 DEFVAR_LISP ("select-active-regions",
12176 Vselect_active_regions
,
12177 doc
: /* If non-nil, an active region automatically sets the primary selection.
12178 If the value is `only', only temporarily active regions (usually made
12179 by mouse-dragging or shift-selection) set the window selection.
12181 This takes effect only when Transient Mark mode is enabled. */);
12182 Vselect_active_regions
= Qt
;
12184 DEFVAR_LISP ("saved-region-selection",
12185 Vsaved_region_selection
,
12186 doc
: /* Contents of active region prior to buffer modification.
12187 If `select-active-regions' is non-nil, Emacs sets this to the
12188 text in the region before modifying the buffer. The next
12189 `deactivate-mark' call uses this to set the window selection. */);
12190 Vsaved_region_selection
= Qnil
;
12192 /* Create the initial keyboard. */
12193 initial_kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12194 init_kboard (initial_kboard
);
12195 /* Vwindow_system is left at t for now. */
12196 initial_kboard
->next_kboard
= all_kboards
;
12197 all_kboards
= initial_kboard
;
12201 keys_of_keyboard (void)
12203 initial_define_key (global_map
, Ctl ('Z'), "suspend-emacs");
12204 initial_define_key (control_x_map
, Ctl ('Z'), "suspend-emacs");
12205 initial_define_key (meta_map
, Ctl ('C'), "exit-recursive-edit");
12206 initial_define_key (global_map
, Ctl (']'), "abort-recursive-edit");
12207 initial_define_key (meta_map
, 'x', "execute-extended-command");
12209 initial_define_lispy_key (Vspecial_event_map
, "delete-frame",
12210 "handle-delete-frame");
12211 initial_define_lispy_key (Vspecial_event_map
, "ns-put-working-text",
12212 "ns-put-working-text");
12213 initial_define_lispy_key (Vspecial_event_map
, "ns-unput-working-text",
12214 "ns-unput-working-text");
12215 /* Here we used to use `ignore-event' which would simple set prefix-arg to
12216 current-prefix-arg, as is done in `handle-switch-frame'.
12217 But `handle-switch-frame is not run from the special-map.
12218 Commands from that map are run in a special way that automatically
12219 preserves the prefix-arg. Restoring the prefix arg here is not just
12220 redundant but harmful:
12222 - current-prefix-arg is set to non-nil, prefix-arg is set to nil.
12223 - after the first prompt, the exit-minibuffer-hook is run which may
12224 iconify a frame and thus push a `iconify-frame' event.
12225 - after running exit-minibuffer-hook, current-prefix-arg is
12226 restored to the non-nil value it had before the prompt.
12227 - we enter the second prompt.
12228 current-prefix-arg is non-nil, prefix-arg is nil.
12229 - before running the first real event, we run the special iconify-frame
12230 event, but we pass the `special' arg to execute-command so
12231 current-prefix-arg and prefix-arg are left untouched.
12232 - here we foolishly copy the non-nil current-prefix-arg to prefix-arg.
12233 - the next key event will have a spuriously non-nil current-prefix-arg. */
12234 initial_define_lispy_key (Vspecial_event_map
, "iconify-frame",
12236 initial_define_lispy_key (Vspecial_event_map
, "make-frame-visible",
12238 /* Handling it at such a low-level causes read_key_sequence to get
12239 * confused because it doesn't realize that the current_buffer was
12240 * changed by read_char.
12242 * initial_define_lispy_key (Vspecial_event_map, "select-window",
12243 * "handle-select-window"); */
12244 initial_define_lispy_key (Vspecial_event_map
, "save-session",
12245 "handle-save-session");
12248 /* Define a special event which is raised for dbus callback
12250 initial_define_lispy_key (Vspecial_event_map
, "dbus-event",
12251 "dbus-handle-event");
12254 initial_define_lispy_key (Vspecial_event_map
, "config-changed-event",
12258 /* Mark the pointers in the kboard objects.
12259 Called by the Fgarbage_collector. */
12261 mark_kboards (void)
12265 for (kb
= all_kboards
; kb
; kb
= kb
->next_kboard
)
12267 if (kb
->kbd_macro_buffer
)
12268 for (p
= kb
->kbd_macro_buffer
; p
< kb
->kbd_macro_ptr
; p
++)
12270 mark_object (KVAR (kb
, Voverriding_terminal_local_map
));
12271 mark_object (KVAR (kb
, Vlast_command
));
12272 mark_object (KVAR (kb
, Vreal_last_command
));
12273 mark_object (KVAR (kb
, Vkeyboard_translate_table
));
12274 mark_object (KVAR (kb
, Vlast_repeatable_command
));
12275 mark_object (KVAR (kb
, Vprefix_arg
));
12276 mark_object (KVAR (kb
, Vlast_prefix_arg
));
12277 mark_object (KVAR (kb
, kbd_queue
));
12278 mark_object (KVAR (kb
, defining_kbd_macro
));
12279 mark_object (KVAR (kb
, Vlast_kbd_macro
));
12280 mark_object (KVAR (kb
, Vsystem_key_alist
));
12281 mark_object (KVAR (kb
, system_key_syms
));
12282 mark_object (KVAR (kb
, Vwindow_system
));
12283 mark_object (KVAR (kb
, Vinput_decode_map
));
12284 mark_object (KVAR (kb
, Vlocal_function_key_map
));
12285 mark_object (KVAR (kb
, Vdefault_minibuffer_frame
));
12286 mark_object (KVAR (kb
, echo_string
));
12289 struct input_event
*event
;
12290 for (event
= kbd_fetch_ptr
; event
!= kbd_store_ptr
; event
++)
12292 if (event
== kbd_buffer
+ KBD_BUFFER_SIZE
)
12293 event
= kbd_buffer
;
12294 if (event
->kind
!= SELECTION_REQUEST_EVENT
12295 && event
->kind
!= SELECTION_CLEAR_EVENT
)
12297 mark_object (event
->x
);
12298 mark_object (event
->y
);
12300 mark_object (event
->frame_or_window
);
12301 mark_object (event
->arg
);