1 /* Generic frame functions.
3 Copyright (C) 1993-1995, 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 "character.h"
39 /* These help us bind and responding to switch-frame events. */
43 #include "blockinput.h"
45 #include "termhooks.h"
46 #include "dispextern.h"
49 #ifdef HAVE_WINDOW_SYSTEM
58 #ifdef HAVE_WINDOW_SYSTEM
63 Lisp_Object Qns_parse_geometry
;
66 Lisp_Object Qframep
, Qframe_live_p
;
67 Lisp_Object Qicon
, Qmodeline
;
69 Lisp_Object Qx
, Qw32
, Qmac
, Qpc
, Qns
;
71 Lisp_Object Qdisplay_type
;
72 static Lisp_Object Qbackground_mode
;
75 static Lisp_Object Qx_frame_parameter
;
76 Lisp_Object Qx_resource_name
;
77 Lisp_Object Qterminal
;
78 Lisp_Object Qterminal_live_p
;
80 /* Frame parameters (set or reported). */
82 Lisp_Object Qauto_raise
, Qauto_lower
;
83 Lisp_Object Qborder_color
, Qborder_width
;
84 Lisp_Object Qcursor_color
, Qcursor_type
;
85 static Lisp_Object Qgeometry
; /* Not used */
86 Lisp_Object Qheight
, Qwidth
;
87 Lisp_Object Qleft
, Qright
;
88 Lisp_Object Qicon_left
, Qicon_top
, Qicon_type
, Qicon_name
;
90 Lisp_Object Qinternal_border_width
;
91 Lisp_Object Qmouse_color
;
92 Lisp_Object Qminibuffer
;
93 Lisp_Object Qscroll_bar_width
, Qvertical_scroll_bars
;
94 Lisp_Object Qvisibility
;
95 Lisp_Object Qscroll_bar_foreground
, Qscroll_bar_background
;
96 Lisp_Object Qscreen_gamma
;
97 Lisp_Object Qline_spacing
;
98 static Lisp_Object Quser_position
, Quser_size
;
99 Lisp_Object Qwait_for_wm
;
100 static Lisp_Object Qwindow_id
;
101 #ifdef HAVE_X_WINDOWS
102 static Lisp_Object Qouter_window_id
;
104 Lisp_Object Qparent_id
;
105 Lisp_Object Qtitle
, Qname
;
106 static Lisp_Object Qexplicit_name
;
107 Lisp_Object Qunsplittable
;
108 Lisp_Object Qmenu_bar_lines
, Qtool_bar_lines
, Qtool_bar_position
;
109 Lisp_Object Qleft_fringe
, Qright_fringe
;
110 Lisp_Object Qbuffer_predicate
;
111 static Lisp_Object Qbuffer_list
, Qburied_buffer_list
;
112 Lisp_Object Qtty_color_mode
;
113 Lisp_Object Qtty
, Qtty_type
;
115 Lisp_Object Qfullscreen
, Qfullwidth
, Qfullheight
, Qfullboth
, Qmaximized
;
117 Lisp_Object Qfont_backend
;
120 Lisp_Object Qface_set_after_frame_default
;
122 static Lisp_Object Qdelete_frame_functions
;
124 #ifdef HAVE_WINDOW_SYSTEM
125 static void x_report_frame_params (struct frame
*, Lisp_Object
*);
130 set_menu_bar_lines_1 (Lisp_Object window
, int n
)
132 struct window
*w
= XWINDOW (window
);
134 XSETFASTINT (w
->last_modified
, 0);
135 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
136 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
138 if (INTEGERP (w
->orig_top_line
))
139 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
140 if (INTEGERP (w
->orig_total_lines
))
141 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
143 /* Handle just the top child in a vertical split. */
144 if (!NILP (w
->vchild
))
145 set_menu_bar_lines_1 (w
->vchild
, n
);
147 /* Adjust all children in a horizontal split. */
148 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
150 w
= XWINDOW (window
);
151 set_menu_bar_lines_1 (window
, n
);
156 set_menu_bar_lines (struct frame
*f
, Lisp_Object value
, Lisp_Object oldval
)
159 int olines
= FRAME_MENU_BAR_LINES (f
);
161 /* Right now, menu bars don't work properly in minibuf-only frames;
162 most of the commands try to apply themselves to the minibuffer
163 frame itself, and get an error because you can't switch buffers
164 in or split the minibuffer window. */
165 if (FRAME_MINIBUF_ONLY_P (f
))
168 if (INTEGERP (value
))
169 nlines
= XINT (value
);
173 if (nlines
!= olines
)
175 windows_or_buffers_changed
++;
176 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
177 FRAME_MENU_BAR_LINES (f
) = nlines
;
178 set_menu_bar_lines_1 (f
->root_window
, nlines
- olines
);
183 Lisp_Object Vframe_list
;
186 DEFUN ("framep", Fframep
, Sframep
, 1, 1, 0,
187 doc
: /* Return non-nil if OBJECT is a frame.
189 t for a termcap frame (a character-only terminal),
190 'x' for an Emacs frame that is really an X window,
191 'w32' for an Emacs frame that is a window on MS-Windows display,
192 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
193 'pc' for a direct-write MS-DOS frame.
194 See also `frame-live-p'. */)
197 if (!FRAMEP (object
))
199 switch (XFRAME (object
)->output_method
)
201 case output_initial
: /* The initial frame is like a termcap frame. */
204 case output_x_window
:
208 case output_msdos_raw
:
219 DEFUN ("frame-live-p", Fframe_live_p
, Sframe_live_p
, 1, 1, 0,
220 doc
: /* Return non-nil if OBJECT is a frame which has not been deleted.
221 Value is nil if OBJECT is not a live frame. If object is a live
222 frame, the return value indicates what sort of terminal device it is
223 displayed on. See the documentation of `framep' for possible
227 return ((FRAMEP (object
)
228 && FRAME_LIVE_P (XFRAME (object
)))
233 DEFUN ("window-system", Fwindow_system
, Swindow_system
, 0, 1, 0,
234 doc
: /* The name of the window system that FRAME is displaying through.
235 The value is a symbol:
236 nil for a termcap frame (a character-only terminal),
237 'x' for an Emacs frame that is really an X window,
238 'w32' for an Emacs frame that is a window on MS-Windows display,
239 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
240 'pc' for a direct-write MS-DOS frame.
242 FRAME defaults to the currently selected frame.
244 Use of this function as a predicate is deprecated. Instead,
245 use `display-graphic-p' or any of the other `display-*-p'
246 predicates which report frame's specific UI-related capabilities. */)
251 frame
= selected_frame
;
253 type
= Fframep (frame
);
256 wrong_type_argument (Qframep
, frame
);
265 make_frame (int mini_p
)
268 register struct frame
*f
;
269 register Lisp_Object root_window
;
270 register Lisp_Object mini_window
;
272 f
= allocate_frame ();
273 XSETFRAME (frame
, f
);
275 f
->desired_matrix
= 0;
276 f
->current_matrix
= 0;
279 f
->glyphs_initialized_p
= 0;
280 f
->decode_mode_spec_buffer
= 0;
282 f
->async_visible
= 0;
283 f
->output_data
.nothing
= 0;
285 f
->async_iconified
= 0;
286 f
->wants_modeline
= 1;
291 f
->has_minibuffer
= mini_p
;
292 f
->focus_frame
= Qnil
;
293 f
->explicit_name
= 0;
294 f
->can_have_scroll_bars
= 0;
295 f
->vertical_scroll_bar_type
= vertical_scroll_bar_none
;
296 f
->param_alist
= Qnil
;
297 f
->scroll_bars
= Qnil
;
298 f
->condemned_scroll_bars
= Qnil
;
299 f
->face_alist
= Qnil
;
300 f
->face_cache
= NULL
;
301 f
->menu_bar_items
= Qnil
;
302 f
->menu_bar_vector
= Qnil
;
303 f
->menu_bar_items_used
= 0;
304 f
->buffer_predicate
= Qnil
;
305 f
->buffer_list
= Qnil
;
306 f
->buried_buffer_list
= Qnil
;
309 f
->menu_bar_window
= Qnil
;
310 f
->tool_bar_window
= Qnil
;
311 f
->tool_bar_items
= Qnil
;
312 f
->tool_bar_position
= Qtop
;
313 f
->desired_tool_bar_string
= f
->current_tool_bar_string
= Qnil
;
314 f
->n_tool_bar_items
= 0;
315 f
->left_fringe_width
= f
->right_fringe_width
= 0;
317 f
->menu_bar_lines
= 0;
318 f
->tool_bar_lines
= 0;
319 f
->scroll_bar_actual_width
= 0;
321 f
->internal_border_width
= 0;
322 f
->column_width
= 1; /* !FRAME_WINDOW_P value */
323 f
->line_height
= 1; /* !FRAME_WINDOW_P value */
324 f
->x_pixels_diff
= f
->y_pixels_diff
= 0;
325 #ifdef HAVE_WINDOW_SYSTEM
326 f
->want_fullscreen
= FULLSCREEN_NONE
;
328 f
->size_hint_flags
= 0;
330 f
->font_driver_list
= NULL
;
331 f
->font_data_list
= NULL
;
333 root_window
= make_window ();
336 mini_window
= make_window ();
337 XWINDOW (root_window
)->next
= mini_window
;
338 XWINDOW (mini_window
)->prev
= root_window
;
339 XWINDOW (mini_window
)->mini_p
= Qt
;
340 XWINDOW (mini_window
)->frame
= frame
;
341 f
->minibuffer_window
= mini_window
;
346 XWINDOW (root_window
)->next
= Qnil
;
347 f
->minibuffer_window
= Qnil
;
350 XWINDOW (root_window
)->frame
= frame
;
353 just so that there is "something there."
354 Correct size will be set up later with change_frame_size. */
356 SET_FRAME_COLS (f
, 10);
357 FRAME_LINES (f
) = 10;
359 XSETFASTINT (XWINDOW (root_window
)->total_cols
, 10);
360 XSETFASTINT (XWINDOW (root_window
)->total_lines
, (mini_p
? 9 : 10));
364 XSETFASTINT (XWINDOW (mini_window
)->total_cols
, 10);
365 XSETFASTINT (XWINDOW (mini_window
)->top_line
, 9);
366 XSETFASTINT (XWINDOW (mini_window
)->total_lines
, 1);
369 /* Choose a buffer for the frame's root window. */
373 XWINDOW (root_window
)->buffer
= Qt
;
374 buf
= Fcurrent_buffer ();
375 /* If buf is a 'hidden' buffer (i.e. one whose name starts with
376 a space), try to find another one. */
377 if (SREF (Fbuffer_name (buf
), 0) == ' ')
378 buf
= Fother_buffer (buf
, Qnil
, Qnil
);
380 /* Use set_window_buffer, not Fset_window_buffer, and don't let
381 hooks be run by it. The reason is that the whole frame/window
382 arrangement is not yet fully intialized at this point. Windows
383 don't have the right size, glyph matrices aren't initialized
384 etc. Running Lisp functions at this point surely ends in a
386 set_window_buffer (root_window
, buf
, 0, 0);
387 f
->buffer_list
= Fcons (buf
, Qnil
);
392 XWINDOW (mini_window
)->buffer
= Qt
;
393 set_window_buffer (mini_window
,
394 (NILP (Vminibuffer_list
)
396 : Fcar (Vminibuffer_list
)),
400 f
->root_window
= root_window
;
401 f
->selected_window
= root_window
;
402 /* Make sure this window seems more recently used than
403 a newly-created, never-selected window. */
404 ++window_select_count
;
405 XSETFASTINT (XWINDOW (f
->selected_window
)->use_time
, window_select_count
);
407 f
->default_face_done_p
= 0;
412 #ifdef HAVE_WINDOW_SYSTEM
413 /* Make a frame using a separate minibuffer window on another frame.
414 MINI_WINDOW is the minibuffer window to use. nil means use the
415 default (the global minibuffer). */
418 make_frame_without_minibuffer (register Lisp_Object mini_window
, KBOARD
*kb
, Lisp_Object display
)
420 register struct frame
*f
;
423 if (!NILP (mini_window
))
424 CHECK_LIVE_WINDOW (mini_window
);
426 if (!NILP (mini_window
)
427 && FRAME_KBOARD (XFRAME (XWINDOW (mini_window
)->frame
)) != kb
)
428 error ("Frame and minibuffer must be on the same terminal");
430 /* Make a frame containing just a root window. */
433 if (NILP (mini_window
))
435 /* Use default-minibuffer-frame if possible. */
436 if (!FRAMEP (KVAR (kb
, Vdefault_minibuffer_frame
))
437 || ! FRAME_LIVE_P (XFRAME (KVAR (kb
, Vdefault_minibuffer_frame
))))
439 Lisp_Object frame_dummy
;
441 XSETFRAME (frame_dummy
, f
);
442 GCPRO1 (frame_dummy
);
443 /* If there's no minibuffer frame to use, create one. */
444 KVAR (kb
, Vdefault_minibuffer_frame
) =
445 call1 (intern ("make-initial-minibuffer-frame"), display
);
449 mini_window
= XFRAME (KVAR (kb
, Vdefault_minibuffer_frame
))->minibuffer_window
;
452 f
->minibuffer_window
= mini_window
;
454 /* Make the chosen minibuffer window display the proper minibuffer,
455 unless it is already showing a minibuffer. */
456 if (NILP (Fmemq (XWINDOW (mini_window
)->buffer
, Vminibuffer_list
)))
457 Fset_window_buffer (mini_window
,
458 (NILP (Vminibuffer_list
)
460 : Fcar (Vminibuffer_list
)), Qnil
);
464 /* Make a frame containing only a minibuffer window. */
467 make_minibuffer_frame (void)
469 /* First make a frame containing just a root window, no minibuffer. */
471 register struct frame
*f
= make_frame (0);
472 register Lisp_Object mini_window
;
473 register Lisp_Object frame
;
475 XSETFRAME (frame
, f
);
480 f
->wants_modeline
= 0;
481 f
->has_minibuffer
= 1;
483 /* Now label the root window as also being the minibuffer.
484 Avoid infinite looping on the window chain by marking next pointer
487 mini_window
= f
->minibuffer_window
= f
->root_window
;
488 XWINDOW (mini_window
)->mini_p
= Qt
;
489 XWINDOW (mini_window
)->next
= Qnil
;
490 XWINDOW (mini_window
)->prev
= Qnil
;
491 XWINDOW (mini_window
)->frame
= frame
;
493 /* Put the proper buffer in that window. */
495 Fset_window_buffer (mini_window
,
496 (NILP (Vminibuffer_list
)
498 : Fcar (Vminibuffer_list
)), Qnil
);
501 #endif /* HAVE_WINDOW_SYSTEM */
503 /* Construct a frame that refers to a terminal. */
505 static int tty_frame_count
;
508 make_initial_frame (void)
511 struct terminal
*terminal
;
514 eassert (initial_kboard
);
516 /* The first call must initialize Vframe_list. */
517 if (! (NILP (Vframe_list
) || CONSP (Vframe_list
)))
520 terminal
= init_initial_terminal ();
523 XSETFRAME (frame
, f
);
525 Vframe_list
= Fcons (frame
, Vframe_list
);
528 f
->name
= make_pure_c_string ("F1");
531 f
->async_visible
= 1;
533 f
->output_method
= terminal
->type
;
534 f
->terminal
= terminal
;
535 f
->terminal
->reference_count
++;
536 f
->output_data
.nothing
= 0;
538 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
539 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
541 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
542 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
544 /* The default value of menu-bar-mode is t. */
545 set_menu_bar_lines (f
, make_number (1), Qnil
);
549 init_frame_faces (f
);
556 static struct frame
*
557 make_terminal_frame (struct terminal
*terminal
)
559 register struct frame
*f
;
564 error ("Terminal is not live, can't create new frames on it");
568 XSETFRAME (frame
, f
);
569 Vframe_list
= Fcons (frame
, Vframe_list
);
572 sprintf (name
, "F%d", tty_frame_count
);
573 f
->name
= build_string (name
);
575 f
->visible
= 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
576 f
->async_visible
= 1; /* Don't let visible be cleared later. */
577 f
->terminal
= terminal
;
578 f
->terminal
->reference_count
++;
580 f
->output_data
.tty
->display_info
= &the_only_display_info
;
581 if (!inhibit_window_system
582 && (!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
))
583 || XFRAME (selected_frame
)->output_method
== output_msdos_raw
))
584 f
->output_method
= output_msdos_raw
;
586 f
->output_method
= output_termcap
;
587 #else /* not MSDOS */
588 f
->output_method
= output_termcap
;
589 create_tty_output (f
);
590 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
591 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
592 #endif /* not MSDOS */
594 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
595 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
596 FRAME_MENU_BAR_LINES(f
) = NILP (Vmenu_bar_mode
) ? 0 : 1;
598 /* Set the top frame to the newly created frame. */
599 if (FRAMEP (FRAME_TTY (f
)->top_frame
)
600 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f
)->top_frame
)))
601 XFRAME (FRAME_TTY (f
)->top_frame
)->async_visible
= 2; /* obscured */
603 FRAME_TTY (f
)->top_frame
= frame
;
606 init_frame_faces (f
);
611 /* Get a suitable value for frame parameter PARAMETER for a newly
612 created frame, based on (1) the user-supplied frame parameter
613 alist SUPPLIED_PARMS, and (2) CURRENT_VALUE. */
616 get_future_frame_param (Lisp_Object parameter
,
617 Lisp_Object supplied_parms
,
622 result
= Fassq (parameter
, supplied_parms
);
624 result
= Fassq (parameter
, XFRAME (selected_frame
)->param_alist
);
625 if (NILP (result
) && current_value
!= NULL
)
626 result
= build_string (current_value
);
627 if (!NILP (result
) && !STRINGP (result
))
628 result
= XCDR (result
);
629 if (NILP (result
) || !STRINGP (result
))
635 DEFUN ("make-terminal-frame", Fmake_terminal_frame
, Smake_terminal_frame
,
637 doc
: /* Create an additional terminal frame, possibly on another terminal.
638 This function takes one argument, an alist specifying frame parameters.
640 You can create multiple frames on a single text-only terminal, but
641 only one of them (the selected terminal frame) is actually displayed.
643 In practice, generally you don't need to specify any parameters,
644 except when you want to create a new frame on another terminal.
645 In that case, the `tty' parameter specifies the device file to open,
646 and the `tty-type' parameter specifies the terminal type. Example:
648 (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
650 Note that changing the size of one terminal frame automatically
651 affects all frames on the same terminal device. */)
655 struct terminal
*t
= NULL
;
656 Lisp_Object frame
, tem
;
657 struct frame
*sf
= SELECTED_FRAME ();
660 if (sf
->output_method
!= output_msdos_raw
661 && sf
->output_method
!= output_termcap
)
663 #else /* not MSDOS */
665 #ifdef WINDOWSNT /* This should work now! */
666 if (sf
->output_method
!= output_termcap
)
667 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
669 #endif /* not MSDOS */
672 Lisp_Object terminal
;
674 terminal
= Fassq (Qterminal
, parms
);
675 if (!NILP (terminal
))
677 terminal
= XCDR (terminal
);
678 t
= get_terminal (terminal
, 1);
681 if (t
&& t
!= the_only_display_info
.terminal
)
682 /* msdos.c assumes a single tty_display_info object. */
683 error ("Multiple terminals are not supported on this platform");
685 t
= the_only_display_info
.terminal
;
691 char *name
= 0, *type
= 0;
692 Lisp_Object tty
, tty_type
;
694 tty
= get_future_frame_param
695 (Qtty
, parms
, (FRAME_TERMCAP_P (XFRAME (selected_frame
))
696 ? FRAME_TTY (XFRAME (selected_frame
))->name
700 name
= (char *) alloca (SBYTES (tty
) + 1);
701 strncpy (name
, SSDATA (tty
), SBYTES (tty
));
702 name
[SBYTES (tty
)] = 0;
705 tty_type
= get_future_frame_param
706 (Qtty_type
, parms
, (FRAME_TERMCAP_P (XFRAME (selected_frame
))
707 ? FRAME_TTY (XFRAME (selected_frame
))->type
709 if (!NILP (tty_type
))
711 type
= (char *) alloca (SBYTES (tty_type
) + 1);
712 strncpy (type
, SSDATA (tty_type
), SBYTES (tty_type
));
713 type
[SBYTES (tty_type
)] = 0;
716 t
= init_tty (name
, type
, 0); /* Errors are not fatal. */
719 f
= make_terminal_frame (t
);
723 get_tty_size (fileno (FRAME_TTY (f
)->input
), &width
, &height
);
724 change_frame_size (f
, height
, width
, 0, 0, 0);
729 XSETFRAME (frame
, f
);
730 Fmodify_frame_parameters (frame
, parms
);
731 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty_type
,
732 build_string (t
->display_info
.tty
->type
)),
734 if (t
->display_info
.tty
->name
!= NULL
)
735 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty
,
736 build_string (t
->display_info
.tty
->name
)),
739 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty
, Qnil
), Qnil
));
741 /* Make the frame face alist be frame-specific, so that each
742 frame could change its face definitions independently. */
743 f
->face_alist
= Fcopy_alist (sf
->face_alist
);
744 /* Simple Fcopy_alist isn't enough, because we need the contents of
745 the vectors which are the CDRs of associations in face_alist to
746 be copied as well. */
747 for (tem
= f
->face_alist
; CONSP (tem
); tem
= XCDR (tem
))
748 XSETCDR (XCAR (tem
), Fcopy_sequence (XCDR (XCAR (tem
))));
753 /* Perform the switch to frame FRAME.
755 If FRAME is a switch-frame event `(switch-frame FRAME1)', use
758 If TRACK is non-zero and the frame that currently has the focus
759 redirects its focus to the selected frame, redirect that focused
760 frame's focus to FRAME instead.
762 FOR_DELETION non-zero means that the selected frame is being
763 deleted, which includes the possibility that the frame's terminal
766 The value of NORECORD is passed as argument to Fselect_window. */
769 do_switch_frame (Lisp_Object frame
, int track
, int for_deletion
, Lisp_Object norecord
)
771 struct frame
*sf
= SELECTED_FRAME ();
773 /* If FRAME is a switch-frame event, extract the frame we should
776 && EQ (XCAR (frame
), Qswitch_frame
)
777 && CONSP (XCDR (frame
)))
778 frame
= XCAR (XCDR (frame
));
780 /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
781 a switch-frame event to arrive after a frame is no longer live,
782 especially when deleting the initial frame during startup. */
784 if (! FRAME_LIVE_P (XFRAME (frame
)))
787 if (sf
== XFRAME (frame
))
790 /* This is too greedy; it causes inappropriate focus redirection
791 that's hard to get rid of. */
793 /* If a frame's focus has been redirected toward the currently
794 selected frame, we should change the redirection to point to the
795 newly selected frame. This means that if the focus is redirected
796 from a minibufferless frame to a surrogate minibuffer frame, we
797 can use `other-window' to switch between all the frames using
798 that minibuffer frame, and the focus redirection will follow us
804 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
808 if (!FRAMEP (XCAR (tail
)))
811 focus
= FRAME_FOCUS_FRAME (XFRAME (XCAR (tail
)));
813 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
814 Fredirect_frame_focus (XCAR (tail
), frame
);
818 /* Instead, apply it only to the frame we're pointing to. */
819 #ifdef HAVE_WINDOW_SYSTEM
820 if (track
&& FRAME_WINDOW_P (XFRAME (frame
)))
822 Lisp_Object focus
, xfocus
;
824 xfocus
= x_get_focus_frame (XFRAME (frame
));
827 focus
= FRAME_FOCUS_FRAME (XFRAME (xfocus
));
828 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
829 Fredirect_frame_focus (xfocus
, frame
);
832 #endif /* HAVE_X_WINDOWS */
835 if (!for_deletion
&& FRAME_HAS_MINIBUF_P (sf
))
836 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf
)), 1);
838 if (FRAME_TERMCAP_P (XFRAME (frame
)) || FRAME_MSDOS_P (XFRAME (frame
)))
840 if (FRAMEP (FRAME_TTY (XFRAME (frame
))->top_frame
))
841 /* Mark previously displayed frame as now obscured. */
842 XFRAME (FRAME_TTY (XFRAME (frame
))->top_frame
)->async_visible
= 2;
843 XFRAME (frame
)->async_visible
= 1;
844 FRAME_TTY (XFRAME (frame
))->top_frame
= frame
;
847 selected_frame
= frame
;
848 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame
)))
849 last_nonminibuf_frame
= XFRAME (selected_frame
);
851 Fselect_window (XFRAME (frame
)->selected_window
, norecord
);
853 /* We want to make sure that the next event generates a frame-switch
854 event to the appropriate frame. This seems kludgy to me, but
855 before you take it out, make sure that evaluating something like
856 (select-window (frame-root-window (new-frame))) doesn't end up
857 with your typing being interpreted in the new frame instead of
858 the one you're actually typing in. */
859 internal_last_event_frame
= Qnil
;
864 DEFUN ("select-frame", Fselect_frame
, Sselect_frame
, 1, 2, "e",
865 doc
: /* Select FRAME.
866 Subsequent editing commands apply to its selected window.
867 Optional argument NORECORD means to neither change the order of
868 recently selected windows nor the buffer list.
870 The selection of FRAME lasts until the next time the user does
871 something to select a different frame, or until the next time
872 this function is called. If you are using a window system, the
873 previously selected frame may be restored as the selected frame
874 when returning to the command loop, because it still may have
875 the window system's input focus. On a text-only terminal, the
876 next redisplay will display FRAME.
878 This function returns FRAME, or nil if FRAME has been deleted. */)
879 (Lisp_Object frame
, Lisp_Object norecord
)
881 return do_switch_frame (frame
, 1, 0, norecord
);
885 DEFUN ("handle-switch-frame", Fhandle_switch_frame
, Shandle_switch_frame
, 1, 1, "e",
886 doc
: /* Handle a switch-frame event EVENT.
887 Switch-frame events are usually bound to this function.
888 A switch-frame event tells Emacs that the window manager has requested
889 that the user's events be directed to the frame mentioned in the event.
890 This function selects the selected window of the frame of EVENT.
892 If EVENT is frame object, handle it as if it were a switch-frame event
896 /* Preserve prefix arg that the command loop just cleared. */
897 KVAR (current_kboard
, Vprefix_arg
) = Vcurrent_prefix_arg
;
898 Frun_hooks (1, &Qmouse_leave_buffer_hook
);
899 return do_switch_frame (event
, 0, 0, Qnil
);
902 DEFUN ("selected-frame", Fselected_frame
, Sselected_frame
, 0, 0, 0,
903 doc
: /* Return the frame that is now selected. */)
906 return selected_frame
;
909 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
910 doc
: /* Return the frame object that window WINDOW is on. */)
913 CHECK_LIVE_WINDOW (window
);
914 return XWINDOW (window
)->frame
;
917 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
918 doc
: /* Returns the topmost, leftmost window of FRAME.
919 If omitted, FRAME defaults to the currently selected frame. */)
925 w
= SELECTED_FRAME ()->root_window
;
928 CHECK_LIVE_FRAME (frame
);
929 w
= XFRAME (frame
)->root_window
;
931 while (NILP (XWINDOW (w
)->buffer
))
933 if (! NILP (XWINDOW (w
)->hchild
))
934 w
= XWINDOW (w
)->hchild
;
935 else if (! NILP (XWINDOW (w
)->vchild
))
936 w
= XWINDOW (w
)->vchild
;
943 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
944 Sactive_minibuffer_window
, 0, 0, 0,
945 doc
: /* Return the currently active minibuffer window, or nil if none. */)
948 return minibuf_level
? minibuf_window
: Qnil
;
951 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
952 doc
: /* Returns the root-window of FRAME.
953 If omitted, FRAME defaults to the currently selected frame. */)
959 window
= SELECTED_FRAME ()->root_window
;
962 CHECK_LIVE_FRAME (frame
);
963 window
= XFRAME (frame
)->root_window
;
969 DEFUN ("frame-selected-window", Fframe_selected_window
,
970 Sframe_selected_window
, 0, 1, 0,
971 doc
: /* Return the selected window of FRAME.
972 FRAME defaults to the currently selected frame. */)
978 window
= SELECTED_FRAME ()->selected_window
;
981 CHECK_LIVE_FRAME (frame
);
982 window
= XFRAME (frame
)->selected_window
;
988 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
989 Sset_frame_selected_window
, 2, 3, 0,
990 doc
: /* Set selected window of FRAME to WINDOW.
991 If FRAME is nil, use the selected frame. If FRAME is the
992 selected frame, this makes WINDOW the selected window.
993 Optional argument NORECORD non-nil means to neither change the
994 order of recently selected windows nor the buffer list.
996 (Lisp_Object frame
, Lisp_Object window
, Lisp_Object norecord
)
999 frame
= selected_frame
;
1001 CHECK_LIVE_FRAME (frame
);
1002 CHECK_LIVE_WINDOW (window
);
1004 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
1005 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1007 if (EQ (frame
, selected_frame
))
1008 return Fselect_window (window
, norecord
);
1010 return XFRAME (frame
)->selected_window
= window
;
1014 DEFUN ("frame-list", Fframe_list
, Sframe_list
,
1016 doc
: /* Return a list of all live frames. */)
1020 frames
= Fcopy_sequence (Vframe_list
);
1021 #ifdef HAVE_WINDOW_SYSTEM
1022 if (FRAMEP (tip_frame
))
1023 frames
= Fdelq (tip_frame
, frames
);
1028 /* Return the next frame in the frame list after FRAME.
1029 If MINIBUF is nil, exclude minibuffer-only frames.
1030 If MINIBUF is a window, include only its own frame
1031 and any frame now using that window as the minibuffer.
1032 If MINIBUF is `visible', include all visible frames.
1033 If MINIBUF is 0, include all visible and iconified frames.
1034 Otherwise, include all frames. */
1037 next_frame (Lisp_Object frame
, Lisp_Object minibuf
)
1042 /* There must always be at least one frame in Vframe_list. */
1043 if (! CONSP (Vframe_list
))
1046 /* If this frame is dead, it won't be in Vframe_list, and we'll loop
1047 forever. Forestall that. */
1048 CHECK_LIVE_FRAME (frame
);
1051 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1058 && ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1059 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1060 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1061 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
)))))
1063 /* Decide whether this frame is eligible to be returned. */
1065 /* If we've looped all the way around without finding any
1066 eligible frames, return the original frame. */
1070 /* Let minibuf decide if this frame is acceptable. */
1073 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1076 else if (EQ (minibuf
, Qvisible
))
1078 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1079 if (FRAME_VISIBLE_P (XFRAME (f
)))
1082 else if (INTEGERP (minibuf
) && XINT (minibuf
) == 0)
1084 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1085 if (FRAME_VISIBLE_P (XFRAME (f
))
1086 || FRAME_ICONIFIED_P (XFRAME (f
)))
1089 else if (WINDOWP (minibuf
))
1091 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1092 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1093 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1094 FRAME_FOCUS_FRAME (XFRAME (f
))))
1106 /* Return the previous frame in the frame list before FRAME.
1107 If MINIBUF is nil, exclude minibuffer-only frames.
1108 If MINIBUF is a window, include only its own frame
1109 and any frame now using that window as the minibuffer.
1110 If MINIBUF is `visible', include all visible frames.
1111 If MINIBUF is 0, include all visible and iconified frames.
1112 Otherwise, include all frames. */
1115 prev_frame (Lisp_Object frame
, Lisp_Object minibuf
)
1120 /* There must always be at least one frame in Vframe_list. */
1121 if (! CONSP (Vframe_list
))
1125 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1133 if (EQ (frame
, f
) && !NILP (prev
))
1136 if ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1137 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1138 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1139 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
))))
1141 /* Decide whether this frame is eligible to be returned,
1142 according to minibuf. */
1145 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1148 else if (WINDOWP (minibuf
))
1150 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1151 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1152 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1153 FRAME_FOCUS_FRAME (XFRAME (f
))))
1156 else if (EQ (minibuf
, Qvisible
))
1158 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1159 if (FRAME_VISIBLE_P (XFRAME (f
)))
1162 else if (XFASTINT (minibuf
) == 0)
1164 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1165 if (FRAME_VISIBLE_P (XFRAME (f
))
1166 || FRAME_ICONIFIED_P (XFRAME (f
)))
1174 /* We've scanned the entire list. */
1176 /* We went through the whole frame list without finding a single
1177 acceptable frame. Return the original frame. */
1180 /* There were no acceptable frames in the list before FRAME; otherwise,
1181 we would have returned directly from the loop. Since PREV is the last
1182 acceptable frame in the list, return it. */
1187 DEFUN ("next-frame", Fnext_frame
, Snext_frame
, 0, 2, 0,
1188 doc
: /* Return the next frame in the frame list after FRAME.
1189 It considers only frames on the same terminal as FRAME.
1190 By default, skip minibuffer-only frames.
1191 If omitted, FRAME defaults to the selected frame.
1192 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1193 If MINIFRAME is a window, include only its own frame
1194 and any frame now using that window as the minibuffer.
1195 If MINIFRAME is `visible', include all visible frames.
1196 If MINIFRAME is 0, include all visible and iconified frames.
1197 Otherwise, include all frames. */)
1198 (Lisp_Object frame
, Lisp_Object miniframe
)
1201 frame
= selected_frame
;
1203 CHECK_LIVE_FRAME (frame
);
1204 return next_frame (frame
, miniframe
);
1207 DEFUN ("previous-frame", Fprevious_frame
, Sprevious_frame
, 0, 2, 0,
1208 doc
: /* Return the previous frame in the frame list before FRAME.
1209 It considers only frames on the same terminal as FRAME.
1210 By default, skip minibuffer-only frames.
1211 If omitted, FRAME defaults to the selected frame.
1212 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1213 If MINIFRAME is a window, include only its own frame
1214 and any frame now using that window as the minibuffer.
1215 If MINIFRAME is `visible', include all visible frames.
1216 If MINIFRAME is 0, include all visible and iconified frames.
1217 Otherwise, include all frames. */)
1218 (Lisp_Object frame
, Lisp_Object miniframe
)
1221 frame
= selected_frame
;
1222 CHECK_LIVE_FRAME (frame
);
1223 return prev_frame (frame
, miniframe
);
1226 /* Return 1 if it is ok to delete frame F;
1227 0 if all frames aside from F are invisible.
1228 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1231 other_visible_frames (FRAME_PTR f
)
1233 /* We know the selected frame is visible,
1234 so if F is some other frame, it can't be the sole visible one. */
1235 if (f
== SELECTED_FRAME ())
1240 for (frames
= Vframe_list
;
1242 frames
= XCDR (frames
))
1246 this = XCAR (frames
);
1247 /* Verify that the frame's window still exists
1248 and we can still talk to it. And note any recent change
1250 #ifdef HAVE_WINDOW_SYSTEM
1251 if (FRAME_WINDOW_P (XFRAME (this)))
1253 x_sync (XFRAME (this));
1254 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1258 if (FRAME_VISIBLE_P (XFRAME (this))
1259 || FRAME_ICONIFIED_P (XFRAME (this))
1260 /* Allow deleting the terminal frame when at least
1261 one X frame exists! */
1262 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f
)))
1270 /* Delete FRAME. When FORCE equals Qnoelisp, delete FRAME
1271 unconditionally. x_connection_closed and delete_terminal use
1272 this. Any other value of FORCE implements the semantics
1273 described for Fdelete_frame. */
1275 delete_frame (Lisp_Object frame
, Lisp_Object force
)
1276 /* If we use `register' here, gcc-4.0.2 on amd64 using
1277 -DUSE_LISP_UNION_TYPE complains further down that we're getting the
1278 address of `force'. Go figure. */
1282 struct frame
*sf
= SELECTED_FRAME ();
1285 int minibuffer_selected
, tooltip_frame
;
1287 if (EQ (frame
, Qnil
))
1290 XSETFRAME (frame
, f
);
1294 CHECK_FRAME (frame
);
1298 if (! FRAME_LIVE_P (f
))
1301 if (NILP (force
) && !other_visible_frames (f
))
1302 error ("Attempt to delete the sole visible or iconified frame");
1304 /* x_connection_closed must have set FORCE to `noelisp' in order
1305 to delete the last frame, if it is gone. */
1306 if (NILP (XCDR (Vframe_list
)) && !EQ (force
, Qnoelisp
))
1307 error ("Attempt to delete the only frame");
1309 /* Does this frame have a minibuffer, and is it the surrogate
1310 minibuffer for any other frame? */
1311 if (FRAME_HAS_MINIBUF_P (XFRAME (frame
)))
1315 for (frames
= Vframe_list
;
1317 frames
= XCDR (frames
))
1320 this = XCAR (frames
);
1322 if (! EQ (this, frame
)
1324 WINDOW_FRAME (XWINDOW
1325 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1327 /* If we MUST delete this frame, delete the other first.
1328 But do this only if FORCE equals `noelisp'. */
1329 if (EQ (force
, Qnoelisp
))
1330 delete_frame (this, Qnoelisp
);
1332 error ("Attempt to delete a surrogate minibuffer frame");
1337 tooltip_frame
= !NILP (Fframe_parameter (frame
, intern ("tooltip")));
1339 /* Run `delete-frame-functions' unless FORCE is `noelisp' or
1340 frame is a tooltip. FORCE is set to `noelisp' when handling
1341 a disconnect from the terminal, so we don't dare call Lisp
1343 if (NILP (Vrun_hooks
) || tooltip_frame
)
1345 else if (EQ (force
, Qnoelisp
))
1347 = Fcons (list3 (Qrun_hook_with_args
, Qdelete_frame_functions
, frame
),
1350 safe_call2 (Qrun_hook_with_args
, Qdelete_frame_functions
, frame
);
1352 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1353 if (! FRAME_LIVE_P (f
))
1356 /* At this point, we are committed to deleting the frame.
1357 There is no more chance for errors to prevent it. */
1359 minibuffer_selected
= EQ (minibuf_window
, selected_window
);
1361 /* Don't let the frame remain selected. */
1364 Lisp_Object tail
, frame1
;
1366 /* Look for another visible frame on the same terminal. */
1367 frame1
= next_frame (frame
, Qvisible
);
1369 /* If there is none, find *some* other frame. */
1370 if (NILP (frame1
) || EQ (frame1
, frame
))
1372 FOR_EACH_FRAME (tail
, frame1
)
1374 if (! EQ (frame
, frame1
) && FRAME_LIVE_P (XFRAME (frame1
)))
1378 #ifdef NS_IMPL_COCOA
1380 /* Under NS, there is no system mechanism for choosing a new
1381 window to get focus -- it is left to application code.
1382 So the portion of THIS application interfacing with NS
1383 needs to know about it. We call Fraise_frame, but the
1384 purpose is really to transfer focus. */
1385 Fraise_frame (frame1
);
1388 do_switch_frame (frame1
, 0, 1, Qnil
);
1389 sf
= SELECTED_FRAME ();
1392 /* Don't allow minibuf_window to remain on a deleted frame. */
1393 if (EQ (f
->minibuffer_window
, minibuf_window
))
1395 Fset_window_buffer (sf
->minibuffer_window
,
1396 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1397 minibuf_window
= sf
->minibuffer_window
;
1399 /* If the dying minibuffer window was selected,
1400 select the new one. */
1401 if (minibuffer_selected
)
1402 Fselect_window (minibuf_window
, Qnil
);
1405 /* Don't let echo_area_window to remain on a deleted frame. */
1406 if (EQ (f
->minibuffer_window
, echo_area_window
))
1407 echo_area_window
= sf
->minibuffer_window
;
1409 /* Clear any X selections for this frame. */
1410 #ifdef HAVE_X_WINDOWS
1412 x_clear_frame_selections (f
);
1416 This function must be called before the window tree of the
1417 frame is deleted because windows contain dynamically allocated
1421 #ifdef HAVE_WINDOW_SYSTEM
1422 /* Give chance to each font driver to free a frame specific data. */
1423 font_update_drivers (f
, Qnil
);
1426 /* Mark all the windows that used to be on FRAME as deleted, and then
1427 remove the reference to them. */
1428 delete_all_subwindows (XWINDOW (f
->root_window
));
1429 f
->root_window
= Qnil
;
1431 Vframe_list
= Fdelq (frame
, Vframe_list
);
1432 FRAME_SET_VISIBLE (f
, 0);
1434 /* Allow the vector of menu bar contents to be freed in the next
1435 garbage collection. The frame object itself may not be garbage
1436 collected until much later, because recent_keys and other data
1437 structures can still refer to it. */
1438 f
->menu_bar_vector
= Qnil
;
1440 free_font_driver_list (f
);
1442 xfree (f
->decode_mode_spec_buffer
);
1443 xfree (FRAME_INSERT_COST (f
));
1444 xfree (FRAME_DELETEN_COST (f
));
1445 xfree (FRAME_INSERTN_COST (f
));
1446 xfree (FRAME_DELETE_COST (f
));
1447 xfree (FRAME_MESSAGE_BUF (f
));
1449 /* Since some events are handled at the interrupt level, we may get
1450 an event for f at any time; if we zero out the frame's terminal
1451 now, then we may trip up the event-handling code. Instead, we'll
1452 promise that the terminal of the frame must be valid until we
1453 have called the window-system-dependent frame destruction
1456 if (FRAME_TERMINAL (f
)->delete_frame_hook
)
1457 (*FRAME_TERMINAL (f
)->delete_frame_hook
) (f
);
1460 struct terminal
*terminal
= FRAME_TERMINAL (f
);
1461 f
->output_data
.nothing
= 0;
1462 f
->terminal
= 0; /* Now the frame is dead. */
1464 /* If needed, delete the terminal that this frame was on.
1465 (This must be done after the frame is killed.) */
1466 terminal
->reference_count
--;
1467 if (terminal
->reference_count
== 0)
1470 XSETTERMINAL (tmp
, terminal
);
1473 Fdelete_terminal (tmp
, NILP (force
) ? Qt
: force
);
1476 kb
= terminal
->kboard
;
1479 /* If we've deleted the last_nonminibuf_frame, then try to find
1481 if (f
== last_nonminibuf_frame
)
1485 last_nonminibuf_frame
= 0;
1487 for (frames
= Vframe_list
;
1489 frames
= XCDR (frames
))
1491 f
= XFRAME (XCAR (frames
));
1492 if (!FRAME_MINIBUF_ONLY_P (f
))
1494 last_nonminibuf_frame
= f
;
1500 /* If there's no other frame on the same kboard, get out of
1501 single-kboard state if we're in it for this kboard. */
1505 /* Some frame we found on the same kboard, or nil if there are none. */
1506 Lisp_Object frame_on_same_kboard
;
1508 frame_on_same_kboard
= Qnil
;
1510 for (frames
= Vframe_list
;
1512 frames
= XCDR (frames
))
1517 this = XCAR (frames
);
1522 if (kb
== FRAME_KBOARD (f1
))
1523 frame_on_same_kboard
= this;
1526 if (NILP (frame_on_same_kboard
))
1527 not_single_kboard_state (kb
);
1531 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1532 find another one. Prefer minibuffer-only frames, but also notice
1533 frames with other windows. */
1534 if (kb
!= NULL
&& EQ (frame
, KVAR (kb
, Vdefault_minibuffer_frame
)))
1538 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1539 Lisp_Object frame_with_minibuf
;
1540 /* Some frame we found on the same kboard, or nil if there are none. */
1541 Lisp_Object frame_on_same_kboard
;
1543 frame_on_same_kboard
= Qnil
;
1544 frame_with_minibuf
= Qnil
;
1546 for (frames
= Vframe_list
;
1548 frames
= XCDR (frames
))
1553 this = XCAR (frames
);
1558 /* Consider only frames on the same kboard
1559 and only those with minibuffers. */
1560 if (kb
== FRAME_KBOARD (f1
)
1561 && FRAME_HAS_MINIBUF_P (f1
))
1563 frame_with_minibuf
= this;
1564 if (FRAME_MINIBUF_ONLY_P (f1
))
1568 if (kb
== FRAME_KBOARD (f1
))
1569 frame_on_same_kboard
= this;
1572 if (!NILP (frame_on_same_kboard
))
1574 /* We know that there must be some frame with a minibuffer out
1575 there. If this were not true, all of the frames present
1576 would have to be minibufferless, which implies that at some
1577 point their minibuffer frames must have been deleted, but
1578 that is prohibited at the top; you can't delete surrogate
1579 minibuffer frames. */
1580 if (NILP (frame_with_minibuf
))
1583 KVAR (kb
, Vdefault_minibuffer_frame
) = frame_with_minibuf
;
1586 /* No frames left on this kboard--say no minibuffer either. */
1587 KVAR (kb
, Vdefault_minibuffer_frame
) = Qnil
;
1590 /* Cause frame titles to update--necessary if we now have just one frame. */
1592 update_mode_lines
= 1;
1597 DEFUN ("delete-frame", Fdelete_frame
, Sdelete_frame
, 0, 2, "",
1598 doc
: /* Delete FRAME, permanently eliminating it from use.
1599 FRAME defaults to the selected frame.
1601 A frame may not be deleted if its minibuffer is used by other frames.
1602 Normally, you may not delete a frame if all other frames are invisible,
1603 but if the second optional argument FORCE is non-nil, you may do so.
1605 This function runs `delete-frame-functions' before actually
1606 deleting the frame, unless the frame is a tooltip.
1607 The functions are run with one argument, the frame to be deleted. */)
1608 (Lisp_Object frame
, Lisp_Object force
)
1610 return delete_frame (frame
, !NILP (force
) ? Qt
: Qnil
);
1614 /* Return mouse position in character cell units. */
1616 DEFUN ("mouse-position", Fmouse_position
, Smouse_position
, 0, 0, 0,
1617 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1618 The position is given in character cells, where (0, 0) is the
1619 upper-left corner of the frame, X is the horizontal offset, and Y is
1620 the vertical offset.
1621 If Emacs is running on a mouseless terminal or hasn't been programmed
1622 to read the mouse position, it returns the selected frame for FRAME
1623 and nil for X and Y.
1624 If `mouse-position-function' is non-nil, `mouse-position' calls it,
1625 passing the normal return value to that function as an argument,
1626 and returns whatever that function returns. */)
1630 Lisp_Object lispy_dummy
;
1631 enum scroll_bar_part party_dummy
;
1632 Lisp_Object x
, y
, retval
;
1634 unsigned long long_dummy
;
1635 struct gcpro gcpro1
;
1637 f
= SELECTED_FRAME ();
1640 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1641 /* It's okay for the hook to refrain from storing anything. */
1642 if (FRAME_TERMINAL (f
)->mouse_position_hook
)
1643 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, -1,
1644 &lispy_dummy
, &party_dummy
,
1651 pixel_to_glyph_coords (f
, col
, row
, &col
, &row
, NULL
, 1);
1656 XSETFRAME (lispy_dummy
, f
);
1657 retval
= Fcons (lispy_dummy
, Fcons (x
, y
));
1659 if (!NILP (Vmouse_position_function
))
1660 retval
= call1 (Vmouse_position_function
, retval
);
1661 RETURN_UNGCPRO (retval
);
1664 DEFUN ("mouse-pixel-position", Fmouse_pixel_position
,
1665 Smouse_pixel_position
, 0, 0, 0,
1666 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1667 The position is given in pixel units, where (0, 0) is the
1668 upper-left corner of the frame, X is the horizontal offset, and Y is
1669 the vertical offset.
1670 If Emacs is running on a mouseless terminal or hasn't been programmed
1671 to read the mouse position, it returns the selected frame for FRAME
1672 and nil for X and Y. */)
1676 Lisp_Object lispy_dummy
;
1677 enum scroll_bar_part party_dummy
;
1679 unsigned long long_dummy
;
1681 f
= SELECTED_FRAME ();
1684 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1685 /* It's okay for the hook to refrain from storing anything. */
1686 if (FRAME_TERMINAL (f
)->mouse_position_hook
)
1687 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, -1,
1688 &lispy_dummy
, &party_dummy
,
1692 XSETFRAME (lispy_dummy
, f
);
1693 return Fcons (lispy_dummy
, Fcons (x
, y
));
1696 DEFUN ("set-mouse-position", Fset_mouse_position
, Sset_mouse_position
, 3, 3, 0,
1697 doc
: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1698 Coordinates are relative to the frame, not a window,
1699 so the coordinates of the top left character in the frame
1700 may be nonzero due to left-hand scroll bars or the menu bar.
1702 The position is given in character cells, where (0, 0) is the
1703 upper-left corner of the frame, X is the horizontal offset, and Y is
1704 the vertical offset.
1706 This function is a no-op for an X frame that is not visible.
1707 If you have just created a frame, you must wait for it to become visible
1708 before calling this function on it, like this.
1709 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1710 (Lisp_Object frame
, Lisp_Object x
, Lisp_Object y
)
1712 CHECK_LIVE_FRAME (frame
);
1716 /* I think this should be done with a hook. */
1717 #ifdef HAVE_WINDOW_SYSTEM
1718 if (FRAME_WINDOW_P (XFRAME (frame
)))
1719 /* Warping the mouse will cause enternotify and focus events. */
1720 x_set_mouse_position (XFRAME (frame
), XINT (x
), XINT (y
));
1722 #if defined (MSDOS) && defined (HAVE_MOUSE)
1723 if (FRAME_MSDOS_P (XFRAME (frame
)))
1725 Fselect_frame (frame
, Qnil
);
1726 mouse_moveto (XINT (x
), XINT (y
));
1731 Fselect_frame (frame
, Qnil
);
1732 term_mouse_moveto (XINT (x
), XINT (y
));
1741 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position
,
1742 Sset_mouse_pixel_position
, 3, 3, 0,
1743 doc
: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
1744 The position is given in pixels, where (0, 0) is the upper-left corner
1745 of the frame, X is the horizontal offset, and Y is the vertical offset.
1747 Note, this is a no-op for an X frame that is not visible.
1748 If you have just created a frame, you must wait for it to become visible
1749 before calling this function on it, like this.
1750 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1751 (Lisp_Object frame
, Lisp_Object x
, Lisp_Object y
)
1753 CHECK_LIVE_FRAME (frame
);
1757 /* I think this should be done with a hook. */
1758 #ifdef HAVE_WINDOW_SYSTEM
1759 if (FRAME_WINDOW_P (XFRAME (frame
)))
1760 /* Warping the mouse will cause enternotify and focus events. */
1761 x_set_mouse_pixel_position (XFRAME (frame
), XINT (x
), XINT (y
));
1763 #if defined (MSDOS) && defined (HAVE_MOUSE)
1764 if (FRAME_MSDOS_P (XFRAME (frame
)))
1766 Fselect_frame (frame
, Qnil
);
1767 mouse_moveto (XINT (x
), XINT (y
));
1772 Fselect_frame (frame
, Qnil
);
1773 term_mouse_moveto (XINT (x
), XINT (y
));
1782 static void make_frame_visible_1 (Lisp_Object
);
1784 DEFUN ("make-frame-visible", Fmake_frame_visible
, Smake_frame_visible
,
1786 doc
: /* Make the frame FRAME visible (assuming it is an X window).
1787 If omitted, FRAME defaults to the currently selected frame. */)
1791 frame
= selected_frame
;
1793 CHECK_LIVE_FRAME (frame
);
1795 /* I think this should be done with a hook. */
1796 #ifdef HAVE_WINDOW_SYSTEM
1797 if (FRAME_WINDOW_P (XFRAME (frame
)))
1799 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1800 x_make_frame_visible (XFRAME (frame
));
1804 make_frame_visible_1 (XFRAME (frame
)->root_window
);
1806 /* Make menu bar update for the Buffers and Frames menus. */
1807 windows_or_buffers_changed
++;
1812 /* Update the display_time slot of the buffers shown in WINDOW
1813 and all its descendents. */
1816 make_frame_visible_1 (Lisp_Object window
)
1820 for (;!NILP (window
); window
= w
->next
)
1822 w
= XWINDOW (window
);
1824 if (!NILP (w
->buffer
))
1825 BVAR (XBUFFER (w
->buffer
), display_time
) = Fcurrent_time ();
1827 if (!NILP (w
->vchild
))
1828 make_frame_visible_1 (w
->vchild
);
1829 if (!NILP (w
->hchild
))
1830 make_frame_visible_1 (w
->hchild
);
1834 DEFUN ("make-frame-invisible", Fmake_frame_invisible
, Smake_frame_invisible
,
1836 doc
: /* Make the frame FRAME invisible.
1837 If omitted, FRAME defaults to the currently selected frame.
1838 On graphical displays, invisible frames are not updated and are
1839 usually not displayed at all, even in a window system's \"taskbar\".
1841 Normally you may not make FRAME invisible if all other frames are invisible,
1842 but if the second optional argument FORCE is non-nil, you may do so.
1844 This function has no effect on text-only terminal frames. Such frames
1845 are always considered visible, whether or not they are currently being
1846 displayed in the terminal. */)
1847 (Lisp_Object frame
, Lisp_Object force
)
1850 frame
= selected_frame
;
1852 CHECK_LIVE_FRAME (frame
);
1854 if (NILP (force
) && !other_visible_frames (XFRAME (frame
)))
1855 error ("Attempt to make invisible the sole visible or iconified frame");
1857 #if 0 /* This isn't logically necessary, and it can do GC. */
1858 /* Don't let the frame remain selected. */
1859 if (EQ (frame
, selected_frame
))
1860 do_switch_frame (next_frame (frame
, Qt
), 0, 0, Qnil
)
1863 /* Don't allow minibuf_window to remain on a deleted frame. */
1864 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1866 struct frame
*sf
= XFRAME (selected_frame
);
1867 Fset_window_buffer (sf
->minibuffer_window
,
1868 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1869 minibuf_window
= sf
->minibuffer_window
;
1872 /* I think this should be done with a hook. */
1873 #ifdef HAVE_WINDOW_SYSTEM
1874 if (FRAME_WINDOW_P (XFRAME (frame
)))
1875 x_make_frame_invisible (XFRAME (frame
));
1878 /* Make menu bar update for the Buffers and Frames menus. */
1879 windows_or_buffers_changed
++;
1884 DEFUN ("iconify-frame", Ficonify_frame
, Siconify_frame
,
1886 doc
: /* Make the frame FRAME into an icon.
1887 If omitted, FRAME defaults to the currently selected frame. */)
1891 frame
= selected_frame
;
1893 CHECK_LIVE_FRAME (frame
);
1895 #if 0 /* This isn't logically necessary, and it can do GC. */
1896 /* Don't let the frame remain selected. */
1897 if (EQ (frame
, selected_frame
))
1898 Fhandle_switch_frame (next_frame (frame
, Qt
));
1901 /* Don't allow minibuf_window to remain on a deleted frame. */
1902 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1904 struct frame
*sf
= XFRAME (selected_frame
);
1905 Fset_window_buffer (sf
->minibuffer_window
,
1906 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1907 minibuf_window
= sf
->minibuffer_window
;
1910 /* I think this should be done with a hook. */
1911 #ifdef HAVE_WINDOW_SYSTEM
1912 if (FRAME_WINDOW_P (XFRAME (frame
)))
1913 x_iconify_frame (XFRAME (frame
));
1916 /* Make menu bar update for the Buffers and Frames menus. */
1917 windows_or_buffers_changed
++;
1922 DEFUN ("frame-visible-p", Fframe_visible_p
, Sframe_visible_p
,
1924 doc
: /* Return t if FRAME is \"visible\" (actually in use for display).
1925 Return the symbol `icon' if FRAME is iconified or \"minimized\".
1926 Return nil if FRAME was made invisible, via `make-frame-invisible'.
1927 On graphical displays, invisible frames are not updated and are
1928 usually not displayed at all, even in a window system's \"taskbar\".
1930 If FRAME is a text-only terminal frame, this always returns t.
1931 Such frames are always considered visible, whether or not they are
1932 currently being displayed on the terminal. */)
1935 CHECK_LIVE_FRAME (frame
);
1937 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1939 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1941 if (FRAME_ICONIFIED_P (XFRAME (frame
)))
1946 DEFUN ("visible-frame-list", Fvisible_frame_list
, Svisible_frame_list
,
1948 doc
: /* Return a list of all frames now \"visible\" (being updated). */)
1951 Lisp_Object tail
, frame
;
1956 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1958 frame
= XCAR (tail
);
1959 if (!FRAMEP (frame
))
1962 if (FRAME_VISIBLE_P (f
))
1963 value
= Fcons (frame
, value
);
1969 DEFUN ("raise-frame", Fraise_frame
, Sraise_frame
, 0, 1, "",
1970 doc
: /* Bring FRAME to the front, so it occludes any frames it overlaps.
1971 If FRAME is invisible or iconified, make it visible.
1972 If you don't specify a frame, the selected frame is used.
1973 If Emacs is displaying on an ordinary terminal or some other device which
1974 doesn't support multiple overlapping frames, this function selects FRAME. */)
1979 frame
= selected_frame
;
1981 CHECK_LIVE_FRAME (frame
);
1985 if (FRAME_TERMCAP_P (f
))
1986 /* On a text-only terminal select FRAME. */
1987 Fselect_frame (frame
, Qnil
);
1989 /* Do like the documentation says. */
1990 Fmake_frame_visible (frame
);
1992 if (FRAME_TERMINAL (f
)->frame_raise_lower_hook
)
1993 (*FRAME_TERMINAL (f
)->frame_raise_lower_hook
) (f
, 1);
1998 /* Should we have a corresponding function called Flower_Power? */
1999 DEFUN ("lower-frame", Flower_frame
, Slower_frame
, 0, 1, "",
2000 doc
: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2001 If you don't specify a frame, the selected frame is used.
2002 If Emacs is displaying on an ordinary terminal or some other device which
2003 doesn't support multiple overlapping frames, this function does nothing. */)
2009 frame
= selected_frame
;
2011 CHECK_LIVE_FRAME (frame
);
2015 if (FRAME_TERMINAL (f
)->frame_raise_lower_hook
)
2016 (*FRAME_TERMINAL (f
)->frame_raise_lower_hook
) (f
, 0);
2022 DEFUN ("redirect-frame-focus", Fredirect_frame_focus
, Sredirect_frame_focus
,
2024 doc
: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2025 In other words, switch-frame events caused by events in FRAME will
2026 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2027 FOCUS-FRAME after reading an event typed at FRAME.
2029 If FOCUS-FRAME is omitted or nil, any existing redirection is
2030 cancelled, and the frame again receives its own keystrokes.
2032 Focus redirection is useful for temporarily redirecting keystrokes to
2033 a surrogate minibuffer frame when a frame doesn't have its own
2036 A frame's focus redirection can be changed by `select-frame'. If frame
2037 FOO is selected, and then a different frame BAR is selected, any
2038 frames redirecting their focus to FOO are shifted to redirect their
2039 focus to BAR. This allows focus redirection to work properly when the
2040 user switches from one frame to another using `select-window'.
2042 This means that a frame whose focus is redirected to itself is treated
2043 differently from a frame whose focus is redirected to nil; the former
2044 is affected by `select-frame', while the latter is not.
2046 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2047 (Lisp_Object frame
, Lisp_Object focus_frame
)
2051 /* Note that we don't check for a live frame here. It's reasonable
2052 to redirect the focus of a frame you're about to delete, if you
2053 know what other frame should receive those keystrokes. */
2054 CHECK_FRAME (frame
);
2056 if (! NILP (focus_frame
))
2057 CHECK_LIVE_FRAME (focus_frame
);
2061 f
->focus_frame
= focus_frame
;
2063 if (FRAME_TERMINAL (f
)->frame_rehighlight_hook
)
2064 (*FRAME_TERMINAL (f
)->frame_rehighlight_hook
) (f
);
2070 DEFUN ("frame-focus", Fframe_focus
, Sframe_focus
, 1, 1, 0,
2071 doc
: /* Return the frame to which FRAME's keystrokes are currently being sent.
2072 This returns nil if FRAME's focus is not redirected.
2073 See `redirect-frame-focus'. */)
2076 CHECK_LIVE_FRAME (frame
);
2078 return FRAME_FOCUS_FRAME (XFRAME (frame
));
2083 /* Return the value of frame parameter PROP in frame FRAME. */
2089 get_frame_param (register struct frame
*frame
, Lisp_Object prop
)
2091 register Lisp_Object tem
;
2093 tem
= Fassq (prop
, frame
->param_alist
);
2099 /* Return the buffer-predicate of the selected frame. */
2102 frame_buffer_predicate (Lisp_Object frame
)
2104 return XFRAME (frame
)->buffer_predicate
;
2107 /* Return the buffer-list of the selected frame. */
2110 frame_buffer_list (Lisp_Object frame
)
2112 return XFRAME (frame
)->buffer_list
;
2115 /* Set the buffer-list of the selected frame. */
2118 set_frame_buffer_list (Lisp_Object frame
, Lisp_Object list
)
2120 XFRAME (frame
)->buffer_list
= list
;
2123 /* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
2126 frames_discard_buffer (Lisp_Object buffer
)
2128 Lisp_Object frame
, tail
;
2130 FOR_EACH_FRAME (tail
, frame
)
2132 XFRAME (frame
)->buffer_list
2133 = Fdelq (buffer
, XFRAME (frame
)->buffer_list
);
2134 XFRAME (frame
)->buried_buffer_list
2135 = Fdelq (buffer
, XFRAME (frame
)->buried_buffer_list
);
2139 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2140 If the alist already has an element for PROP, we change it. */
2143 store_in_alist (Lisp_Object
*alistptr
, Lisp_Object prop
, Lisp_Object val
)
2145 register Lisp_Object tem
;
2147 tem
= Fassq (prop
, *alistptr
);
2149 *alistptr
= Fcons (Fcons (prop
, val
), *alistptr
);
2155 frame_name_fnn_p (char *str
, EMACS_INT len
)
2157 if (len
> 1 && str
[0] == 'F' && '0' <= str
[1] && str
[1] <= '9')
2160 while ('0' <= *p
&& *p
<= '9')
2169 /* Set the name of the terminal frame. Also used by MSDOS frames.
2170 Modeled after x_set_name which is used for WINDOW frames. */
2173 set_term_frame_name (struct frame
*f
, Lisp_Object name
)
2175 f
->explicit_name
= ! NILP (name
);
2177 /* If NAME is nil, set the name to F<num>. */
2182 /* Check for no change needed in this very common case
2183 before we do any consing. */
2184 if (frame_name_fnn_p (SSDATA (f
->name
),
2189 sprintf (namebuf
, "F%d", tty_frame_count
);
2190 name
= build_string (namebuf
);
2194 CHECK_STRING (name
);
2196 /* Don't change the name if it's already NAME. */
2197 if (! NILP (Fstring_equal (name
, f
->name
)))
2200 /* Don't allow the user to set the frame name to F<num>, so it
2201 doesn't clash with the names we generate for terminal frames. */
2202 if (frame_name_fnn_p (SSDATA (name
), SBYTES (name
)))
2203 error ("Frame names of the form F<num> are usurped by Emacs");
2207 update_mode_lines
= 1;
2211 store_frame_param (struct frame
*f
, Lisp_Object prop
, Lisp_Object val
)
2213 register Lisp_Object old_alist_elt
;
2215 /* The buffer-list parameters are stored in a special place and not
2216 in the alist. All buffers must be live. */
2217 if (EQ (prop
, Qbuffer_list
))
2219 Lisp_Object list
= Qnil
;
2220 for (; CONSP (val
); val
= XCDR (val
))
2221 if (!NILP (Fbuffer_live_p (XCAR (val
))))
2222 list
= Fcons (XCAR (val
), list
);
2223 f
->buffer_list
= Fnreverse (list
);
2226 if (EQ (prop
, Qburied_buffer_list
))
2228 Lisp_Object list
= Qnil
;
2229 for (; CONSP (val
); val
= XCDR (val
))
2230 if (!NILP (Fbuffer_live_p (XCAR (val
))))
2231 list
= Fcons (XCAR (val
), list
);
2232 f
->buried_buffer_list
= Fnreverse (list
);
2236 /* If PROP is a symbol which is supposed to have frame-local values,
2237 and it is set up based on this frame, switch to the global
2238 binding. That way, we can create or alter the frame-local binding
2239 without messing up the symbol's status. */
2242 struct Lisp_Symbol
*sym
= XSYMBOL (prop
);
2244 switch (sym
->redirect
)
2246 case SYMBOL_VARALIAS
: sym
= indirect_variable (sym
); goto start
;
2247 case SYMBOL_PLAINVAL
: case SYMBOL_FORWARDED
: break;
2248 case SYMBOL_LOCALIZED
:
2249 { struct Lisp_Buffer_Local_Value
*blv
= sym
->val
.blv
;
2250 if (blv
->frame_local
&& BLV_FOUND (blv
) && XFRAME (blv
->where
) == f
)
2251 swap_in_global_binding (sym
);
2258 /* The tty color needed to be set before the frame's parameter
2259 alist was updated with the new value. This is not true any more,
2260 but we still do this test early on. */
2261 if (FRAME_TERMCAP_P (f
) && EQ (prop
, Qtty_color_mode
)
2262 && f
== FRAME_TTY (f
)->previous_frame
)
2263 /* Force redisplay of this tty. */
2264 FRAME_TTY (f
)->previous_frame
= NULL
;
2266 /* Update the frame parameter alist. */
2267 old_alist_elt
= Fassq (prop
, f
->param_alist
);
2268 if (EQ (old_alist_elt
, Qnil
))
2269 f
->param_alist
= Fcons (Fcons (prop
, val
), f
->param_alist
);
2271 Fsetcdr (old_alist_elt
, val
);
2273 /* Update some other special parameters in their special places
2274 in addition to the alist. */
2276 if (EQ (prop
, Qbuffer_predicate
))
2277 f
->buffer_predicate
= val
;
2279 if (! FRAME_WINDOW_P (f
))
2281 if (EQ (prop
, Qmenu_bar_lines
))
2282 set_menu_bar_lines (f
, val
, make_number (FRAME_MENU_BAR_LINES (f
)));
2283 else if (EQ (prop
, Qname
))
2284 set_term_frame_name (f
, val
);
2287 if (EQ (prop
, Qminibuffer
) && WINDOWP (val
))
2289 if (! MINI_WINDOW_P (XWINDOW (val
)))
2290 error ("Surrogate minibuffer windows must be minibuffer windows");
2292 if ((FRAME_HAS_MINIBUF_P (f
) || FRAME_MINIBUF_ONLY_P (f
))
2293 && !EQ (val
, f
->minibuffer_window
))
2294 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2296 /* Install the chosen minibuffer window, with proper buffer. */
2297 f
->minibuffer_window
= val
;
2301 DEFUN ("frame-parameters", Fframe_parameters
, Sframe_parameters
, 0, 1, 0,
2302 doc
: /* Return the parameters-alist of frame FRAME.
2303 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2304 The meaningful PARMs depend on the kind of frame.
2305 If FRAME is omitted, return information on the currently selected frame. */)
2311 struct gcpro gcpro1
;
2314 frame
= selected_frame
;
2316 CHECK_FRAME (frame
);
2319 if (!FRAME_LIVE_P (f
))
2322 alist
= Fcopy_alist (f
->param_alist
);
2325 if (!FRAME_WINDOW_P (f
))
2327 int fg
= FRAME_FOREGROUND_PIXEL (f
);
2328 int bg
= FRAME_BACKGROUND_PIXEL (f
);
2331 /* If the frame's parameter alist says the colors are
2332 unspecified and reversed, take the frame's background pixel
2333 for foreground and vice versa. */
2334 elt
= Fassq (Qforeground_color
, alist
);
2335 if (CONSP (elt
) && STRINGP (XCDR (elt
)))
2337 if (strncmp (SSDATA (XCDR (elt
)),
2339 SCHARS (XCDR (elt
))) == 0)
2340 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, bg
));
2341 else if (strncmp (SSDATA (XCDR (elt
)),
2343 SCHARS (XCDR (elt
))) == 0)
2344 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2347 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2348 elt
= Fassq (Qbackground_color
, alist
);
2349 if (CONSP (elt
) && STRINGP (XCDR (elt
)))
2351 if (strncmp (SSDATA (XCDR (elt
)),
2353 SCHARS (XCDR (elt
))) == 0)
2354 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, fg
));
2355 else if (strncmp (SSDATA (XCDR (elt
)),
2357 SCHARS (XCDR (elt
))) == 0)
2358 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2361 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2362 store_in_alist (&alist
, intern ("font"),
2363 build_string (FRAME_MSDOS_P (f
)
2365 : FRAME_W32_P (f
) ? "w32term"
2368 store_in_alist (&alist
, Qname
, f
->name
);
2369 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2370 store_in_alist (&alist
, Qheight
, make_number (height
));
2371 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2372 store_in_alist (&alist
, Qwidth
, make_number (width
));
2373 store_in_alist (&alist
, Qmodeline
, (FRAME_WANTS_MODELINE_P (f
) ? Qt
: Qnil
));
2374 store_in_alist (&alist
, Qminibuffer
,
2375 (! FRAME_HAS_MINIBUF_P (f
) ? Qnil
2376 : FRAME_MINIBUF_ONLY_P (f
) ? Qonly
2377 : FRAME_MINIBUF_WINDOW (f
)));
2378 store_in_alist (&alist
, Qunsplittable
, (FRAME_NO_SPLIT_P (f
) ? Qt
: Qnil
));
2379 store_in_alist (&alist
, Qbuffer_list
, frame_buffer_list (frame
));
2380 store_in_alist (&alist
, Qburied_buffer_list
, XFRAME (frame
)->buried_buffer_list
);
2382 /* I think this should be done with a hook. */
2383 #ifdef HAVE_WINDOW_SYSTEM
2384 if (FRAME_WINDOW_P (f
))
2385 x_report_frame_params (f
, &alist
);
2389 /* This ought to be correct in f->param_alist for an X frame. */
2391 XSETFASTINT (lines
, FRAME_MENU_BAR_LINES (f
));
2392 store_in_alist (&alist
, Qmenu_bar_lines
, lines
);
2400 DEFUN ("frame-parameter", Fframe_parameter
, Sframe_parameter
, 2, 2, 0,
2401 doc
: /* Return FRAME's value for parameter PARAMETER.
2402 If FRAME is nil, describe the currently selected frame. */)
2403 (Lisp_Object frame
, Lisp_Object parameter
)
2409 frame
= selected_frame
;
2411 CHECK_FRAME (frame
);
2412 CHECK_SYMBOL (parameter
);
2417 if (FRAME_LIVE_P (f
))
2419 /* Avoid consing in frequent cases. */
2420 if (EQ (parameter
, Qname
))
2422 #ifdef HAVE_X_WINDOWS
2423 else if (EQ (parameter
, Qdisplay
) && FRAME_X_P (f
))
2424 value
= XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
);
2425 #endif /* HAVE_X_WINDOWS */
2426 else if (EQ (parameter
, Qbackground_color
)
2427 || EQ (parameter
, Qforeground_color
))
2429 value
= Fassq (parameter
, f
->param_alist
);
2432 value
= XCDR (value
);
2433 /* Fframe_parameters puts the actual fg/bg color names,
2434 even if f->param_alist says otherwise. This is
2435 important when param_alist's notion of colors is
2436 "unspecified". We need to do the same here. */
2437 if (STRINGP (value
) && !FRAME_WINDOW_P (f
))
2439 const char *color_name
;
2442 if (EQ (parameter
, Qbackground_color
))
2444 color_name
= SSDATA (value
);
2445 csz
= SCHARS (value
);
2446 if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2447 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2448 else if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2449 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2451 else if (EQ (parameter
, Qforeground_color
))
2453 color_name
= SSDATA (value
);
2454 csz
= SCHARS (value
);
2455 if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2456 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2457 else if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2458 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2463 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2465 else if (EQ (parameter
, Qdisplay_type
)
2466 || EQ (parameter
, Qbackground_mode
))
2467 value
= Fcdr (Fassq (parameter
, f
->param_alist
));
2469 /* FIXME: Avoid this code path at all (as well as code duplication)
2470 by sharing more code with Fframe_parameters. */
2471 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2478 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters
,
2479 Smodify_frame_parameters
, 2, 2, 0,
2480 doc
: /* Modify the parameters of frame FRAME according to ALIST.
2481 If FRAME is nil, it defaults to the selected frame.
2482 ALIST is an alist of parameters to change and their new values.
2483 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2484 The meaningful PARMs depend on the kind of frame.
2485 Undefined PARMs are ignored, but stored in the frame's parameter list
2486 so that `frame-parameters' will return them.
2488 The value of frame parameter FOO can also be accessed
2489 as a frame-local binding for the variable FOO, if you have
2490 enabled such bindings for that variable with `make-variable-frame-local'.
2491 Note that this functionality is obsolete as of Emacs 22.2, and its
2492 use is not recommended. Explicitly check for a frame-parameter instead. */)
2493 (Lisp_Object frame
, Lisp_Object alist
)
2496 register Lisp_Object tail
, prop
, val
;
2498 if (EQ (frame
, Qnil
))
2499 frame
= selected_frame
;
2500 CHECK_LIVE_FRAME (frame
);
2503 /* I think this should be done with a hook. */
2504 #ifdef HAVE_WINDOW_SYSTEM
2505 if (FRAME_WINDOW_P (f
))
2506 x_set_frame_parameters (f
, alist
);
2510 if (FRAME_MSDOS_P (f
))
2511 IT_set_frame_parameters (f
, alist
);
2516 int length
= XINT (Flength (alist
));
2519 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2521 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2523 /* Extract parm names and values into those vectors. */
2526 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
2531 parms
[i
] = Fcar (elt
);
2532 values
[i
] = Fcdr (elt
);
2536 /* Now process them in reverse of specified order. */
2541 store_frame_param (f
, prop
, val
);
2543 /* Changing the background color might change the background
2544 mode, so that we have to load new defface specs.
2545 Call frame-set-background-mode to do that. */
2546 if (EQ (prop
, Qbackground_color
))
2547 call1 (Qframe_set_background_mode
, frame
);
2553 DEFUN ("frame-char-height", Fframe_char_height
, Sframe_char_height
,
2555 doc
: /* Height in pixels of a line in the font in frame FRAME.
2556 If FRAME is omitted, the selected frame is used.
2557 For a terminal frame, the value is always 1. */)
2563 frame
= selected_frame
;
2564 CHECK_FRAME (frame
);
2567 #ifdef HAVE_WINDOW_SYSTEM
2568 if (FRAME_WINDOW_P (f
))
2569 return make_number (x_char_height (f
));
2572 return make_number (1);
2576 DEFUN ("frame-char-width", Fframe_char_width
, Sframe_char_width
,
2578 doc
: /* Width in pixels of characters in the font in frame FRAME.
2579 If FRAME is omitted, the selected frame is used.
2580 On a graphical screen, the width is the standard width of the default font.
2581 For a terminal screen, the value is always 1. */)
2587 frame
= selected_frame
;
2588 CHECK_FRAME (frame
);
2591 #ifdef HAVE_WINDOW_SYSTEM
2592 if (FRAME_WINDOW_P (f
))
2593 return make_number (x_char_width (f
));
2596 return make_number (1);
2599 DEFUN ("frame-pixel-height", Fframe_pixel_height
,
2600 Sframe_pixel_height
, 0, 1, 0,
2601 doc
: /* Return a FRAME's height in pixels.
2602 If FRAME is omitted, the selected frame is used. The exact value
2603 of the result depends on the window-system and toolkit in use:
2605 In the Gtk+ version of Emacs, it includes only any window (including
2606 the minibuffer or eacho area), mode line, and header line. It does not
2607 include the tool bar or menu bar.
2609 With the Motif or Lucid toolkits, it also includes the tool bar (but
2612 In a graphical version with no toolkit, it includes both the tool bar
2615 For a text-only terminal, it includes the menu bar. In this case, the
2616 result is really in characters rather than pixels (i.e., is identical
2617 to `frame-height'). */)
2623 frame
= selected_frame
;
2624 CHECK_FRAME (frame
);
2627 #ifdef HAVE_WINDOW_SYSTEM
2628 if (FRAME_WINDOW_P (f
))
2629 return make_number (x_pixel_height (f
));
2632 return make_number (FRAME_LINES (f
));
2635 DEFUN ("frame-pixel-width", Fframe_pixel_width
,
2636 Sframe_pixel_width
, 0, 1, 0,
2637 doc
: /* Return FRAME's width in pixels.
2638 For a terminal frame, the result really gives the width in characters.
2639 If FRAME is omitted, the selected frame is used. */)
2645 frame
= selected_frame
;
2646 CHECK_FRAME (frame
);
2649 #ifdef HAVE_WINDOW_SYSTEM
2650 if (FRAME_WINDOW_P (f
))
2651 return make_number (x_pixel_width (f
));
2654 return make_number (FRAME_COLS (f
));
2657 DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width
,
2658 Stool_bar_pixel_width
, 0, 1, 0,
2659 doc
: /* Return width in pixels of FRAME's tool bar.
2660 The result is greater than zero only when the tool bar is on the left
2661 or right side of FRAME. If FRAME is omitted, the selected frame is
2668 frame
= selected_frame
;
2669 CHECK_FRAME (frame
);
2672 #ifdef FRAME_TOOLBAR_WIDTH
2673 if (FRAME_WINDOW_P (f
))
2674 return make_number (FRAME_TOOLBAR_WIDTH (f
));
2676 return make_number (0);
2679 DEFUN ("set-frame-height", Fset_frame_height
, Sset_frame_height
, 2, 3, 0,
2680 doc
: /* Specify that the frame FRAME has LINES lines.
2681 Optional third arg non-nil means that redisplay should use LINES lines
2682 but that the idea of the actual height of the frame should not be changed. */)
2683 (Lisp_Object frame
, Lisp_Object lines
, Lisp_Object pretend
)
2685 register struct frame
*f
;
2687 CHECK_NUMBER (lines
);
2689 frame
= selected_frame
;
2690 CHECK_LIVE_FRAME (frame
);
2693 /* I think this should be done with a hook. */
2694 #ifdef HAVE_WINDOW_SYSTEM
2695 if (FRAME_WINDOW_P (f
))
2697 if (XINT (lines
) != FRAME_LINES (f
))
2698 x_set_window_size (f
, 1, FRAME_COLS (f
), XINT (lines
));
2699 do_pending_window_change (0);
2703 change_frame_size (f
, XINT (lines
), 0, !NILP (pretend
), 0, 0);
2707 DEFUN ("set-frame-width", Fset_frame_width
, Sset_frame_width
, 2, 3, 0,
2708 doc
: /* Specify that the frame FRAME has COLS columns.
2709 Optional third arg non-nil means that redisplay should use COLS columns
2710 but that the idea of the actual width of the frame should not be changed. */)
2711 (Lisp_Object frame
, Lisp_Object cols
, Lisp_Object pretend
)
2713 register struct frame
*f
;
2714 CHECK_NUMBER (cols
);
2716 frame
= selected_frame
;
2717 CHECK_LIVE_FRAME (frame
);
2720 /* I think this should be done with a hook. */
2721 #ifdef HAVE_WINDOW_SYSTEM
2722 if (FRAME_WINDOW_P (f
))
2724 if (XINT (cols
) != FRAME_COLS (f
))
2725 x_set_window_size (f
, 1, XINT (cols
), FRAME_LINES (f
));
2726 do_pending_window_change (0);
2730 change_frame_size (f
, 0, XINT (cols
), !NILP (pretend
), 0, 0);
2734 DEFUN ("set-frame-size", Fset_frame_size
, Sset_frame_size
, 3, 3, 0,
2735 doc
: /* Sets size of FRAME to COLS by ROWS, measured in characters. */)
2736 (Lisp_Object frame
, Lisp_Object cols
, Lisp_Object rows
)
2738 register struct frame
*f
;
2740 CHECK_LIVE_FRAME (frame
);
2741 CHECK_NUMBER (cols
);
2742 CHECK_NUMBER (rows
);
2745 /* I think this should be done with a hook. */
2746 #ifdef HAVE_WINDOW_SYSTEM
2747 if (FRAME_WINDOW_P (f
))
2749 if (XINT (rows
) != FRAME_LINES (f
)
2750 || XINT (cols
) != FRAME_COLS (f
)
2751 || f
->new_text_lines
|| f
->new_text_cols
)
2752 x_set_window_size (f
, 1, XINT (cols
), XINT (rows
));
2753 do_pending_window_change (0);
2757 change_frame_size (f
, XINT (rows
), XINT (cols
), 0, 0, 0);
2762 DEFUN ("set-frame-position", Fset_frame_position
,
2763 Sset_frame_position
, 3, 3, 0,
2764 doc
: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2765 This is actually the position of the upper left corner of the frame.
2766 Negative values for XOFFSET or YOFFSET are interpreted relative to
2767 the rightmost or bottommost possible position (that stays within the screen). */)
2768 (Lisp_Object frame
, Lisp_Object xoffset
, Lisp_Object yoffset
)
2770 register struct frame
*f
;
2772 CHECK_LIVE_FRAME (frame
);
2773 CHECK_NUMBER (xoffset
);
2774 CHECK_NUMBER (yoffset
);
2777 /* I think this should be done with a hook. */
2778 #ifdef HAVE_WINDOW_SYSTEM
2779 if (FRAME_WINDOW_P (f
))
2780 x_set_offset (f
, XINT (xoffset
), XINT (yoffset
), 1);
2787 /***********************************************************************
2789 ***********************************************************************/
2791 /* Connect the frame-parameter names for X frames
2792 to the ways of passing the parameter values to the window system.
2794 The name of a parameter, as a Lisp symbol,
2795 has an `x-frame-parameter' property which is an integer in Lisp
2796 that is an index in this table. */
2798 struct frame_parm_table
{
2800 Lisp_Object
*variable
;
2803 static const struct frame_parm_table frame_parms
[] =
2805 {"auto-raise", &Qauto_raise
},
2806 {"auto-lower", &Qauto_lower
},
2807 {"background-color", 0},
2808 {"border-color", &Qborder_color
},
2809 {"border-width", &Qborder_width
},
2810 {"cursor-color", &Qcursor_color
},
2811 {"cursor-type", &Qcursor_type
},
2813 {"foreground-color", 0},
2814 {"icon-name", &Qicon_name
},
2815 {"icon-type", &Qicon_type
},
2816 {"internal-border-width", &Qinternal_border_width
},
2817 {"menu-bar-lines", &Qmenu_bar_lines
},
2818 {"mouse-color", &Qmouse_color
},
2820 {"scroll-bar-width", &Qscroll_bar_width
},
2822 {"unsplittable", &Qunsplittable
},
2823 {"vertical-scroll-bars", &Qvertical_scroll_bars
},
2824 {"visibility", &Qvisibility
},
2825 {"tool-bar-lines", &Qtool_bar_lines
},
2826 {"scroll-bar-foreground", &Qscroll_bar_foreground
},
2827 {"scroll-bar-background", &Qscroll_bar_background
},
2828 {"screen-gamma", &Qscreen_gamma
},
2829 {"line-spacing", &Qline_spacing
},
2830 {"left-fringe", &Qleft_fringe
},
2831 {"right-fringe", &Qright_fringe
},
2832 {"wait-for-wm", &Qwait_for_wm
},
2833 {"fullscreen", &Qfullscreen
},
2834 {"font-backend", &Qfont_backend
},
2836 {"sticky", &Qsticky
},
2837 {"tool-bar-position", &Qtool_bar_position
},
2842 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
2843 wanted positions of the WM window (not Emacs window).
2844 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
2845 window (FRAME_X_WINDOW).
2849 x_fullscreen_adjust (struct frame
*f
, int *width
, int *height
, int *top_pos
, int *left_pos
)
2851 int newwidth
= FRAME_COLS (f
);
2852 int newheight
= FRAME_LINES (f
);
2853 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2855 *top_pos
= f
->top_pos
;
2856 *left_pos
= f
->left_pos
;
2858 if (f
->want_fullscreen
& FULLSCREEN_HEIGHT
)
2862 ph
= x_display_pixel_height (dpyinfo
);
2863 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2864 ph
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, newheight
) - f
->y_pixels_diff
;
2865 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2869 if (f
->want_fullscreen
& FULLSCREEN_WIDTH
)
2873 pw
= x_display_pixel_width (dpyinfo
);
2874 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2875 pw
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, newwidth
) - f
->x_pixels_diff
;
2876 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2881 *height
= newheight
;
2884 #endif /* WINDOWSNT */
2886 #ifdef HAVE_WINDOW_SYSTEM
2888 /* Change the parameters of frame F as specified by ALIST.
2889 If a parameter is not specially recognized, do nothing special;
2890 otherwise call the `x_set_...' function for that parameter.
2891 Except for certain geometry properties, always call store_frame_param
2892 to store the new value in the parameter alist. */
2895 x_set_frame_parameters (FRAME_PTR f
, Lisp_Object alist
)
2899 /* If both of these parameters are present, it's more efficient to
2900 set them both at once. So we wait until we've looked at the
2901 entire list before we set them. */
2905 Lisp_Object left
, top
;
2907 /* Same with these. */
2908 Lisp_Object icon_left
, icon_top
;
2910 /* Record in these vectors all the parms specified. */
2912 Lisp_Object
*values
;
2914 int left_no_change
= 0, top_no_change
= 0;
2915 int icon_left_no_change
= 0, icon_top_no_change
= 0;
2916 int size_changed
= 0;
2917 struct gcpro gcpro1
, gcpro2
;
2920 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2923 parms
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2924 values
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2926 /* Extract parm names and values into those vectors. */
2929 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
2934 parms
[i
] = Fcar (elt
);
2935 values
[i
] = Fcdr (elt
);
2938 /* TAIL and ALIST are not used again below here. */
2939 alist
= tail
= Qnil
;
2941 GCPRO2 (*parms
, *values
);
2945 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
2946 because their values appear in VALUES and strings are not valid. */
2947 top
= left
= Qunbound
;
2948 icon_left
= icon_top
= Qunbound
;
2950 /* Provide default values for HEIGHT and WIDTH. */
2951 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2952 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2954 /* Process foreground_color and background_color before anything else.
2955 They are independent of other properties, but other properties (e.g.,
2956 cursor_color) are dependent upon them. */
2957 /* Process default font as well, since fringe widths depends on it. */
2958 for (p
= 0; p
< i
; p
++)
2960 Lisp_Object prop
, val
;
2964 if (EQ (prop
, Qforeground_color
)
2965 || EQ (prop
, Qbackground_color
)
2966 || EQ (prop
, Qfont
))
2968 register Lisp_Object param_index
, old_value
;
2970 old_value
= get_frame_param (f
, prop
);
2971 if (NILP (Fequal (val
, old_value
)))
2973 store_frame_param (f
, prop
, val
);
2975 param_index
= Fget (prop
, Qx_frame_parameter
);
2976 if (NATNUMP (param_index
)
2977 && (XFASTINT (param_index
)
2978 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
2979 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
2980 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
2985 /* Now process them in reverse of specified order. */
2988 Lisp_Object prop
, val
;
2993 if (EQ (prop
, Qwidth
) && NATNUMP (val
))
2996 width
= XFASTINT (val
);
2998 else if (EQ (prop
, Qheight
) && NATNUMP (val
))
3001 height
= XFASTINT (val
);
3003 else if (EQ (prop
, Qtop
))
3005 else if (EQ (prop
, Qleft
))
3007 else if (EQ (prop
, Qicon_top
))
3009 else if (EQ (prop
, Qicon_left
))
3011 else if (EQ (prop
, Qforeground_color
)
3012 || EQ (prop
, Qbackground_color
)
3013 || EQ (prop
, Qfont
))
3014 /* Processed above. */
3018 register Lisp_Object param_index
, old_value
;
3020 old_value
= get_frame_param (f
, prop
);
3022 store_frame_param (f
, prop
, val
);
3024 param_index
= Fget (prop
, Qx_frame_parameter
);
3025 if (NATNUMP (param_index
)
3026 && (XFASTINT (param_index
)
3027 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3028 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
3029 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
3033 /* Don't die if just one of these was set. */
3034 if (EQ (left
, Qunbound
))
3037 if (f
->left_pos
< 0)
3038 left
= Fcons (Qplus
, Fcons (make_number (f
->left_pos
), Qnil
));
3040 XSETINT (left
, f
->left_pos
);
3042 if (EQ (top
, Qunbound
))
3046 top
= Fcons (Qplus
, Fcons (make_number (f
->top_pos
), Qnil
));
3048 XSETINT (top
, f
->top_pos
);
3051 /* If one of the icon positions was not set, preserve or default it. */
3052 if (EQ (icon_left
, Qunbound
) || ! INTEGERP (icon_left
))
3054 icon_left_no_change
= 1;
3055 icon_left
= Fcdr (Fassq (Qicon_left
, f
->param_alist
));
3056 if (NILP (icon_left
))
3057 XSETINT (icon_left
, 0);
3059 if (EQ (icon_top
, Qunbound
) || ! INTEGERP (icon_top
))
3061 icon_top_no_change
= 1;
3062 icon_top
= Fcdr (Fassq (Qicon_top
, f
->param_alist
));
3063 if (NILP (icon_top
))
3064 XSETINT (icon_top
, 0);
3067 /* Don't set these parameters unless they've been explicitly
3068 specified. The window might be mapped or resized while we're in
3069 this function, and we don't want to override that unless the lisp
3070 code has asked for it.
3072 Don't set these parameters unless they actually differ from the
3073 window's current parameters; the window may not actually exist
3078 check_frame_size (f
, &height
, &width
);
3080 XSETFRAME (frame
, f
);
3083 && (width
!= FRAME_COLS (f
)
3084 || height
!= FRAME_LINES (f
)
3085 || f
->new_text_lines
|| f
->new_text_cols
))
3086 Fset_frame_size (frame
, make_number (width
), make_number (height
));
3088 if ((!NILP (left
) || !NILP (top
))
3089 && ! (left_no_change
&& top_no_change
)
3090 && ! (NUMBERP (left
) && XINT (left
) == f
->left_pos
3091 && NUMBERP (top
) && XINT (top
) == f
->top_pos
))
3096 /* Record the signs. */
3097 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3098 if (EQ (left
, Qminus
))
3099 f
->size_hint_flags
|= XNegative
;
3100 else if (INTEGERP (left
))
3102 leftpos
= XINT (left
);
3104 f
->size_hint_flags
|= XNegative
;
3106 else if (CONSP (left
) && EQ (XCAR (left
), Qminus
)
3107 && CONSP (XCDR (left
))
3108 && INTEGERP (XCAR (XCDR (left
))))
3110 leftpos
= - XINT (XCAR (XCDR (left
)));
3111 f
->size_hint_flags
|= XNegative
;
3113 else if (CONSP (left
) && EQ (XCAR (left
), Qplus
)
3114 && CONSP (XCDR (left
))
3115 && INTEGERP (XCAR (XCDR (left
))))
3117 leftpos
= XINT (XCAR (XCDR (left
)));
3120 if (EQ (top
, Qminus
))
3121 f
->size_hint_flags
|= YNegative
;
3122 else if (INTEGERP (top
))
3124 toppos
= XINT (top
);
3126 f
->size_hint_flags
|= YNegative
;
3128 else if (CONSP (top
) && EQ (XCAR (top
), Qminus
)
3129 && CONSP (XCDR (top
))
3130 && INTEGERP (XCAR (XCDR (top
))))
3132 toppos
= - XINT (XCAR (XCDR (top
)));
3133 f
->size_hint_flags
|= YNegative
;
3135 else if (CONSP (top
) && EQ (XCAR (top
), Qplus
)
3136 && CONSP (XCDR (top
))
3137 && INTEGERP (XCAR (XCDR (top
))))
3139 toppos
= XINT (XCAR (XCDR (top
)));
3143 /* Store the numeric value of the position. */
3144 f
->top_pos
= toppos
;
3145 f
->left_pos
= leftpos
;
3147 f
->win_gravity
= NorthWestGravity
;
3149 /* Actually set that position, and convert to absolute. */
3150 x_set_offset (f
, leftpos
, toppos
, -1);
3153 if ((!NILP (icon_left
) || !NILP (icon_top
))
3154 && ! (icon_left_no_change
&& icon_top_no_change
))
3155 x_wm_set_icon_position (f
, XINT (icon_left
), XINT (icon_top
));
3162 /* Insert a description of internally-recorded parameters of frame X
3163 into the parameter alist *ALISTPTR that is to be given to the user.
3164 Only parameters that are specific to the X window system
3165 and whose values are not correctly recorded in the frame's
3166 param_alist need to be considered here. */
3169 x_report_frame_params (struct frame
*f
, Lisp_Object
*alistptr
)
3174 /* Represent negative positions (off the top or left screen edge)
3175 in a way that Fmodify_frame_parameters will understand correctly. */
3176 XSETINT (tem
, f
->left_pos
);
3177 if (f
->left_pos
>= 0)
3178 store_in_alist (alistptr
, Qleft
, tem
);
3180 store_in_alist (alistptr
, Qleft
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3182 XSETINT (tem
, f
->top_pos
);
3183 if (f
->top_pos
>= 0)
3184 store_in_alist (alistptr
, Qtop
, tem
);
3186 store_in_alist (alistptr
, Qtop
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3188 store_in_alist (alistptr
, Qborder_width
,
3189 make_number (f
->border_width
));
3190 store_in_alist (alistptr
, Qinternal_border_width
,
3191 make_number (FRAME_INTERNAL_BORDER_WIDTH (f
)));
3192 store_in_alist (alistptr
, Qleft_fringe
,
3193 make_number (FRAME_LEFT_FRINGE_WIDTH (f
)));
3194 store_in_alist (alistptr
, Qright_fringe
,
3195 make_number (FRAME_RIGHT_FRINGE_WIDTH (f
)));
3196 store_in_alist (alistptr
, Qscroll_bar_width
,
3197 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3199 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
3200 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3201 /* nil means "use default width"
3202 for non-toolkit scroll bar.
3203 ruler-mode.el depends on this. */
3205 sprintf (buf
, "%ld", (long) FRAME_X_WINDOW (f
));
3206 store_in_alist (alistptr
, Qwindow_id
,
3207 build_string (buf
));
3208 #ifdef HAVE_X_WINDOWS
3209 #ifdef USE_X_TOOLKIT
3210 /* Tooltip frame may not have this widget. */
3211 if (FRAME_X_OUTPUT (f
)->widget
)
3213 sprintf (buf
, "%ld", (long) FRAME_OUTER_WINDOW (f
));
3214 store_in_alist (alistptr
, Qouter_window_id
,
3215 build_string (buf
));
3217 store_in_alist (alistptr
, Qicon_name
, f
->icon_name
);
3218 FRAME_SAMPLE_VISIBILITY (f
);
3219 store_in_alist (alistptr
, Qvisibility
,
3220 (FRAME_VISIBLE_P (f
) ? Qt
3221 : FRAME_ICONIFIED_P (f
) ? Qicon
: Qnil
));
3222 store_in_alist (alistptr
, Qdisplay
,
3223 XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
3225 if (FRAME_X_OUTPUT (f
)->parent_desc
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
3228 XSETFASTINT (tem
, FRAME_X_OUTPUT (f
)->parent_desc
);
3229 store_in_alist (alistptr
, Qexplicit_name
, (f
->explicit_name
? Qt
: Qnil
));
3230 store_in_alist (alistptr
, Qparent_id
, tem
);
3231 store_in_alist (alistptr
, Qtool_bar_position
, f
->tool_bar_position
);
3235 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3236 the previous value of that parameter, NEW_VALUE is the new value. */
3239 x_set_fullscreen (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
3241 if (NILP (new_value
))
3242 f
->want_fullscreen
= FULLSCREEN_NONE
;
3243 else if (EQ (new_value
, Qfullboth
) || EQ (new_value
, Qfullscreen
))
3244 f
->want_fullscreen
= FULLSCREEN_BOTH
;
3245 else if (EQ (new_value
, Qfullwidth
))
3246 f
->want_fullscreen
= FULLSCREEN_WIDTH
;
3247 else if (EQ (new_value
, Qfullheight
))
3248 f
->want_fullscreen
= FULLSCREEN_HEIGHT
;
3249 else if (EQ (new_value
, Qmaximized
))
3250 f
->want_fullscreen
= FULLSCREEN_MAXIMIZED
;
3252 if (FRAME_TERMINAL (f
)->fullscreen_hook
!= NULL
)
3253 FRAME_TERMINAL (f
)->fullscreen_hook (f
);
3257 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3258 the previous value of that parameter, NEW_VALUE is the new value. */
3261 x_set_line_spacing (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
3263 if (NILP (new_value
))
3264 f
->extra_line_spacing
= 0;
3265 else if (NATNUMP (new_value
))
3266 f
->extra_line_spacing
= XFASTINT (new_value
);
3268 signal_error ("Invalid line-spacing", new_value
);
3269 if (FRAME_VISIBLE_P (f
))
3274 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3275 the previous value of that parameter, NEW_VALUE is the new value. */
3278 x_set_screen_gamma (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
3280 Lisp_Object bgcolor
;
3282 if (NILP (new_value
))
3284 else if (NUMBERP (new_value
) && XFLOATINT (new_value
) > 0)
3285 /* The value 0.4545 is the normal viewing gamma. */
3286 f
->gamma
= 1.0 / (0.4545 * XFLOATINT (new_value
));
3288 signal_error ("Invalid screen-gamma", new_value
);
3290 /* Apply the new gamma value to the frame background. */
3291 bgcolor
= Fassq (Qbackground_color
, f
->param_alist
);
3292 if (CONSP (bgcolor
) && (bgcolor
= XCDR (bgcolor
), STRINGP (bgcolor
)))
3294 Lisp_Object parm_index
= Fget (Qbackground_color
, Qx_frame_parameter
);
3295 if (NATNUMP (parm_index
)
3296 && (XFASTINT (parm_index
)
3297 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3298 && FRAME_RIF (f
)->frame_parm_handlers
[XFASTINT (parm_index
)])
3299 (*FRAME_RIF (f
)->frame_parm_handlers
[XFASTINT (parm_index
)])
3303 Fclear_face_cache (Qnil
);
3308 x_set_font (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3310 Lisp_Object font_object
, font_param
= Qnil
;
3313 /* Set the frame parameter back to the old value because we may
3314 fail to use ARG as the new parameter value. */
3315 store_frame_param (f
, Qfont
, oldval
);
3317 /* ARG is a fontset name, a font name, a cons of fontset name and a
3318 font object, or a font object. In the last case, this function
3323 fontset
= fs_query_fontset (arg
, 0);
3326 font_object
= font_open_by_name (f
, SSDATA (arg
));
3327 if (NILP (font_object
))
3328 error ("Font `%s' is not defined", SSDATA (arg
));
3329 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3331 else if (fontset
> 0)
3333 Lisp_Object ascii_font
= fontset_ascii (fontset
);
3335 font_object
= font_open_by_name (f
, SSDATA (ascii_font
));
3336 if (NILP (font_object
))
3337 error ("Font `%s' is not defined", SDATA (arg
));
3338 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3341 error ("The default fontset can't be used for a frame font");
3343 else if (CONSP (arg
) && STRINGP (XCAR (arg
)) && FONT_OBJECT_P (XCDR (arg
)))
3345 /* This is the case that the ASCII font of F's fontset XCAR
3346 (arg) is changed to the font XCDR (arg) by
3347 `set-fontset-font'. */
3348 fontset
= fs_query_fontset (XCAR (arg
), 0);
3350 error ("Unknown fontset: %s", SDATA (XCAR (arg
)));
3351 font_object
= XCDR (arg
);
3352 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3353 font_param
= Ffont_get (font_object
, QCname
);
3355 else if (FONT_OBJECT_P (arg
))
3358 font_param
= Ffont_get (font_object
, QCname
);
3359 /* This is to store the XLFD font name in the frame parameter for
3360 backward compatibility. We should store the font-object
3361 itself in the future. */
3362 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3363 fontset
= FRAME_FONTSET (f
);
3364 /* Check if we can use the current fontset. If not, set FONTSET
3365 to -1 to generate a new fontset from FONT-OBJECT. */
3368 Lisp_Object ascii_font
= fontset_ascii (fontset
);
3369 Lisp_Object spec
= font_spec_from_name (ascii_font
);
3371 if (! font_match_p (spec
, font_object
))
3376 signal_error ("Invalid font", arg
);
3378 if (! NILP (Fequal (font_object
, oldval
)))
3381 x_new_font (f
, font_object
, fontset
);
3382 store_frame_param (f
, Qfont
, arg
);
3383 #ifdef HAVE_X_WINDOWS
3384 store_frame_param (f
, Qfont_param
, font_param
);
3386 /* Recalculate toolbar height. */
3387 f
->n_tool_bar_rows
= 0;
3388 /* Ensure we redraw it. */
3389 clear_current_matrices (f
);
3391 recompute_basic_faces (f
);
3393 do_pending_window_change (0);
3395 /* We used to call face-set-after-frame-default here, but it leads to
3396 recursive calls (since that function can set the `default' face's
3397 font which in turns changes the frame's `font' parameter).
3398 Also I don't know what this call is meant to do, but it seems the
3399 wrong way to do it anyway (it does a lot more work than what seems
3400 reasonable in response to a change to `font'). */
3405 x_set_font_backend (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
3407 if (! NILP (new_value
)
3408 && !CONSP (new_value
))
3412 CHECK_STRING (new_value
);
3413 p0
= p1
= SSDATA (new_value
);
3417 while (*p1
&& ! isspace (*p1
) && *p1
!= ',') p1
++;
3419 new_value
= Fcons (Fintern (make_string (p0
, p1
- p0
), Qnil
),
3425 while ((c
= *++p1
) && isspace (c
));
3429 new_value
= Fnreverse (new_value
);
3432 if (! NILP (old_value
) && ! NILP (Fequal (old_value
, new_value
)))
3436 free_all_realized_faces (Qnil
);
3438 new_value
= font_update_drivers (f
, NILP (new_value
) ? Qt
: new_value
);
3439 if (NILP (new_value
))
3441 if (NILP (old_value
))
3442 error ("No font backend available");
3443 font_update_drivers (f
, old_value
);
3444 error ("None of specified font backends are available");
3446 store_frame_param (f
, Qfont_backend
, new_value
);
3452 XSETFRAME (frame
, f
);
3453 x_set_font (f
, Fframe_parameter (frame
, Qfont
), Qnil
);
3454 ++face_change_count
;
3455 ++windows_or_buffers_changed
;
3461 x_set_fringe_width (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
3463 compute_fringe_widths (f
, 1);
3464 #ifdef HAVE_X_WINDOWS
3465 /* Must adjust this so window managers report correct number of columns. */
3466 if (FRAME_X_WINDOW (f
) != 0)
3467 x_wm_set_size_hint (f
, 0, 0);
3472 x_set_border_width (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3476 if (XINT (arg
) == f
->border_width
)
3479 if (FRAME_X_WINDOW (f
) != 0)
3480 error ("Cannot change the border width of a frame");
3482 f
->border_width
= XINT (arg
);
3486 x_set_internal_border_width (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3488 int old
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3491 FRAME_INTERNAL_BORDER_WIDTH (f
) = XINT (arg
);
3492 if (FRAME_INTERNAL_BORDER_WIDTH (f
) < 0)
3493 FRAME_INTERNAL_BORDER_WIDTH (f
) = 0;
3495 #ifdef USE_X_TOOLKIT
3496 if (FRAME_X_OUTPUT (f
)->edit_widget
)
3497 widget_store_internal_border (FRAME_X_OUTPUT (f
)->edit_widget
);
3500 if (FRAME_INTERNAL_BORDER_WIDTH (f
) == old
)
3503 if (FRAME_X_WINDOW (f
) != 0)
3505 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3506 SET_FRAME_GARBAGED (f
);
3507 do_pending_window_change (0);
3510 SET_FRAME_GARBAGED (f
);
3514 x_set_visibility (struct frame
*f
, Lisp_Object value
, Lisp_Object oldval
)
3517 XSETFRAME (frame
, f
);
3520 Fmake_frame_invisible (frame
, Qt
);
3521 else if (EQ (value
, Qicon
))
3522 Ficonify_frame (frame
);
3524 Fmake_frame_visible (frame
);
3528 x_set_autoraise (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3530 f
->auto_raise
= !EQ (Qnil
, arg
);
3534 x_set_autolower (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3536 f
->auto_lower
= !EQ (Qnil
, arg
);
3540 x_set_unsplittable (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3542 f
->no_split
= !NILP (arg
);
3546 x_set_vertical_scroll_bars (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3548 if ((EQ (arg
, Qleft
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3549 || (EQ (arg
, Qright
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
3550 || (NILP (arg
) && FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3551 || (!NILP (arg
) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)))
3553 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
)
3555 ? vertical_scroll_bar_none
3557 ? vertical_scroll_bar_left
3559 ? vertical_scroll_bar_right
3560 : EQ (Qleft
, Vdefault_frame_scroll_bars
)
3561 ? vertical_scroll_bar_left
3562 : EQ (Qright
, Vdefault_frame_scroll_bars
)
3563 ? vertical_scroll_bar_right
3564 : vertical_scroll_bar_none
);
3566 /* We set this parameter before creating the X window for the
3567 frame, so we can get the geometry right from the start.
3568 However, if the window hasn't been created yet, we shouldn't
3569 call x_set_window_size. */
3570 if (FRAME_X_WINDOW (f
))
3571 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3572 do_pending_window_change (0);
3577 x_set_scroll_bar_width (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3579 int wid
= FRAME_COLUMN_WIDTH (f
);
3583 x_set_scroll_bar_default_width (f
);
3585 if (FRAME_X_WINDOW (f
))
3586 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3587 do_pending_window_change (0);
3589 else if (INTEGERP (arg
) && XINT (arg
) > 0
3590 && XFASTINT (arg
) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3592 if (XFASTINT (arg
) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
3593 XSETINT (arg
, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
+ 1);
3595 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = XFASTINT (arg
);
3596 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (XFASTINT (arg
) + wid
-1) / wid
;
3597 if (FRAME_X_WINDOW (f
))
3598 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3599 do_pending_window_change (0);
3602 change_frame_size (f
, 0, FRAME_COLS (f
), 0, 0, 0);
3603 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.hpos
= 0;
3604 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.x
= 0;
3609 /* Return non-nil if frame F wants a bitmap icon. */
3612 x_icon_type (FRAME_PTR f
)
3616 tem
= assq_no_quit (Qicon_type
, f
->param_alist
);
3624 x_set_alpha (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
3631 for (i
= 0; i
< 2; i
++)
3644 else if (FLOATP (item
))
3646 alpha
= XFLOAT_DATA (item
);
3647 if (alpha
< 0.0 || 1.0 < alpha
)
3648 args_out_of_range (make_float (0.0), make_float (1.0));
3650 else if (INTEGERP (item
))
3652 ialpha
= XINT (item
);
3653 if (ialpha
< 0 || 100 < ialpha
)
3654 args_out_of_range (make_number (0), make_number (100));
3656 alpha
= ialpha
/ 100.0;
3659 wrong_type_argument (Qnumberp
, item
);
3663 for (i
= 0; i
< 2; i
++)
3664 f
->alpha
[i
] = newval
[i
];
3666 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA)
3668 x_set_frame_alpha (f
);
3676 /* Subroutines of creating an X frame. */
3678 /* Make sure that Vx_resource_name is set to a reasonable value.
3679 Fix it up, or set it to `emacs' if it is too hopeless. */
3682 validate_x_resource_name (void)
3685 /* Number of valid characters in the resource name. */
3687 /* Number of invalid characters in the resource name. */
3692 if (!STRINGP (Vx_resource_class
))
3693 Vx_resource_class
= build_string (EMACS_CLASS
);
3695 if (STRINGP (Vx_resource_name
))
3697 unsigned char *p
= SDATA (Vx_resource_name
);
3699 len
= SBYTES (Vx_resource_name
);
3701 /* Only letters, digits, - and _ are valid in resource names.
3702 Count the valid characters and count the invalid ones. */
3703 for (i
= 0; i
< len
; i
++)
3706 if (! ((c
>= 'a' && c
<= 'z')
3707 || (c
>= 'A' && c
<= 'Z')
3708 || (c
>= '0' && c
<= '9')
3709 || c
== '-' || c
== '_'))
3716 /* Not a string => completely invalid. */
3717 bad_count
= 5, good_count
= 0;
3719 /* If name is valid already, return. */
3723 /* If name is entirely invalid, or nearly so, use `emacs'. */
3726 Vx_resource_name
= build_string ("emacs");
3730 /* Name is partly valid. Copy it and replace the invalid characters
3731 with underscores. */
3733 Vx_resource_name
= new = Fcopy_sequence (Vx_resource_name
);
3735 for (i
= 0; i
< len
; i
++)
3737 int c
= SREF (new, i
);
3738 if (! ((c
>= 'a' && c
<= 'z')
3739 || (c
>= 'A' && c
<= 'Z')
3740 || (c
>= '0' && c
<= '9')
3741 || c
== '-' || c
== '_'))
3747 extern char *x_get_string_resource (XrmDatabase
, const char *, const char *);
3748 extern Display_Info
*check_x_display_info (Lisp_Object
);
3751 /* Get specified attribute from resource database RDB.
3752 See Fx_get_resource below for other parameters. */
3755 xrdb_get_resource (XrmDatabase rdb
, Lisp_Object attribute
, Lisp_Object
class, Lisp_Object component
, Lisp_Object subclass
)
3757 register char *value
;
3761 CHECK_STRING (attribute
);
3762 CHECK_STRING (class);
3764 if (!NILP (component
))
3765 CHECK_STRING (component
);
3766 if (!NILP (subclass
))
3767 CHECK_STRING (subclass
);
3768 if (NILP (component
) != NILP (subclass
))
3769 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3771 validate_x_resource_name ();
3773 /* Allocate space for the components, the dots which separate them,
3774 and the final '\0'. Make them big enough for the worst case. */
3775 name_key
= (char *) alloca (SBYTES (Vx_resource_name
)
3776 + (STRINGP (component
)
3777 ? SBYTES (component
) : 0)
3778 + SBYTES (attribute
)
3781 class_key
= (char *) alloca (SBYTES (Vx_resource_class
)
3783 + (STRINGP (subclass
)
3784 ? SBYTES (subclass
) : 0)
3787 /* Start with emacs.FRAMENAME for the name (the specific one)
3788 and with `Emacs' for the class key (the general one). */
3789 strcpy (name_key
, SSDATA (Vx_resource_name
));
3790 strcpy (class_key
, SSDATA (Vx_resource_class
));
3792 strcat (class_key
, ".");
3793 strcat (class_key
, SSDATA (class));
3795 if (!NILP (component
))
3797 strcat (class_key
, ".");
3798 strcat (class_key
, SSDATA (subclass
));
3800 strcat (name_key
, ".");
3801 strcat (name_key
, SSDATA (component
));
3804 strcat (name_key
, ".");
3805 strcat (name_key
, SSDATA (attribute
));
3807 value
= x_get_string_resource (rdb
, name_key
, class_key
);
3809 if (value
!= (char *) 0 && *value
)
3810 return build_string (value
);
3816 DEFUN ("x-get-resource", Fx_get_resource
, Sx_get_resource
, 2, 4, 0,
3817 doc
: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
3818 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
3819 class, where INSTANCE is the name under which Emacs was invoked, or
3820 the name specified by the `-name' or `-rn' command-line arguments.
3822 The optional arguments COMPONENT and SUBCLASS add to the key and the
3823 class, respectively. You must specify both of them or neither.
3824 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
3825 and the class is `Emacs.CLASS.SUBCLASS'. */)
3826 (Lisp_Object attribute
, Lisp_Object
class, Lisp_Object component
, Lisp_Object subclass
)
3828 #ifdef HAVE_X_WINDOWS
3832 return xrdb_get_resource (check_x_display_info (Qnil
)->xrdb
,
3833 attribute
, class, component
, subclass
);
3836 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
3839 display_x_get_resource (Display_Info
*dpyinfo
, Lisp_Object attribute
, Lisp_Object
class, Lisp_Object component
, Lisp_Object subclass
)
3841 return xrdb_get_resource (dpyinfo
->xrdb
,
3842 attribute
, class, component
, subclass
);
3845 #if defined HAVE_X_WINDOWS && !defined USE_X_TOOLKIT
3846 /* Used when C code wants a resource value. */
3847 /* Called from oldXMenu/Create.c. */
3849 x_get_resource_string (const char *attribute
, const char *class)
3853 struct frame
*sf
= SELECTED_FRAME ();
3855 /* Allocate space for the components, the dots which separate them,
3856 and the final '\0'. */
3857 name_key
= (char *) alloca (SBYTES (Vinvocation_name
)
3858 + strlen (attribute
) + 2);
3859 class_key
= (char *) alloca ((sizeof (EMACS_CLASS
) - 1)
3860 + strlen (class) + 2);
3862 sprintf (name_key
, "%s.%s", SSDATA (Vinvocation_name
), attribute
);
3863 sprintf (class_key
, "%s.%s", EMACS_CLASS
, class);
3865 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf
)->xrdb
,
3866 name_key
, class_key
);
3870 /* Return the value of parameter PARAM.
3872 First search ALIST, then Vdefault_frame_alist, then the X defaults
3873 database, using ATTRIBUTE as the attribute name and CLASS as its class.
3875 Convert the resource to the type specified by desired_type.
3877 If no default is specified, return Qunbound. If you call
3878 x_get_arg, make sure you deal with Qunbound in a reasonable way,
3879 and don't let it get stored in any Lisp-visible variables! */
3882 x_get_arg (Display_Info
*dpyinfo
, Lisp_Object alist
, Lisp_Object param
,
3883 const char *attribute
, const char *class, enum resource_types type
)
3885 register Lisp_Object tem
;
3887 tem
= Fassq (param
, alist
);
3891 /* If we find this parm in ALIST, clear it out
3892 so that it won't be "left over" at the end. */
3894 XSETCAR (tem
, Qnil
);
3895 /* In case the parameter appears more than once in the alist,
3897 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
3898 if (CONSP (XCAR (tail
))
3899 && EQ (XCAR (XCAR (tail
)), param
))
3900 XSETCAR (XCAR (tail
), Qnil
);
3903 tem
= Fassq (param
, Vdefault_frame_alist
);
3905 /* If it wasn't specified in ALIST or the Lisp-level defaults,
3906 look in the X resources. */
3909 if (attribute
&& dpyinfo
)
3911 tem
= display_x_get_resource (dpyinfo
,
3912 build_string (attribute
),
3913 build_string (class),
3921 case RES_TYPE_NUMBER
:
3922 return make_number (atoi (SSDATA (tem
)));
3924 case RES_TYPE_BOOLEAN_NUMBER
:
3925 if (!strcmp (SSDATA (tem
), "on")
3926 || !strcmp (SSDATA (tem
), "true"))
3927 return make_number (1);
3928 return make_number (atoi (SSDATA (tem
)));
3931 case RES_TYPE_FLOAT
:
3932 return make_float (atof (SSDATA (tem
)));
3934 case RES_TYPE_BOOLEAN
:
3935 tem
= Fdowncase (tem
);
3936 if (!strcmp (SSDATA (tem
), "on")
3938 || !strcmp (SSDATA (tem
), "yes")
3940 || !strcmp (SSDATA (tem
), "true"))
3945 case RES_TYPE_STRING
:
3948 case RES_TYPE_SYMBOL
:
3949 /* As a special case, we map the values `true' and `on'
3950 to Qt, and `false' and `off' to Qnil. */
3953 lower
= Fdowncase (tem
);
3954 if (!strcmp (SSDATA (lower
), "on")
3956 || !strcmp (SSDATA (lower
), "yes")
3958 || !strcmp (SSDATA (lower
), "true"))
3960 else if (!strcmp (SSDATA (lower
), "off")
3962 || !strcmp (SSDATA (lower
), "no")
3964 || !strcmp (SSDATA (lower
), "false"))
3967 return Fintern (tem
, Qnil
);
3981 x_frame_get_arg (struct frame
*f
, Lisp_Object alist
, Lisp_Object param
,
3982 const char *attribute
, const char *class,
3983 enum resource_types type
)
3985 return x_get_arg (FRAME_X_DISPLAY_INFO (f
),
3986 alist
, param
, attribute
, class, type
);
3989 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
3992 x_frame_get_and_record_arg (struct frame
*f
, Lisp_Object alist
,
3994 const char *attribute
, const char *class,
3995 enum resource_types type
)
3999 value
= x_get_arg (FRAME_X_DISPLAY_INFO (f
), alist
, param
,
4000 attribute
, class, type
);
4001 if (! NILP (value
) && ! EQ (value
, Qunbound
))
4002 store_frame_param (f
, param
, value
);
4008 /* Record in frame F the specified or default value according to ALIST
4009 of the parameter named PROP (a Lisp symbol).
4010 If no value is specified for PROP, look for an X default for XPROP
4011 on the frame named NAME.
4012 If that is not found either, use the value DEFLT. */
4015 x_default_parameter (struct frame
*f
, Lisp_Object alist
, Lisp_Object prop
,
4016 Lisp_Object deflt
, const char *xprop
, const char *xclass
,
4017 enum resource_types type
)
4021 tem
= x_frame_get_arg (f
, alist
, prop
, xprop
, xclass
, type
);
4022 if (EQ (tem
, Qunbound
))
4024 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
4031 /* NS used to define x-parse-geometry in ns-win.el, but that confused
4032 make-docfile: the documentation string in ns-win.el was used for
4033 x-parse-geometry even in non-NS builds.
4035 With two definitions of x-parse-geometry in this file, various
4036 things still get confused (eg M-x apropos documentation), so that
4037 it is best if the two definitions just share the same doc-string.
4039 DEFUN ("x-parse-geometry", Fx_parse_geometry
, Sx_parse_geometry
, 1, 1, 0,
4040 doc
: /* Parse a display geometry string STRING.
4041 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
4042 The properties returned may include `top', `left', `height', and `width'.
4043 For X, the value of `left' or `top' may be an integer,
4044 or a list (+ N) meaning N pixels relative to top/left corner,
4045 or a list (- N) meaning -N pixels relative to bottom/right corner.
4046 On Nextstep, this just calls `ns-parse-geometry'. */)
4047 (Lisp_Object string
)
4050 call1 (Qns_parse_geometry
, string
);
4053 unsigned int width
, height
;
4056 CHECK_STRING (string
);
4058 geometry
= XParseGeometry (SSDATA (string
),
4059 &x
, &y
, &width
, &height
);
4061 if (geometry
& XValue
)
4063 Lisp_Object element
;
4065 if (x
>= 0 && (geometry
& XNegative
))
4066 element
= Fcons (Qleft
, Fcons (Qminus
, Fcons (make_number (-x
), Qnil
)));
4067 else if (x
< 0 && ! (geometry
& XNegative
))
4068 element
= Fcons (Qleft
, Fcons (Qplus
, Fcons (make_number (x
), Qnil
)));
4070 element
= Fcons (Qleft
, make_number (x
));
4071 result
= Fcons (element
, result
);
4074 if (geometry
& YValue
)
4076 Lisp_Object element
;
4078 if (y
>= 0 && (geometry
& YNegative
))
4079 element
= Fcons (Qtop
, Fcons (Qminus
, Fcons (make_number (-y
), Qnil
)));
4080 else if (y
< 0 && ! (geometry
& YNegative
))
4081 element
= Fcons (Qtop
, Fcons (Qplus
, Fcons (make_number (y
), Qnil
)));
4083 element
= Fcons (Qtop
, make_number (y
));
4084 result
= Fcons (element
, result
);
4087 if (geometry
& WidthValue
)
4088 result
= Fcons (Fcons (Qwidth
, make_number (width
)), result
);
4089 if (geometry
& HeightValue
)
4090 result
= Fcons (Fcons (Qheight
, make_number (height
)), result
);
4093 #endif /* HAVE_NS */
4097 /* Calculate the desired size and position of frame F.
4098 Return the flags saying which aspects were specified.
4100 Also set the win_gravity and size_hint_flags of F.
4102 Adjust height for toolbar if TOOLBAR_P is 1.
4104 This function does not make the coordinates positive. */
4106 #define DEFAULT_ROWS 35
4107 #define DEFAULT_COLS 80
4110 x_figure_window_size (struct frame
*f
, Lisp_Object parms
, int toolbar_p
)
4112 register Lisp_Object tem0
, tem1
, tem2
;
4113 long window_prompting
= 0;
4114 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4116 /* Default values if we fall through.
4117 Actually, if that happens we should get
4118 window manager prompting. */
4119 SET_FRAME_COLS (f
, DEFAULT_COLS
);
4120 FRAME_LINES (f
) = DEFAULT_ROWS
;
4121 /* Window managers expect that if program-specified
4122 positions are not (0,0), they're intentional, not defaults. */
4126 /* Ensure that old new_text_cols and new_text_lines will not override the
4128 /* ++KFS: This was specific to W32, but seems ok for all platforms */
4129 f
->new_text_cols
= f
->new_text_lines
= 0;
4131 tem0
= x_get_arg (dpyinfo
, parms
, Qheight
, 0, 0, RES_TYPE_NUMBER
);
4132 tem1
= x_get_arg (dpyinfo
, parms
, Qwidth
, 0, 0, RES_TYPE_NUMBER
);
4133 tem2
= x_get_arg (dpyinfo
, parms
, Quser_size
, 0, 0, RES_TYPE_NUMBER
);
4134 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4136 if (!EQ (tem0
, Qunbound
))
4138 CHECK_NUMBER (tem0
);
4139 FRAME_LINES (f
) = XINT (tem0
);
4141 if (!EQ (tem1
, Qunbound
))
4143 CHECK_NUMBER (tem1
);
4144 SET_FRAME_COLS (f
, XINT (tem1
));
4146 if (!NILP (tem2
) && !EQ (tem2
, Qunbound
))
4147 window_prompting
|= USSize
;
4149 window_prompting
|= PSize
;
4152 f
->scroll_bar_actual_width
4153 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
4155 /* This used to be done _before_ calling x_figure_window_size, but
4156 since the height is reset here, this was really a no-op. I
4157 assume that moving it here does what Gerd intended (although he
4158 no longer can remember what that was... ++KFS, 2003-03-25. */
4160 /* Add the tool-bar height to the initial frame height so that the
4161 user gets a text display area of the size he specified with -g or
4162 via .Xdefaults. Later changes of the tool-bar height don't
4163 change the frame size. This is done so that users can create
4164 tall Emacs frames without having to guess how tall the tool-bar
4166 if (toolbar_p
&& FRAME_TOOL_BAR_LINES (f
))
4168 int margin
, relief
, bar_height
;
4170 relief
= (tool_bar_button_relief
>= 0
4171 ? tool_bar_button_relief
4172 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
4174 if (INTEGERP (Vtool_bar_button_margin
)
4175 && XINT (Vtool_bar_button_margin
) > 0)
4176 margin
= XFASTINT (Vtool_bar_button_margin
);
4177 else if (CONSP (Vtool_bar_button_margin
)
4178 && INTEGERP (XCDR (Vtool_bar_button_margin
))
4179 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4180 margin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4184 bar_height
= DEFAULT_TOOL_BAR_IMAGE_HEIGHT
+ 2 * margin
+ 2 * relief
;
4185 FRAME_LINES (f
) += (bar_height
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
4188 compute_fringe_widths (f
, 0);
4190 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, FRAME_COLS (f
));
4191 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4193 tem0
= x_get_arg (dpyinfo
, parms
, Qtop
, 0, 0, RES_TYPE_NUMBER
);
4194 tem1
= x_get_arg (dpyinfo
, parms
, Qleft
, 0, 0, RES_TYPE_NUMBER
);
4195 tem2
= x_get_arg (dpyinfo
, parms
, Quser_position
, 0, 0, RES_TYPE_NUMBER
);
4196 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4198 if (EQ (tem0
, Qminus
))
4201 window_prompting
|= YNegative
;
4203 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qminus
)
4204 && CONSP (XCDR (tem0
))
4205 && INTEGERP (XCAR (XCDR (tem0
))))
4207 f
->top_pos
= - XINT (XCAR (XCDR (tem0
)));
4208 window_prompting
|= YNegative
;
4210 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qplus
)
4211 && CONSP (XCDR (tem0
))
4212 && INTEGERP (XCAR (XCDR (tem0
))))
4214 f
->top_pos
= XINT (XCAR (XCDR (tem0
)));
4216 else if (EQ (tem0
, Qunbound
))
4220 CHECK_NUMBER (tem0
);
4221 f
->top_pos
= XINT (tem0
);
4223 window_prompting
|= YNegative
;
4226 if (EQ (tem1
, Qminus
))
4229 window_prompting
|= XNegative
;
4231 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qminus
)
4232 && CONSP (XCDR (tem1
))
4233 && INTEGERP (XCAR (XCDR (tem1
))))
4235 f
->left_pos
= - XINT (XCAR (XCDR (tem1
)));
4236 window_prompting
|= XNegative
;
4238 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qplus
)
4239 && CONSP (XCDR (tem1
))
4240 && INTEGERP (XCAR (XCDR (tem1
))))
4242 f
->left_pos
= XINT (XCAR (XCDR (tem1
)));
4244 else if (EQ (tem1
, Qunbound
))
4248 CHECK_NUMBER (tem1
);
4249 f
->left_pos
= XINT (tem1
);
4250 if (f
->left_pos
< 0)
4251 window_prompting
|= XNegative
;
4254 if (!NILP (tem2
) && ! EQ (tem2
, Qunbound
))
4255 window_prompting
|= USPosition
;
4257 window_prompting
|= PPosition
;
4260 if (window_prompting
& XNegative
)
4262 if (window_prompting
& YNegative
)
4263 f
->win_gravity
= SouthEastGravity
;
4265 f
->win_gravity
= NorthEastGravity
;
4269 if (window_prompting
& YNegative
)
4270 f
->win_gravity
= SouthWestGravity
;
4272 f
->win_gravity
= NorthWestGravity
;
4275 f
->size_hint_flags
= window_prompting
;
4277 return window_prompting
;
4282 #endif /* HAVE_WINDOW_SYSTEM */
4285 frame_make_pointer_invisible (void)
4287 if (! NILP (Vmake_pointer_invisible
))
4290 if (!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
)))
4293 f
= SELECTED_FRAME ();
4294 if (f
&& !f
->pointer_invisible
4295 && FRAME_TERMINAL (f
)->toggle_invisible_pointer_hook
)
4298 FRAME_TERMINAL (f
)->toggle_invisible_pointer_hook (f
, 1);
4299 f
->pointer_invisible
= 1;
4305 frame_make_pointer_visible (void)
4307 /* We don't check Vmake_pointer_invisible here in case the
4308 pointer was invisible when Vmake_pointer_invisible was set to nil. */
4311 if (!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
)))
4314 f
= SELECTED_FRAME ();
4315 if (f
&& f
->pointer_invisible
&& f
->mouse_moved
4316 && FRAME_TERMINAL (f
)->toggle_invisible_pointer_hook
)
4318 FRAME_TERMINAL (f
)->toggle_invisible_pointer_hook (f
, 0);
4319 f
->pointer_invisible
= 0;
4323 DEFUN ("frame-pointer-visible-p", Fframe_pointer_visible_p
,
4324 Sframe_pointer_visible_p
, 0, 1, 0,
4325 doc
: /* Return t if the mouse pointer displayed on FRAME is visible.
4326 Otherwise it returns nil. FRAME omitted or nil means the
4327 selected frame. This is useful when `make-pointer-invisible' is set. */)
4331 frame
= selected_frame
;
4333 CHECK_FRAME (frame
);
4335 return (XFRAME (frame
)->pointer_invisible
? Qnil
: Qt
);
4339 /***********************************************************************
4341 ***********************************************************************/
4344 syms_of_frame (void)
4346 Qframep
= intern_c_string ("framep");
4347 staticpro (&Qframep
);
4348 Qframe_live_p
= intern_c_string ("frame-live-p");
4349 staticpro (&Qframe_live_p
);
4350 Qexplicit_name
= intern_c_string ("explicit-name");
4351 staticpro (&Qexplicit_name
);
4352 Qheight
= intern_c_string ("height");
4353 staticpro (&Qheight
);
4354 Qicon
= intern_c_string ("icon");
4356 Qminibuffer
= intern_c_string ("minibuffer");
4357 staticpro (&Qminibuffer
);
4358 Qmodeline
= intern_c_string ("modeline");
4359 staticpro (&Qmodeline
);
4360 Qonly
= intern_c_string ("only");
4362 Qwidth
= intern_c_string ("width");
4363 staticpro (&Qwidth
);
4364 Qgeometry
= intern_c_string ("geometry");
4365 staticpro (&Qgeometry
);
4366 Qicon_left
= intern_c_string ("icon-left");
4367 staticpro (&Qicon_left
);
4368 Qicon_top
= intern_c_string ("icon-top");
4369 staticpro (&Qicon_top
);
4370 Qtooltip
= intern_c_string ("tooltip");
4371 staticpro (&Qtooltip
);
4372 Qleft
= intern_c_string ("left");
4374 Qright
= intern_c_string ("right");
4375 staticpro (&Qright
);
4376 Quser_position
= intern_c_string ("user-position");
4377 staticpro (&Quser_position
);
4378 Quser_size
= intern_c_string ("user-size");
4379 staticpro (&Quser_size
);
4380 Qwindow_id
= intern_c_string ("window-id");
4381 staticpro (&Qwindow_id
);
4382 #ifdef HAVE_X_WINDOWS
4383 Qouter_window_id
= intern_c_string ("outer-window-id");
4384 staticpro (&Qouter_window_id
);
4386 Qparent_id
= intern_c_string ("parent-id");
4387 staticpro (&Qparent_id
);
4388 Qx
= intern_c_string ("x");
4390 Qw32
= intern_c_string ("w32");
4392 Qpc
= intern_c_string ("pc");
4394 Qmac
= intern_c_string ("mac");
4396 Qns
= intern_c_string ("ns");
4398 Qvisible
= intern_c_string ("visible");
4399 staticpro (&Qvisible
);
4400 Qbuffer_predicate
= intern_c_string ("buffer-predicate");
4401 staticpro (&Qbuffer_predicate
);
4402 Qbuffer_list
= intern_c_string ("buffer-list");
4403 staticpro (&Qbuffer_list
);
4404 Qburied_buffer_list
= intern_c_string ("buried-buffer-list");
4405 staticpro (&Qburied_buffer_list
);
4406 Qdisplay_type
= intern_c_string ("display-type");
4407 staticpro (&Qdisplay_type
);
4408 Qbackground_mode
= intern_c_string ("background-mode");
4409 staticpro (&Qbackground_mode
);
4410 Qnoelisp
= intern_c_string ("noelisp");
4411 staticpro (&Qnoelisp
);
4412 Qtty_color_mode
= intern_c_string ("tty-color-mode");
4413 staticpro (&Qtty_color_mode
);
4414 Qtty
= intern_c_string ("tty");
4416 Qtty_type
= intern_c_string ("tty-type");
4417 staticpro (&Qtty_type
);
4419 Qface_set_after_frame_default
= intern_c_string ("face-set-after-frame-default");
4420 staticpro (&Qface_set_after_frame_default
);
4422 Qfullwidth
= intern_c_string ("fullwidth");
4423 staticpro (&Qfullwidth
);
4424 Qfullheight
= intern_c_string ("fullheight");
4425 staticpro (&Qfullheight
);
4426 Qfullboth
= intern_c_string ("fullboth");
4427 staticpro (&Qfullboth
);
4428 Qmaximized
= intern_c_string ("maximized");
4429 staticpro (&Qmaximized
);
4430 Qx_resource_name
= intern_c_string ("x-resource-name");
4431 staticpro (&Qx_resource_name
);
4433 Qx_frame_parameter
= intern_c_string ("x-frame-parameter");
4434 staticpro (&Qx_frame_parameter
);
4436 Qterminal
= intern_c_string ("terminal");
4437 staticpro (&Qterminal
);
4438 Qterminal_live_p
= intern_c_string ("terminal-live-p");
4439 staticpro (&Qterminal_live_p
);
4442 Qns_parse_geometry
= intern_c_string ("ns-parse-geometry");
4443 staticpro (&Qns_parse_geometry
);
4449 for (i
= 0; i
< sizeof (frame_parms
) / sizeof (frame_parms
[0]); i
++)
4451 Lisp_Object v
= intern_c_string (frame_parms
[i
].name
);
4452 if (frame_parms
[i
].variable
)
4454 *frame_parms
[i
].variable
= v
;
4455 staticpro (frame_parms
[i
].variable
);
4457 Fput (v
, Qx_frame_parameter
, make_number (i
));
4461 #ifdef HAVE_WINDOW_SYSTEM
4462 DEFVAR_LISP ("x-resource-name", Vx_resource_name
,
4463 doc
: /* The name Emacs uses to look up X resources.
4464 `x-get-resource' uses this as the first component of the instance name
4465 when requesting resource values.
4466 Emacs initially sets `x-resource-name' to the name under which Emacs
4467 was invoked, or to the value specified with the `-name' or `-rn'
4468 switches, if present.
4470 It may be useful to bind this variable locally around a call
4471 to `x-get-resource'. See also the variable `x-resource-class'. */);
4472 Vx_resource_name
= Qnil
;
4474 DEFVAR_LISP ("x-resource-class", Vx_resource_class
,
4475 doc
: /* The class Emacs uses to look up X resources.
4476 `x-get-resource' uses this as the first component of the instance class
4477 when requesting resource values.
4479 Emacs initially sets `x-resource-class' to "Emacs".
4481 Setting this variable permanently is not a reasonable thing to do,
4482 but binding this variable locally around a call to `x-get-resource'
4483 is a reasonable practice. See also the variable `x-resource-name'. */);
4484 Vx_resource_class
= build_string (EMACS_CLASS
);
4486 DEFVAR_LISP ("frame-alpha-lower-limit", Vframe_alpha_lower_limit
,
4487 doc
: /* The lower limit of the frame opacity (alpha transparency).
4488 The value should range from 0 (invisible) to 100 (completely opaque).
4489 You can also use a floating number between 0.0 and 1.0.
4490 The default is 20. */);
4491 Vframe_alpha_lower_limit
= make_number (20);
4494 DEFVAR_LISP ("default-frame-alist", Vdefault_frame_alist
,
4495 doc
: /* Alist of default values for frame creation.
4496 These may be set in your init file, like this:
4497 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
4498 These override values given in window system configuration data,
4499 including X Windows' defaults database.
4500 For values specific to the first Emacs frame, see `initial-frame-alist'.
4501 For window-system specific values, see `window-system-default-frame-alist'.
4502 For values specific to the separate minibuffer frame, see
4503 `minibuffer-frame-alist'.
4504 The `menu-bar-lines' element of the list controls whether new frames
4505 have menu bars; `menu-bar-mode' works by altering this element.
4506 Setting this variable does not affect existing frames, only new ones. */);
4507 Vdefault_frame_alist
= Qnil
;
4509 DEFVAR_LISP ("default-frame-scroll-bars", Vdefault_frame_scroll_bars
,
4510 doc
: /* Default position of scroll bars on this window-system. */);
4511 #ifdef HAVE_WINDOW_SYSTEM
4512 #if defined(HAVE_NTGUI) || defined(NS_IMPL_COCOA) || (defined(USE_GTK) && defined(USE_TOOLKIT_SCROLL_BARS))
4513 /* MS-Windows, Mac OS X, and GTK have scroll bars on the right by
4515 Vdefault_frame_scroll_bars
= Qright
;
4517 Vdefault_frame_scroll_bars
= Qleft
;
4520 Vdefault_frame_scroll_bars
= Qnil
;
4523 DEFVAR_LISP ("terminal-frame", Vterminal_frame
,
4524 doc
: /* The initial frame-object, which represents Emacs's stdout. */);
4526 DEFVAR_LISP ("mouse-position-function", Vmouse_position_function
,
4527 doc
: /* If non-nil, function to transform normal value of `mouse-position'.
4528 `mouse-position' calls this function, passing its usual return value as
4529 argument, and returns whatever this function returns.
4530 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
4531 which need to do mouse handling at the Lisp level. */);
4532 Vmouse_position_function
= Qnil
;
4534 DEFVAR_LISP ("mouse-highlight", Vmouse_highlight
,
4535 doc
: /* If non-nil, clickable text is highlighted when mouse is over it.
4536 If the value is an integer, highlighting is only shown after moving the
4537 mouse, while keyboard input turns off the highlight even when the mouse
4538 is over the clickable text. However, the mouse shape still indicates
4539 when the mouse is over clickable text. */);
4540 Vmouse_highlight
= Qt
;
4542 DEFVAR_LISP ("make-pointer-invisible", Vmake_pointer_invisible
,
4543 doc
: /* If non-nil, make pointer invisible while typing.
4544 The pointer becomes visible again when the mouse is moved. */);
4545 Vmake_pointer_invisible
= Qt
;
4547 DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions
,
4548 doc
: /* Functions to be run before deleting a frame.
4549 The functions are run with one arg, the frame to be deleted.
4552 Note that functions in this list may be called just before the frame is
4553 actually deleted, or some time later (or even both when an earlier function
4554 in `delete-frame-functions' (indirectly) calls `delete-frame'
4556 Vdelete_frame_functions
= Qnil
;
4557 Qdelete_frame_functions
= intern_c_string ("delete-frame-functions");
4558 staticpro (&Qdelete_frame_functions
);
4560 DEFVAR_LISP ("menu-bar-mode", Vmenu_bar_mode
,
4561 doc
: /* Non-nil if Menu-Bar mode is enabled.
4562 See the command `menu-bar-mode' for a description of this minor mode.
4563 Setting this variable directly does not take effect;
4564 either customize it (see the info node `Easy Customization')
4565 or call the function `menu-bar-mode'. */);
4566 Vmenu_bar_mode
= Qt
;
4568 DEFVAR_LISP ("tool-bar-mode", Vtool_bar_mode
,
4569 doc
: /* Non-nil if Tool-Bar mode is enabled.
4570 See the command `tool-bar-mode' for a description of this minor mode.
4571 Setting this variable directly does not take effect;
4572 either customize it (see the info node `Easy Customization')
4573 or call the function `tool-bar-mode'. */);
4574 #ifdef HAVE_WINDOW_SYSTEM
4575 Vtool_bar_mode
= Qt
;
4577 Vtool_bar_mode
= Qnil
;
4580 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame
,
4581 doc
: /* Minibufferless frames use this frame's minibuffer.
4583 Emacs cannot create minibufferless frames unless this is set to an
4584 appropriate surrogate.
4586 Emacs consults this variable only when creating minibufferless
4587 frames; once the frame is created, it sticks with its assigned
4588 minibuffer, no matter what this variable is set to. This means that
4589 this variable doesn't necessarily say anything meaningful about the
4590 current set of frames, or where the minibuffer is currently being
4593 This variable is local to the current terminal and cannot be buffer-local. */);
4595 DEFVAR_BOOL ("focus-follows-mouse", focus_follows_mouse
,
4596 doc
: /* Non-nil if window system changes focus when you move the mouse.
4597 You should set this variable to tell Emacs how your window manager
4598 handles focus, since there is no way in general for Emacs to find out
4599 automatically. See also `mouse-autoselect-window'. */);
4600 focus_follows_mouse
= 0;
4602 staticpro (&Vframe_list
);
4604 defsubr (&Sactive_minibuffer_window
);
4606 defsubr (&Sframe_live_p
);
4607 defsubr (&Swindow_system
);
4608 defsubr (&Smake_terminal_frame
);
4609 defsubr (&Shandle_switch_frame
);
4610 defsubr (&Sselect_frame
);
4611 defsubr (&Sselected_frame
);
4612 defsubr (&Swindow_frame
);
4613 defsubr (&Sframe_root_window
);
4614 defsubr (&Sframe_first_window
);
4615 defsubr (&Sframe_selected_window
);
4616 defsubr (&Sset_frame_selected_window
);
4617 defsubr (&Sframe_list
);
4618 defsubr (&Snext_frame
);
4619 defsubr (&Sprevious_frame
);
4620 defsubr (&Sdelete_frame
);
4621 defsubr (&Smouse_position
);
4622 defsubr (&Smouse_pixel_position
);
4623 defsubr (&Sset_mouse_position
);
4624 defsubr (&Sset_mouse_pixel_position
);
4626 defsubr (&Sframe_configuration
);
4627 defsubr (&Srestore_frame_configuration
);
4629 defsubr (&Smake_frame_visible
);
4630 defsubr (&Smake_frame_invisible
);
4631 defsubr (&Siconify_frame
);
4632 defsubr (&Sframe_visible_p
);
4633 defsubr (&Svisible_frame_list
);
4634 defsubr (&Sraise_frame
);
4635 defsubr (&Slower_frame
);
4636 defsubr (&Sredirect_frame_focus
);
4637 defsubr (&Sframe_focus
);
4638 defsubr (&Sframe_parameters
);
4639 defsubr (&Sframe_parameter
);
4640 defsubr (&Smodify_frame_parameters
);
4641 defsubr (&Sframe_char_height
);
4642 defsubr (&Sframe_char_width
);
4643 defsubr (&Sframe_pixel_height
);
4644 defsubr (&Sframe_pixel_width
);
4645 defsubr (&Stool_bar_pixel_width
);
4646 defsubr (&Sset_frame_height
);
4647 defsubr (&Sset_frame_width
);
4648 defsubr (&Sset_frame_size
);
4649 defsubr (&Sset_frame_position
);
4650 defsubr (&Sframe_pointer_visible_p
);
4652 #ifdef HAVE_WINDOW_SYSTEM
4653 defsubr (&Sx_get_resource
);
4654 defsubr (&Sx_parse_geometry
);