1 /* Generic frame functions.
2 Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009 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/>. */
25 #include "character.h"
36 /* These help us bind and responding to switch-frame events. */
40 #include "blockinput.h"
42 #include "termhooks.h"
43 #include "dispextern.h"
45 #ifdef HAVE_WINDOW_SYSTEM
55 #ifdef HAVE_WINDOW_SYSTEM
57 /* The name we're using in resource queries. Most often "emacs". */
59 Lisp_Object Vx_resource_name
;
61 /* The application class we're using in resource queries.
64 Lisp_Object Vx_resource_class
;
66 /* Lower limit value of the frame opacity (alpha transparency). */
68 Lisp_Object Vframe_alpha_lower_limit
;
73 Lisp_Object Qns_parse_geometry
;
76 Lisp_Object Qframep
, Qframe_live_p
;
77 Lisp_Object Qicon
, Qmodeline
;
79 Lisp_Object Qx
, Qw32
, Qmac
, Qpc
, Qns
;
81 Lisp_Object Qdisplay_type
;
82 Lisp_Object Qbackground_mode
;
85 Lisp_Object Qx_frame_parameter
;
86 Lisp_Object Qx_resource_name
;
87 Lisp_Object Qterminal
;
88 Lisp_Object Qterminal_live_p
;
90 /* Frame parameters (set or reported). */
92 Lisp_Object Qauto_raise
, Qauto_lower
;
93 Lisp_Object Qborder_color
, Qborder_width
;
94 Lisp_Object Qcursor_color
, Qcursor_type
;
95 Lisp_Object Qgeometry
; /* Not used */
96 Lisp_Object Qheight
, Qwidth
;
97 Lisp_Object Qleft
, Qright
;
98 Lisp_Object Qicon_left
, Qicon_top
, Qicon_type
, Qicon_name
;
99 Lisp_Object Qinternal_border_width
;
100 Lisp_Object Qmouse_color
;
101 Lisp_Object Qminibuffer
;
102 Lisp_Object Qscroll_bar_width
, Qvertical_scroll_bars
;
103 Lisp_Object Qvisibility
;
104 Lisp_Object Qscroll_bar_foreground
, Qscroll_bar_background
;
105 Lisp_Object Qscreen_gamma
;
106 Lisp_Object Qline_spacing
;
107 Lisp_Object Quser_position
, Quser_size
;
108 Lisp_Object Qwait_for_wm
;
109 Lisp_Object Qwindow_id
;
110 #ifdef HAVE_X_WINDOWS
111 Lisp_Object Qouter_window_id
;
113 Lisp_Object Qparent_id
;
114 Lisp_Object Qtitle
, Qname
;
115 Lisp_Object Qexplicit_name
;
116 Lisp_Object Qunsplittable
;
117 Lisp_Object Qmenu_bar_lines
, Qtool_bar_lines
;
118 Lisp_Object Qleft_fringe
, Qright_fringe
;
119 Lisp_Object Qbuffer_predicate
, Qbuffer_list
, Qburied_buffer_list
;
120 Lisp_Object Qtty_color_mode
;
121 Lisp_Object Qtty
, Qtty_type
;
123 Lisp_Object Qfullscreen
, Qfullwidth
, Qfullheight
, Qfullboth
, Qmaximized
;
124 Lisp_Object Qfont_backend
;
127 Lisp_Object Qface_set_after_frame_default
;
129 Lisp_Object Vterminal_frame
;
130 Lisp_Object Vdefault_frame_alist
;
131 Lisp_Object Vdefault_frame_scroll_bars
;
132 Lisp_Object Vmouse_position_function
;
133 Lisp_Object Vmouse_highlight
;
134 static Lisp_Object Vdelete_frame_functions
, Qdelete_frame_functions
;
136 int focus_follows_mouse
;
139 set_menu_bar_lines_1 (window
, n
)
143 struct window
*w
= XWINDOW (window
);
145 XSETFASTINT (w
->last_modified
, 0);
146 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
147 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
149 if (INTEGERP (w
->orig_top_line
))
150 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
151 if (INTEGERP (w
->orig_total_lines
))
152 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
154 /* Handle just the top child in a vertical split. */
155 if (!NILP (w
->vchild
))
156 set_menu_bar_lines_1 (w
->vchild
, n
);
158 /* Adjust all children in a horizontal split. */
159 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
161 w
= XWINDOW (window
);
162 set_menu_bar_lines_1 (window
, n
);
167 set_menu_bar_lines (f
, value
, oldval
)
169 Lisp_Object value
, oldval
;
172 int olines
= FRAME_MENU_BAR_LINES (f
);
174 /* Right now, menu bars don't work properly in minibuf-only frames;
175 most of the commands try to apply themselves to the minibuffer
176 frame itself, and get an error because you can't switch buffers
177 in or split the minibuffer window. */
178 if (FRAME_MINIBUF_ONLY_P (f
))
181 if (INTEGERP (value
))
182 nlines
= XINT (value
);
186 if (nlines
!= olines
)
188 windows_or_buffers_changed
++;
189 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
190 FRAME_MENU_BAR_LINES (f
) = nlines
;
191 set_menu_bar_lines_1 (f
->root_window
, nlines
- olines
);
196 Lisp_Object Vframe_list
;
198 extern Lisp_Object Vminibuffer_list
;
199 extern Lisp_Object
get_minibuffer ();
200 extern Lisp_Object
Fhandle_switch_frame ();
201 extern Lisp_Object
Fredirect_frame_focus ();
202 extern Lisp_Object
x_get_focus_frame ();
204 DEFUN ("framep", Fframep
, Sframep
, 1, 1, 0,
205 doc
: /* Return non-nil if OBJECT is a frame.
206 Value is t for a termcap frame (a character-only terminal),
207 `x' for an Emacs frame that is really an X window,
208 `w32' for an Emacs frame that is a window on MS-Windows display,
209 `ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
210 `pc' for a direct-write MS-DOS frame.
211 See also `frame-live-p'. */)
215 if (!FRAMEP (object
))
217 switch (XFRAME (object
)->output_method
)
219 case output_initial
: /* The initial frame is like a termcap frame. */
222 case output_x_window
:
226 case output_msdos_raw
:
237 DEFUN ("frame-live-p", Fframe_live_p
, Sframe_live_p
, 1, 1, 0,
238 doc
: /* Return non-nil if OBJECT is a frame which has not been deleted.
239 Value is nil if OBJECT is not a live frame. If object is a live
240 frame, the return value indicates what sort of terminal device it is
241 displayed on. See the documentation of `framep' for possible
246 return ((FRAMEP (object
)
247 && FRAME_LIVE_P (XFRAME (object
)))
252 DEFUN ("window-system", Fwindow_system
, Swindow_system
, 0, 1, 0,
253 doc
: /* The name of the window system that FRAME is displaying through.
254 The value is a symbol---for instance, 'x' for X windows.
255 The value is nil if Emacs is using a text-only terminal.
257 FRAME defaults to the currently selected frame. */)
263 frame
= selected_frame
;
265 type
= Fframep (frame
);
268 wrong_type_argument (Qframep
, frame
);
281 register struct frame
*f
;
282 register Lisp_Object root_window
;
283 register Lisp_Object mini_window
;
285 f
= allocate_frame ();
286 XSETFRAME (frame
, f
);
288 f
->desired_matrix
= 0;
289 f
->current_matrix
= 0;
292 f
->glyphs_initialized_p
= 0;
293 f
->decode_mode_spec_buffer
= 0;
295 f
->async_visible
= 0;
296 f
->output_data
.nothing
= 0;
298 f
->async_iconified
= 0;
299 f
->wants_modeline
= 1;
304 f
->has_minibuffer
= mini_p
;
305 f
->focus_frame
= Qnil
;
306 f
->explicit_name
= 0;
307 f
->can_have_scroll_bars
= 0;
308 f
->vertical_scroll_bar_type
= vertical_scroll_bar_none
;
309 f
->param_alist
= Qnil
;
310 f
->scroll_bars
= Qnil
;
311 f
->condemned_scroll_bars
= Qnil
;
312 f
->face_alist
= Qnil
;
313 f
->face_cache
= NULL
;
314 f
->menu_bar_items
= Qnil
;
315 f
->menu_bar_vector
= Qnil
;
316 f
->menu_bar_items_used
= 0;
317 f
->buffer_predicate
= Qnil
;
318 f
->buffer_list
= Qnil
;
319 f
->buried_buffer_list
= Qnil
;
322 f
->menu_bar_window
= Qnil
;
323 f
->tool_bar_window
= Qnil
;
324 f
->tool_bar_items
= Qnil
;
325 f
->desired_tool_bar_string
= f
->current_tool_bar_string
= Qnil
;
326 f
->n_tool_bar_items
= 0;
327 f
->left_fringe_width
= f
->right_fringe_width
= 0;
329 f
->scroll_bar_actual_width
= 0;
331 f
->internal_border_width
= 0;
332 f
->column_width
= 1; /* !FRAME_WINDOW_P value */
333 f
->line_height
= 1; /* !FRAME_WINDOW_P value */
334 f
->x_pixels_diff
= f
->y_pixels_diff
= 0;
335 #ifdef HAVE_WINDOW_SYSTEM
336 f
->want_fullscreen
= FULLSCREEN_NONE
;
338 f
->size_hint_flags
= 0;
340 f
->font_driver_list
= NULL
;
341 f
->font_data_list
= NULL
;
343 root_window
= make_window ();
346 mini_window
= make_window ();
347 XWINDOW (root_window
)->next
= mini_window
;
348 XWINDOW (mini_window
)->prev
= root_window
;
349 XWINDOW (mini_window
)->mini_p
= Qt
;
350 XWINDOW (mini_window
)->frame
= frame
;
351 f
->minibuffer_window
= mini_window
;
356 XWINDOW (root_window
)->next
= Qnil
;
357 f
->minibuffer_window
= Qnil
;
360 XWINDOW (root_window
)->frame
= frame
;
363 just so that there is "something there."
364 Correct size will be set up later with change_frame_size. */
366 SET_FRAME_COLS (f
, 10);
367 FRAME_LINES (f
) = 10;
369 XSETFASTINT (XWINDOW (root_window
)->total_cols
, 10);
370 XSETFASTINT (XWINDOW (root_window
)->total_lines
, (mini_p
? 9 : 10));
374 XSETFASTINT (XWINDOW (mini_window
)->total_cols
, 10);
375 XSETFASTINT (XWINDOW (mini_window
)->top_line
, 9);
376 XSETFASTINT (XWINDOW (mini_window
)->total_lines
, 1);
379 /* Choose a buffer for the frame's root window. */
383 XWINDOW (root_window
)->buffer
= Qt
;
384 buf
= Fcurrent_buffer ();
385 /* If buf is a 'hidden' buffer (i.e. one whose name starts with
386 a space), try to find another one. */
387 if (SREF (Fbuffer_name (buf
), 0) == ' ')
388 buf
= Fother_buffer (buf
, Qnil
, Qnil
);
390 /* Use set_window_buffer, not Fset_window_buffer, and don't let
391 hooks be run by it. The reason is that the whole frame/window
392 arrangement is not yet fully intialized at this point. Windows
393 don't have the right size, glyph matrices aren't initialized
394 etc. Running Lisp functions at this point surely ends in a
396 set_window_buffer (root_window
, buf
, 0, 0);
397 f
->buffer_list
= Fcons (buf
, Qnil
);
402 XWINDOW (mini_window
)->buffer
= Qt
;
403 set_window_buffer (mini_window
,
404 (NILP (Vminibuffer_list
)
406 : Fcar (Vminibuffer_list
)),
410 f
->root_window
= root_window
;
411 f
->selected_window
= root_window
;
412 /* Make sure this window seems more recently used than
413 a newly-created, never-selected window. */
414 ++window_select_count
;
415 XSETFASTINT (XWINDOW (f
->selected_window
)->use_time
, window_select_count
);
417 f
->default_face_done_p
= 0;
422 #ifdef HAVE_WINDOW_SYSTEM
423 /* Make a frame using a separate minibuffer window on another frame.
424 MINI_WINDOW is the minibuffer window to use. nil means use the
425 default (the global minibuffer). */
428 make_frame_without_minibuffer (mini_window
, kb
, display
)
429 register Lisp_Object mini_window
;
433 register struct frame
*f
;
436 if (!NILP (mini_window
))
437 CHECK_LIVE_WINDOW (mini_window
);
439 if (!NILP (mini_window
)
440 && FRAME_KBOARD (XFRAME (XWINDOW (mini_window
)->frame
)) != kb
)
441 error ("Frame and minibuffer must be on the same terminal");
443 /* Make a frame containing just a root window. */
446 if (NILP (mini_window
))
448 /* Use default-minibuffer-frame if possible. */
449 if (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
450 || ! FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
)))
452 Lisp_Object frame_dummy
;
454 XSETFRAME (frame_dummy
, f
);
455 GCPRO1 (frame_dummy
);
456 /* If there's no minibuffer frame to use, create one. */
457 kb
->Vdefault_minibuffer_frame
=
458 call1 (intern ("make-initial-minibuffer-frame"), display
);
462 mini_window
= XFRAME (kb
->Vdefault_minibuffer_frame
)->minibuffer_window
;
465 f
->minibuffer_window
= mini_window
;
467 /* Make the chosen minibuffer window display the proper minibuffer,
468 unless it is already showing a minibuffer. */
469 if (NILP (Fmemq (XWINDOW (mini_window
)->buffer
, Vminibuffer_list
)))
470 Fset_window_buffer (mini_window
,
471 (NILP (Vminibuffer_list
)
473 : Fcar (Vminibuffer_list
)), Qnil
);
477 /* Make a frame containing only a minibuffer window. */
480 make_minibuffer_frame ()
482 /* First make a frame containing just a root window, no minibuffer. */
484 register struct frame
*f
= make_frame (0);
485 register Lisp_Object mini_window
;
486 register Lisp_Object frame
;
488 XSETFRAME (frame
, f
);
493 f
->wants_modeline
= 0;
494 f
->has_minibuffer
= 1;
496 /* Now label the root window as also being the minibuffer.
497 Avoid infinite looping on the window chain by marking next pointer
500 mini_window
= f
->minibuffer_window
= f
->root_window
;
501 XWINDOW (mini_window
)->mini_p
= Qt
;
502 XWINDOW (mini_window
)->next
= Qnil
;
503 XWINDOW (mini_window
)->prev
= Qnil
;
504 XWINDOW (mini_window
)->frame
= frame
;
506 /* Put the proper buffer in that window. */
508 Fset_window_buffer (mini_window
,
509 (NILP (Vminibuffer_list
)
511 : Fcar (Vminibuffer_list
)), Qnil
);
514 #endif /* HAVE_WINDOW_SYSTEM */
516 /* Construct a frame that refers to a terminal. */
518 static int tty_frame_count
;
521 make_initial_frame (void)
524 struct terminal
*terminal
;
527 eassert (initial_kboard
);
529 /* The first call must initialize Vframe_list. */
530 if (! (NILP (Vframe_list
) || CONSP (Vframe_list
)))
533 terminal
= init_initial_terminal ();
536 XSETFRAME (frame
, f
);
538 Vframe_list
= Fcons (frame
, Vframe_list
);
541 f
->name
= build_string ("F1");
544 f
->async_visible
= 1;
546 f
->output_method
= terminal
->type
;
547 f
->terminal
= terminal
;
548 f
->terminal
->reference_count
++;
549 f
->output_data
.nothing
= 0;
551 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
552 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
554 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
555 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
559 init_frame_faces (f
);
567 make_terminal_frame (struct terminal
*terminal
)
569 register struct frame
*f
;
574 error ("Terminal is not live, can't create new frames on it");
578 XSETFRAME (frame
, f
);
579 Vframe_list
= Fcons (frame
, Vframe_list
);
582 sprintf (name
, "F%d", tty_frame_count
);
583 f
->name
= build_string (name
);
585 f
->visible
= 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
586 f
->async_visible
= 1; /* Don't let visible be cleared later. */
587 f
->terminal
= terminal
;
588 f
->terminal
->reference_count
++;
590 f
->output_data
.tty
->display_info
= &the_only_display_info
;
591 if (!inhibit_window_system
592 && (!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
))
593 || XFRAME (selected_frame
)->output_method
== output_msdos_raw
))
594 f
->output_method
= output_msdos_raw
;
596 f
->output_method
= output_termcap
;
597 #else /* not MSDOS */
598 f
->output_method
= output_termcap
;
599 create_tty_output (f
);
600 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
601 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
602 #endif /* not MSDOS */
604 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
605 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
607 /* Set the top frame to the newly created frame. */
608 if (FRAMEP (FRAME_TTY (f
)->top_frame
)
609 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f
)->top_frame
)))
610 XFRAME (FRAME_TTY (f
)->top_frame
)->async_visible
= 2; /* obscured */
612 FRAME_TTY (f
)->top_frame
= frame
;
615 init_frame_faces (f
);
620 /* Get a suitable value for frame parameter PARAMETER for a newly
621 created frame, based on (1) the user-supplied frame parameter
622 alist SUPPLIED_PARMS, (2) CURRENT_VALUE, and finally, if all else
623 fails, (3) Vdefault_frame_alist. */
626 get_future_frame_param (Lisp_Object parameter
,
627 Lisp_Object supplied_parms
,
632 result
= Fassq (parameter
, supplied_parms
);
634 result
= Fassq (parameter
, XFRAME (selected_frame
)->param_alist
);
635 if (NILP (result
) && current_value
!= NULL
)
636 result
= build_string (current_value
);
638 result
= Fassq (parameter
, Vdefault_frame_alist
);
639 if (!NILP (result
) && !STRINGP (result
))
640 result
= XCDR (result
);
641 if (NILP (result
) || !STRINGP (result
))
647 DEFUN ("make-terminal-frame", Fmake_terminal_frame
, Smake_terminal_frame
,
649 doc
: /* Create an additional terminal frame, possibly on another terminal.
650 This function takes one argument, an alist specifying frame parameters.
652 You can create multiple frames on a single text-only terminal, but
653 only one of them (the selected terminal frame) is actually displayed.
655 In practice, generally you don't need to specify any parameters,
656 except when you want to create a new frame on another terminal.
657 In that case, the `tty' parameter specifies the device file to open,
658 and the `tty-type' parameter specifies the terminal type. Example:
660 (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
662 Note that changing the size of one terminal frame automatically
663 affects all frames on the same terminal device. */)
668 struct terminal
*t
= NULL
;
669 Lisp_Object frame
, tem
;
670 struct frame
*sf
= SELECTED_FRAME ();
673 if (sf
->output_method
!= output_msdos_raw
674 && sf
->output_method
!= output_termcap
)
676 #else /* not MSDOS */
678 #ifdef WINDOWSNT /* This should work now! */
679 if (sf
->output_method
!= output_termcap
)
680 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
682 #endif /* not MSDOS */
685 Lisp_Object terminal
;
687 terminal
= Fassq (Qterminal
, parms
);
688 if (!NILP (terminal
))
690 terminal
= XCDR (terminal
);
691 t
= get_terminal (terminal
, 1);
694 if (t
&& t
!= the_only_display_info
.terminal
)
695 /* msdos.c assumes a single tty_display_info object. */
696 error ("Multiple terminals are not supported on this platform");
698 t
= the_only_display_info
.terminal
;
704 char *name
= 0, *type
= 0;
705 Lisp_Object tty
, tty_type
;
707 tty
= get_future_frame_param
708 (Qtty
, parms
, (FRAME_TERMCAP_P (XFRAME (selected_frame
))
709 ? FRAME_TTY (XFRAME (selected_frame
))->name
713 name
= (char *) alloca (SBYTES (tty
) + 1);
714 strncpy (name
, SDATA (tty
), SBYTES (tty
));
715 name
[SBYTES (tty
)] = 0;
718 tty_type
= get_future_frame_param
719 (Qtty_type
, parms
, (FRAME_TERMCAP_P (XFRAME (selected_frame
))
720 ? FRAME_TTY (XFRAME (selected_frame
))->type
722 if (!NILP (tty_type
))
724 type
= (char *) alloca (SBYTES (tty_type
) + 1);
725 strncpy (type
, SDATA (tty_type
), SBYTES (tty_type
));
726 type
[SBYTES (tty_type
)] = 0;
729 t
= init_tty (name
, type
, 0); /* Errors are not fatal. */
732 f
= make_terminal_frame (t
);
736 get_tty_size (fileno (FRAME_TTY (f
)->input
), &width
, &height
);
737 change_frame_size (f
, height
, width
, 0, 0, 0);
742 XSETFRAME (frame
, f
);
743 Fmodify_frame_parameters (frame
, Vdefault_frame_alist
);
744 Fmodify_frame_parameters (frame
, parms
);
745 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty_type
,
746 build_string (t
->display_info
.tty
->type
)),
748 if (t
->display_info
.tty
->name
!= NULL
)
749 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty
,
750 build_string (t
->display_info
.tty
->name
)),
753 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtty
, Qnil
), Qnil
));
755 /* Make the frame face alist be frame-specific, so that each
756 frame could change its face definitions independently. */
757 f
->face_alist
= Fcopy_alist (sf
->face_alist
);
758 /* Simple Fcopy_alist isn't enough, because we need the contents of
759 the vectors which are the CDRs of associations in face_alist to
760 be copied as well. */
761 for (tem
= f
->face_alist
; CONSP (tem
); tem
= XCDR (tem
))
762 XSETCDR (XCAR (tem
), Fcopy_sequence (XCDR (XCAR (tem
))));
767 /* Perform the switch to frame FRAME.
769 If FRAME is a switch-frame event `(switch-frame FRAME1)', use
772 If TRACK is non-zero and the frame that currently has the focus
773 redirects its focus to the selected frame, redirect that focused
774 frame's focus to FRAME instead.
776 FOR_DELETION non-zero means that the selected frame is being
777 deleted, which includes the possibility that the frame's terminal
780 The value of NORECORD is passed as argument to Fselect_window. */
783 do_switch_frame (frame
, track
, for_deletion
, norecord
)
784 Lisp_Object frame
, norecord
;
785 int track
, for_deletion
;
787 struct frame
*sf
= SELECTED_FRAME ();
789 /* If FRAME is a switch-frame event, extract the frame we should
792 && EQ (XCAR (frame
), Qswitch_frame
)
793 && CONSP (XCDR (frame
)))
794 frame
= XCAR (XCDR (frame
));
796 /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
797 a switch-frame event to arrive after a frame is no longer live,
798 especially when deleting the initial frame during startup. */
800 if (! FRAME_LIVE_P (XFRAME (frame
)))
803 if (sf
== XFRAME (frame
))
806 /* This is too greedy; it causes inappropriate focus redirection
807 that's hard to get rid of. */
809 /* If a frame's focus has been redirected toward the currently
810 selected frame, we should change the redirection to point to the
811 newly selected frame. This means that if the focus is redirected
812 from a minibufferless frame to a surrogate minibuffer frame, we
813 can use `other-window' to switch between all the frames using
814 that minibuffer frame, and the focus redirection will follow us
820 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
824 if (!FRAMEP (XCAR (tail
)))
827 focus
= FRAME_FOCUS_FRAME (XFRAME (XCAR (tail
)));
829 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
830 Fredirect_frame_focus (XCAR (tail
), frame
);
834 /* Instead, apply it only to the frame we're pointing to. */
835 #ifdef HAVE_WINDOW_SYSTEM
836 if (track
&& FRAME_WINDOW_P (XFRAME (frame
)))
838 Lisp_Object focus
, xfocus
;
840 xfocus
= x_get_focus_frame (XFRAME (frame
));
843 focus
= FRAME_FOCUS_FRAME (XFRAME (xfocus
));
844 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
845 Fredirect_frame_focus (xfocus
, frame
);
848 #endif /* HAVE_X_WINDOWS */
851 if (!for_deletion
&& FRAME_HAS_MINIBUF_P (sf
))
852 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf
)), 1);
854 if (FRAME_TERMCAP_P (XFRAME (frame
)) || FRAME_MSDOS_P (XFRAME (frame
)))
856 if (FRAMEP (FRAME_TTY (XFRAME (frame
))->top_frame
))
857 /* Mark previously displayed frame as now obscured. */
858 XFRAME (FRAME_TTY (XFRAME (frame
))->top_frame
)->async_visible
= 2;
859 XFRAME (frame
)->async_visible
= 1;
860 FRAME_TTY (XFRAME (frame
))->top_frame
= frame
;
863 selected_frame
= frame
;
864 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame
)))
865 last_nonminibuf_frame
= XFRAME (selected_frame
);
867 Fselect_window (XFRAME (frame
)->selected_window
, norecord
);
869 /* We want to make sure that the next event generates a frame-switch
870 event to the appropriate frame. This seems kludgy to me, but
871 before you take it out, make sure that evaluating something like
872 (select-window (frame-root-window (new-frame))) doesn't end up
873 with your typing being interpreted in the new frame instead of
874 the one you're actually typing in. */
875 internal_last_event_frame
= Qnil
;
880 DEFUN ("select-frame", Fselect_frame
, Sselect_frame
, 1, 2, "e",
881 doc
: /* Select FRAME.
882 Subsequent editing commands apply to its selected window.
883 Optional argument NORECORD means to neither change the order of
884 recently selected windows nor the buffer list.
886 The selection of FRAME lasts until the next time the user does
887 something to select a different frame, or until the next time
888 this function is called. If you are using a window system, the
889 previously selected frame may be restored as the selected frame
890 after return to the command loop, because it still may have the
891 window system's input focus. On a text-only terminal, the next
892 redisplay will display FRAME.
894 This function returns FRAME, or nil if FRAME has been deleted. */)
896 Lisp_Object frame
, norecord
;
898 return do_switch_frame (frame
, 1, 0, norecord
);
902 DEFUN ("handle-switch-frame", Fhandle_switch_frame
, Shandle_switch_frame
, 1, 1, "e",
903 doc
: /* Handle a switch-frame event EVENT.
904 Switch-frame events are usually bound to this function.
905 A switch-frame event tells Emacs that the window manager has requested
906 that the user's events be directed to the frame mentioned in the event.
907 This function selects the selected window of the frame of EVENT.
909 If EVENT is frame object, handle it as if it were a switch-frame event
914 /* Preserve prefix arg that the command loop just cleared. */
915 current_kboard
->Vprefix_arg
= Vcurrent_prefix_arg
;
916 call1 (Vrun_hooks
, Qmouse_leave_buffer_hook
);
917 return do_switch_frame (event
, 0, 0, Qnil
);
920 DEFUN ("selected-frame", Fselected_frame
, Sselected_frame
, 0, 0, 0,
921 doc
: /* Return the frame that is now selected. */)
924 return selected_frame
;
927 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
928 doc
: /* Return the frame object that window WINDOW is on. */)
932 CHECK_LIVE_WINDOW (window
);
933 return XWINDOW (window
)->frame
;
936 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
937 doc
: /* Returns the topmost, leftmost window of FRAME.
938 If omitted, FRAME defaults to the currently selected frame. */)
945 w
= SELECTED_FRAME ()->root_window
;
948 CHECK_LIVE_FRAME (frame
);
949 w
= XFRAME (frame
)->root_window
;
951 while (NILP (XWINDOW (w
)->buffer
))
953 if (! NILP (XWINDOW (w
)->hchild
))
954 w
= XWINDOW (w
)->hchild
;
955 else if (! NILP (XWINDOW (w
)->vchild
))
956 w
= XWINDOW (w
)->vchild
;
963 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
964 Sactive_minibuffer_window
, 0, 0, 0,
965 doc
: /* Return the currently active minibuffer window, or nil if none. */)
968 return minibuf_level
? minibuf_window
: Qnil
;
971 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
972 doc
: /* Returns the root-window of FRAME.
973 If omitted, FRAME defaults to the currently selected frame. */)
980 window
= SELECTED_FRAME ()->root_window
;
983 CHECK_LIVE_FRAME (frame
);
984 window
= XFRAME (frame
)->root_window
;
990 DEFUN ("frame-selected-window", Fframe_selected_window
,
991 Sframe_selected_window
, 0, 1, 0,
992 doc
: /* Return the selected window of FRAME.
993 FRAME defaults to the currently selected frame. */)
1000 window
= SELECTED_FRAME ()->selected_window
;
1003 CHECK_LIVE_FRAME (frame
);
1004 window
= XFRAME (frame
)->selected_window
;
1010 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
1011 Sset_frame_selected_window
, 2, 3, 0,
1012 doc
: /* Set selected window of FRAME to WINDOW.
1013 If FRAME is nil, use the selected frame. If FRAME is the
1014 selected frame, this makes WINDOW the selected window.
1015 Optional argument NORECORD non-nil means to neither change the
1016 order of recently selected windows nor the buffer list.
1018 (frame
, window
, norecord
)
1019 Lisp_Object frame
, window
, norecord
;
1022 frame
= selected_frame
;
1024 CHECK_LIVE_FRAME (frame
);
1025 CHECK_LIVE_WINDOW (window
);
1027 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
1028 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1030 if (EQ (frame
, selected_frame
))
1031 return Fselect_window (window
, norecord
);
1033 return XFRAME (frame
)->selected_window
= window
;
1037 DEFUN ("frame-list", Fframe_list
, Sframe_list
,
1039 doc
: /* Return a list of all live frames. */)
1043 frames
= Fcopy_sequence (Vframe_list
);
1044 #ifdef HAVE_WINDOW_SYSTEM
1045 if (FRAMEP (tip_frame
))
1046 frames
= Fdelq (tip_frame
, frames
);
1051 /* Return the next frame in the frame list after FRAME.
1052 If MINIBUF is nil, exclude minibuffer-only frames.
1053 If MINIBUF is a window, include only its own frame
1054 and any frame now using that window as the minibuffer.
1055 If MINIBUF is `visible', include all visible frames.
1056 If MINIBUF is 0, include all visible and iconified frames.
1057 Otherwise, include all frames. */
1060 next_frame (frame
, minibuf
)
1062 Lisp_Object minibuf
;
1067 /* There must always be at least one frame in Vframe_list. */
1068 if (! CONSP (Vframe_list
))
1071 /* If this frame is dead, it won't be in Vframe_list, and we'll loop
1072 forever. Forestall that. */
1073 CHECK_LIVE_FRAME (frame
);
1076 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1083 && ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1084 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1085 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1086 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
)))))
1088 /* Decide whether this frame is eligible to be returned. */
1090 /* If we've looped all the way around without finding any
1091 eligible frames, return the original frame. */
1095 /* Let minibuf decide if this frame is acceptable. */
1098 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1101 else if (EQ (minibuf
, Qvisible
))
1103 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1104 if (FRAME_VISIBLE_P (XFRAME (f
)))
1107 else if (INTEGERP (minibuf
) && XINT (minibuf
) == 0)
1109 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1110 if (FRAME_VISIBLE_P (XFRAME (f
))
1111 || FRAME_ICONIFIED_P (XFRAME (f
)))
1114 else if (WINDOWP (minibuf
))
1116 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1117 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1118 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1119 FRAME_FOCUS_FRAME (XFRAME (f
))))
1131 /* Return the previous frame in the frame list before FRAME.
1132 If MINIBUF is nil, exclude minibuffer-only frames.
1133 If MINIBUF is a window, include only its own frame
1134 and any frame now using that window as the minibuffer.
1135 If MINIBUF is `visible', include all visible frames.
1136 If MINIBUF is 0, include all visible and iconified frames.
1137 Otherwise, include all frames. */
1140 prev_frame (frame
, minibuf
)
1142 Lisp_Object minibuf
;
1147 /* There must always be at least one frame in Vframe_list. */
1148 if (! CONSP (Vframe_list
))
1152 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1160 if (EQ (frame
, f
) && !NILP (prev
))
1163 if ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1164 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1165 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1166 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
))))
1168 /* Decide whether this frame is eligible to be returned,
1169 according to minibuf. */
1172 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1175 else if (WINDOWP (minibuf
))
1177 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1178 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1179 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1180 FRAME_FOCUS_FRAME (XFRAME (f
))))
1183 else if (EQ (minibuf
, Qvisible
))
1185 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1186 if (FRAME_VISIBLE_P (XFRAME (f
)))
1189 else if (XFASTINT (minibuf
) == 0)
1191 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1192 if (FRAME_VISIBLE_P (XFRAME (f
))
1193 || FRAME_ICONIFIED_P (XFRAME (f
)))
1201 /* We've scanned the entire list. */
1203 /* We went through the whole frame list without finding a single
1204 acceptable frame. Return the original frame. */
1207 /* There were no acceptable frames in the list before FRAME; otherwise,
1208 we would have returned directly from the loop. Since PREV is the last
1209 acceptable frame in the list, return it. */
1214 DEFUN ("next-frame", Fnext_frame
, Snext_frame
, 0, 2, 0,
1215 doc
: /* Return the next frame in the frame list after FRAME.
1216 It considers only frames on the same terminal as FRAME.
1217 By default, skip minibuffer-only frames.
1218 If omitted, FRAME defaults to the selected frame.
1219 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1220 If MINIFRAME is a window, include only its own frame
1221 and any frame now using that window as the minibuffer.
1222 If MINIFRAME is `visible', include all visible frames.
1223 If MINIFRAME is 0, include all visible and iconified frames.
1224 Otherwise, include all frames. */)
1226 Lisp_Object frame
, miniframe
;
1229 frame
= selected_frame
;
1231 CHECK_LIVE_FRAME (frame
);
1232 return next_frame (frame
, miniframe
);
1235 DEFUN ("previous-frame", Fprevious_frame
, Sprevious_frame
, 0, 2, 0,
1236 doc
: /* Return the previous frame in the frame list before FRAME.
1237 It considers only frames on the same terminal as FRAME.
1238 By default, skip minibuffer-only frames.
1239 If omitted, FRAME defaults to the selected frame.
1240 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1241 If MINIFRAME is a window, include only its own frame
1242 and any frame now using that window as the minibuffer.
1243 If MINIFRAME is `visible', include all visible frames.
1244 If MINIFRAME is 0, include all visible and iconified frames.
1245 Otherwise, include all frames. */)
1247 Lisp_Object frame
, miniframe
;
1250 frame
= selected_frame
;
1251 CHECK_LIVE_FRAME (frame
);
1252 return prev_frame (frame
, miniframe
);
1255 /* Return 1 if it is ok to delete frame F;
1256 0 if all frames aside from F are invisible.
1257 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1260 other_visible_frames (f
)
1263 /* We know the selected frame is visible,
1264 so if F is some other frame, it can't be the sole visible one. */
1265 if (f
== SELECTED_FRAME ())
1270 for (frames
= Vframe_list
;
1272 frames
= XCDR (frames
))
1276 this = XCAR (frames
);
1277 /* Verify that the frame's window still exists
1278 and we can still talk to it. And note any recent change
1280 #ifdef HAVE_WINDOW_SYSTEM
1281 if (FRAME_WINDOW_P (XFRAME (this)))
1283 x_sync (XFRAME (this));
1284 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1288 if (FRAME_VISIBLE_P (XFRAME (this))
1289 || FRAME_ICONIFIED_P (XFRAME (this))
1290 /* Allow deleting the terminal frame when at least
1291 one X frame exists! */
1292 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f
)))
1300 /* Error handler for `delete-frame-functions'. */
1302 delete_frame_handler (Lisp_Object arg
)
1304 add_to_log ("Error during `delete-frame': %s", arg
, Qnil
);
1308 extern Lisp_Object Qrun_hook_with_args
;
1310 /* Delete FRAME. When FORCE equals Qnoelisp, delete FRAME
1311 unconditionally. x_connection_closed and delete_terminal use
1312 this. Any other value of FORCE implements the semantics
1313 described for Fdelete_frame. */
1315 delete_frame (frame
, force
)
1316 /* If we use `register' here, gcc-4.0.2 on amd64 using
1317 -DUSE_LISP_UNION_TYPE complains further down that we're getting the
1318 address of `force'. Go figure. */
1319 Lisp_Object frame
, force
;
1322 struct frame
*sf
= SELECTED_FRAME ();
1325 int minibuffer_selected
;
1327 if (EQ (frame
, Qnil
))
1330 XSETFRAME (frame
, f
);
1334 CHECK_FRAME (frame
);
1338 if (! FRAME_LIVE_P (f
))
1341 if (NILP (force
) && !other_visible_frames (f
))
1342 error ("Attempt to delete the sole visible or iconified frame");
1344 /* x_connection_closed must have set FORCE to `noelisp' in order
1345 to delete the last frame, if it is gone. */
1346 if (NILP (XCDR (Vframe_list
)) && !EQ (force
, Qnoelisp
))
1347 error ("Attempt to delete the only frame");
1349 /* Does this frame have a minibuffer, and is it the surrogate
1350 minibuffer for any other frame? */
1351 if (FRAME_HAS_MINIBUF_P (XFRAME (frame
)))
1355 for (frames
= Vframe_list
;
1357 frames
= XCDR (frames
))
1360 this = XCAR (frames
);
1362 if (! EQ (this, frame
)
1364 WINDOW_FRAME (XWINDOW
1365 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1367 /* If we MUST delete this frame, delete the other first.
1368 But do this only if FORCE equals `noelisp'. */
1369 if (EQ (force
, Qnoelisp
))
1370 delete_frame (this, Qnoelisp
);
1372 error ("Attempt to delete a surrogate minibuffer frame");
1377 /* Run `delete-frame-functions' unless FORCE is `noelisp' or
1378 frame is a tooltip. FORCE is set to `noelisp' when handling
1379 a disconnect from the terminal, so we don't dare call Lisp
1381 if (NILP (Vrun_hooks
) || !NILP (Fframe_parameter (frame
, intern ("tooltip"))))
1383 if (EQ (force
, Qnoelisp
))
1385 = Fcons (list3 (Qrun_hook_with_args
, Qdelete_frame_functions
, frame
),
1388 safe_call2 (Qrun_hook_with_args
, Qdelete_frame_functions
, frame
);
1390 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1391 if (! FRAME_LIVE_P (f
))
1394 /* At this point, we are committed to deleting the frame.
1395 There is no more chance for errors to prevent it. */
1397 minibuffer_selected
= EQ (minibuf_window
, selected_window
);
1399 /* Don't let the frame remain selected. */
1402 Lisp_Object tail
, frame1
;
1404 /* Look for another visible frame on the same terminal. */
1405 frame1
= next_frame (frame
, Qvisible
);
1407 /* If there is none, find *some* other frame. */
1408 if (NILP (frame1
) || EQ (frame1
, frame
))
1410 FOR_EACH_FRAME (tail
, frame1
)
1412 if (! EQ (frame
, frame1
) && FRAME_LIVE_P (XFRAME (frame1
)))
1416 #ifdef NS_IMPL_COCOA
1418 /* Under NS, there is no system mechanism for choosing a new
1419 window to get focus -- it is left to application code.
1420 So the portion of THIS application interfacing with NS
1421 needs to know about it. We call Fraise_frame, but the
1422 purpose is really to transfer focus. */
1423 Fraise_frame (frame1
);
1426 do_switch_frame (frame1
, 0, 1, Qnil
);
1427 sf
= SELECTED_FRAME ();
1430 /* Don't allow minibuf_window to remain on a deleted frame. */
1431 if (EQ (f
->minibuffer_window
, minibuf_window
))
1433 Fset_window_buffer (sf
->minibuffer_window
,
1434 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1435 minibuf_window
= sf
->minibuffer_window
;
1437 /* If the dying minibuffer window was selected,
1438 select the new one. */
1439 if (minibuffer_selected
)
1440 Fselect_window (minibuf_window
, Qnil
);
1443 /* Don't let echo_area_window to remain on a deleted frame. */
1444 if (EQ (f
->minibuffer_window
, echo_area_window
))
1445 echo_area_window
= sf
->minibuffer_window
;
1447 /* Clear any X selections for this frame. */
1448 #ifdef HAVE_X_WINDOWS
1450 x_clear_frame_selections (f
);
1454 This function must be called before the window tree of the
1455 frame is deleted because windows contain dynamically allocated
1459 #ifdef HAVE_WINDOW_SYSTEM
1460 /* Give chance to each font driver to free a frame specific data. */
1461 font_update_drivers (f
, Qnil
);
1464 /* Mark all the windows that used to be on FRAME as deleted, and then
1465 remove the reference to them. */
1466 delete_all_subwindows (XWINDOW (f
->root_window
));
1467 f
->root_window
= Qnil
;
1469 Vframe_list
= Fdelq (frame
, Vframe_list
);
1470 FRAME_SET_VISIBLE (f
, 0);
1472 /* Allow the vector of menu bar contents to be freed in the next
1473 garbage collection. The frame object itself may not be garbage
1474 collected until much later, because recent_keys and other data
1475 structures can still refer to it. */
1476 f
->menu_bar_vector
= Qnil
;
1478 free_font_driver_list (f
);
1480 xfree (f
->decode_mode_spec_buffer
);
1481 xfree (FRAME_INSERT_COST (f
));
1482 xfree (FRAME_DELETEN_COST (f
));
1483 xfree (FRAME_INSERTN_COST (f
));
1484 xfree (FRAME_DELETE_COST (f
));
1485 xfree (FRAME_MESSAGE_BUF (f
));
1487 /* Since some events are handled at the interrupt level, we may get
1488 an event for f at any time; if we zero out the frame's terminal
1489 now, then we may trip up the event-handling code. Instead, we'll
1490 promise that the terminal of the frame must be valid until we
1491 have called the window-system-dependent frame destruction
1494 if (FRAME_TERMINAL (f
)->delete_frame_hook
)
1495 (*FRAME_TERMINAL (f
)->delete_frame_hook
) (f
);
1498 struct terminal
*terminal
= FRAME_TERMINAL (f
);
1499 f
->output_data
.nothing
= 0;
1500 f
->terminal
= 0; /* Now the frame is dead. */
1502 /* If needed, delete the terminal that this frame was on.
1503 (This must be done after the frame is killed.) */
1504 terminal
->reference_count
--;
1505 if (terminal
->reference_count
== 0)
1508 XSETTERMINAL (tmp
, terminal
);
1511 Fdelete_terminal (tmp
, NILP (force
) ? Qt
: force
);
1514 kb
= terminal
->kboard
;
1517 /* If we've deleted the last_nonminibuf_frame, then try to find
1519 if (f
== last_nonminibuf_frame
)
1523 last_nonminibuf_frame
= 0;
1525 for (frames
= Vframe_list
;
1527 frames
= XCDR (frames
))
1529 f
= XFRAME (XCAR (frames
));
1530 if (!FRAME_MINIBUF_ONLY_P (f
))
1532 last_nonminibuf_frame
= f
;
1538 /* If there's no other frame on the same kboard, get out of
1539 single-kboard state if we're in it for this kboard. */
1543 /* Some frame we found on the same kboard, or nil if there are none. */
1544 Lisp_Object frame_on_same_kboard
;
1546 frame_on_same_kboard
= Qnil
;
1548 for (frames
= Vframe_list
;
1550 frames
= XCDR (frames
))
1555 this = XCAR (frames
);
1560 if (kb
== FRAME_KBOARD (f1
))
1561 frame_on_same_kboard
= this;
1564 if (NILP (frame_on_same_kboard
))
1565 not_single_kboard_state (kb
);
1569 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1570 find another one. Prefer minibuffer-only frames, but also notice
1571 frames with other windows. */
1572 if (kb
!= NULL
&& EQ (frame
, kb
->Vdefault_minibuffer_frame
))
1576 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1577 Lisp_Object frame_with_minibuf
;
1578 /* Some frame we found on the same kboard, or nil if there are none. */
1579 Lisp_Object frame_on_same_kboard
;
1581 frame_on_same_kboard
= Qnil
;
1582 frame_with_minibuf
= Qnil
;
1584 for (frames
= Vframe_list
;
1586 frames
= XCDR (frames
))
1591 this = XCAR (frames
);
1596 /* Consider only frames on the same kboard
1597 and only those with minibuffers. */
1598 if (kb
== FRAME_KBOARD (f1
)
1599 && FRAME_HAS_MINIBUF_P (f1
))
1601 frame_with_minibuf
= this;
1602 if (FRAME_MINIBUF_ONLY_P (f1
))
1606 if (kb
== FRAME_KBOARD (f1
))
1607 frame_on_same_kboard
= this;
1610 if (!NILP (frame_on_same_kboard
))
1612 /* We know that there must be some frame with a minibuffer out
1613 there. If this were not true, all of the frames present
1614 would have to be minibufferless, which implies that at some
1615 point their minibuffer frames must have been deleted, but
1616 that is prohibited at the top; you can't delete surrogate
1617 minibuffer frames. */
1618 if (NILP (frame_with_minibuf
))
1621 kb
->Vdefault_minibuffer_frame
= frame_with_minibuf
;
1624 /* No frames left on this kboard--say no minibuffer either. */
1625 kb
->Vdefault_minibuffer_frame
= Qnil
;
1628 /* Cause frame titles to update--necessary if we now have just one frame. */
1629 update_mode_lines
= 1;
1634 DEFUN ("delete-frame", Fdelete_frame
, Sdelete_frame
, 0, 2, "",
1635 doc
: /* Delete FRAME, permanently eliminating it from use.
1636 FRAME defaults to the selected frame.
1638 A frame may not be deleted if its minibuffer is used by other frames.
1639 Normally, you may not delete a frame if all other frames are invisible,
1640 but if the second optional argument FORCE is non-nil, you may do so.
1642 This function runs `delete-frame-functions' before actually
1643 deleting the frame, unless the frame is a tooltip.
1644 The functions are run with one argument, the frame to be deleted. */)
1646 Lisp_Object frame
, force
;
1648 return delete_frame (frame
, !NILP (force
) ? Qt
: Qnil
);
1652 /* Return mouse position in character cell units. */
1654 DEFUN ("mouse-position", Fmouse_position
, Smouse_position
, 0, 0, 0,
1655 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1656 The position is given in character cells, where (0, 0) is the
1657 upper-left corner of the frame, X is the horizontal offset, and Y is
1658 the vertical offset.
1659 If Emacs is running on a mouseless terminal or hasn't been programmed
1660 to read the mouse position, it returns the selected frame for FRAME
1661 and nil for X and Y.
1662 If `mouse-position-function' is non-nil, `mouse-position' calls it,
1663 passing the normal return value to that function as an argument,
1664 and returns whatever that function returns. */)
1668 Lisp_Object lispy_dummy
;
1669 enum scroll_bar_part party_dummy
;
1670 Lisp_Object x
, y
, retval
;
1672 unsigned long long_dummy
;
1673 struct gcpro gcpro1
;
1675 f
= SELECTED_FRAME ();
1678 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1679 /* It's okay for the hook to refrain from storing anything. */
1680 if (FRAME_TERMINAL (f
)->mouse_position_hook
)
1681 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, -1,
1682 &lispy_dummy
, &party_dummy
,
1689 pixel_to_glyph_coords (f
, col
, row
, &col
, &row
, NULL
, 1);
1694 XSETFRAME (lispy_dummy
, f
);
1695 retval
= Fcons (lispy_dummy
, Fcons (x
, y
));
1697 if (!NILP (Vmouse_position_function
))
1698 retval
= call1 (Vmouse_position_function
, retval
);
1699 RETURN_UNGCPRO (retval
);
1702 DEFUN ("mouse-pixel-position", Fmouse_pixel_position
,
1703 Smouse_pixel_position
, 0, 0, 0,
1704 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1705 The position is given in pixel units, where (0, 0) is the
1706 upper-left corner of the frame, X is the horizontal offset, and Y is
1707 the vertical offset.
1708 If Emacs is running on a mouseless terminal or hasn't been programmed
1709 to read the mouse position, it returns the selected frame for FRAME
1710 and nil for X and Y. */)
1714 Lisp_Object lispy_dummy
;
1715 enum scroll_bar_part party_dummy
;
1717 unsigned long long_dummy
;
1719 f
= SELECTED_FRAME ();
1722 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1723 /* It's okay for the hook to refrain from storing anything. */
1724 if (FRAME_TERMINAL (f
)->mouse_position_hook
)
1725 (*FRAME_TERMINAL (f
)->mouse_position_hook
) (&f
, -1,
1726 &lispy_dummy
, &party_dummy
,
1730 XSETFRAME (lispy_dummy
, f
);
1731 return Fcons (lispy_dummy
, Fcons (x
, y
));
1734 DEFUN ("set-mouse-position", Fset_mouse_position
, Sset_mouse_position
, 3, 3, 0,
1735 doc
: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1736 Coordinates are relative to the frame, not a window,
1737 so the coordinates of the top left character in the frame
1738 may be nonzero due to left-hand scroll bars or the menu bar.
1740 The position is given in character cells, where (0, 0) is the
1741 upper-left corner of the frame, X is the horizontal offset, and Y is
1742 the vertical offset.
1744 This function is a no-op for an X frame that is not visible.
1745 If you have just created a frame, you must wait for it to become visible
1746 before calling this function on it, like this.
1747 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1749 Lisp_Object frame
, x
, y
;
1751 CHECK_LIVE_FRAME (frame
);
1755 /* I think this should be done with a hook. */
1756 #ifdef HAVE_WINDOW_SYSTEM
1757 if (FRAME_WINDOW_P (XFRAME (frame
)))
1758 /* Warping the mouse will cause enternotify and focus events. */
1759 x_set_mouse_position (XFRAME (frame
), XINT (x
), XINT (y
));
1761 #if defined (MSDOS) && defined (HAVE_MOUSE)
1762 if (FRAME_MSDOS_P (XFRAME (frame
)))
1764 Fselect_frame (frame
, Qnil
);
1765 mouse_moveto (XINT (x
), XINT (y
));
1770 Fselect_frame (frame
, Qnil
);
1771 term_mouse_moveto (XINT (x
), XINT (y
));
1780 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position
,
1781 Sset_mouse_pixel_position
, 3, 3, 0,
1782 doc
: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
1783 The position is given in pixels, where (0, 0) is the upper-left corner
1784 of the frame, X is the horizontal offset, and Y is the vertical offset.
1786 Note, this is a no-op for an X frame that is not visible.
1787 If you have just created a frame, you must wait for it to become visible
1788 before calling this function on it, like this.
1789 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1791 Lisp_Object frame
, x
, y
;
1793 CHECK_LIVE_FRAME (frame
);
1797 /* I think this should be done with a hook. */
1798 #ifdef HAVE_WINDOW_SYSTEM
1799 if (FRAME_WINDOW_P (XFRAME (frame
)))
1800 /* Warping the mouse will cause enternotify and focus events. */
1801 x_set_mouse_pixel_position (XFRAME (frame
), XINT (x
), XINT (y
));
1803 #if defined (MSDOS) && defined (HAVE_MOUSE)
1804 if (FRAME_MSDOS_P (XFRAME (frame
)))
1806 Fselect_frame (frame
, Qnil
);
1807 mouse_moveto (XINT (x
), XINT (y
));
1812 Fselect_frame (frame
, Qnil
);
1813 term_mouse_moveto (XINT (x
), XINT (y
));
1822 static void make_frame_visible_1
P_ ((Lisp_Object
));
1824 DEFUN ("make-frame-visible", Fmake_frame_visible
, Smake_frame_visible
,
1826 doc
: /* Make the frame FRAME visible (assuming it is an X window).
1827 If omitted, FRAME defaults to the currently selected frame. */)
1832 frame
= selected_frame
;
1834 CHECK_LIVE_FRAME (frame
);
1836 /* I think this should be done with a hook. */
1837 #ifdef HAVE_WINDOW_SYSTEM
1838 if (FRAME_WINDOW_P (XFRAME (frame
)))
1840 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1841 x_make_frame_visible (XFRAME (frame
));
1845 make_frame_visible_1 (XFRAME (frame
)->root_window
);
1847 /* Make menu bar update for the Buffers and Frames menus. */
1848 windows_or_buffers_changed
++;
1853 /* Update the display_time slot of the buffers shown in WINDOW
1854 and all its descendents. */
1857 make_frame_visible_1 (window
)
1862 for (;!NILP (window
); window
= w
->next
)
1864 w
= XWINDOW (window
);
1866 if (!NILP (w
->buffer
))
1867 XBUFFER (w
->buffer
)->display_time
= Fcurrent_time ();
1869 if (!NILP (w
->vchild
))
1870 make_frame_visible_1 (w
->vchild
);
1871 if (!NILP (w
->hchild
))
1872 make_frame_visible_1 (w
->hchild
);
1876 DEFUN ("make-frame-invisible", Fmake_frame_invisible
, Smake_frame_invisible
,
1878 doc
: /* Make the frame FRAME invisible (assuming it is an X window).
1879 If omitted, FRAME defaults to the currently selected frame.
1880 Normally you may not make FRAME invisible if all other frames are invisible,
1881 but if the second optional argument FORCE is non-nil, you may do so. */)
1883 Lisp_Object frame
, force
;
1886 frame
= selected_frame
;
1888 CHECK_LIVE_FRAME (frame
);
1890 if (NILP (force
) && !other_visible_frames (XFRAME (frame
)))
1891 error ("Attempt to make invisible the sole visible or iconified frame");
1893 #if 0 /* This isn't logically necessary, and it can do GC. */
1894 /* Don't let the frame remain selected. */
1895 if (EQ (frame
, selected_frame
))
1896 do_switch_frame (next_frame (frame
, Qt
), 0, 0, Qnil
)
1899 /* Don't allow minibuf_window to remain on a deleted frame. */
1900 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1902 struct frame
*sf
= XFRAME (selected_frame
);
1903 Fset_window_buffer (sf
->minibuffer_window
,
1904 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1905 minibuf_window
= sf
->minibuffer_window
;
1908 /* I think this should be done with a hook. */
1909 #ifdef HAVE_WINDOW_SYSTEM
1910 if (FRAME_WINDOW_P (XFRAME (frame
)))
1911 x_make_frame_invisible (XFRAME (frame
));
1914 /* Make menu bar update for the Buffers and Frames menus. */
1915 windows_or_buffers_changed
++;
1920 DEFUN ("iconify-frame", Ficonify_frame
, Siconify_frame
,
1922 doc
: /* Make the frame FRAME into an icon.
1923 If omitted, FRAME defaults to the currently selected frame. */)
1928 frame
= selected_frame
;
1930 CHECK_LIVE_FRAME (frame
);
1932 #if 0 /* This isn't logically necessary, and it can do GC. */
1933 /* Don't let the frame remain selected. */
1934 if (EQ (frame
, selected_frame
))
1935 Fhandle_switch_frame (next_frame (frame
, Qt
));
1938 /* Don't allow minibuf_window to remain on a deleted frame. */
1939 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1941 struct frame
*sf
= XFRAME (selected_frame
);
1942 Fset_window_buffer (sf
->minibuffer_window
,
1943 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1944 minibuf_window
= sf
->minibuffer_window
;
1947 /* I think this should be done with a hook. */
1948 #ifdef HAVE_WINDOW_SYSTEM
1949 if (FRAME_WINDOW_P (XFRAME (frame
)))
1950 x_iconify_frame (XFRAME (frame
));
1953 /* Make menu bar update for the Buffers and Frames menus. */
1954 windows_or_buffers_changed
++;
1959 DEFUN ("frame-visible-p", Fframe_visible_p
, Sframe_visible_p
,
1961 doc
: /* Return t if FRAME is now \"visible\" (actually in use for display).
1962 A frame that is not \"visible\" is not updated and, if it works through
1963 a window system, it may not show at all.
1964 Return the symbol `icon' if frame is visible only as an icon.
1966 On a text-only terminal, all frames are considered visible, whether
1967 they are currently being displayed or not, and this function returns t
1972 CHECK_LIVE_FRAME (frame
);
1974 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1976 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1978 if (FRAME_ICONIFIED_P (XFRAME (frame
)))
1983 DEFUN ("visible-frame-list", Fvisible_frame_list
, Svisible_frame_list
,
1985 doc
: /* Return a list of all frames now \"visible\" (being updated). */)
1988 Lisp_Object tail
, frame
;
1993 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1995 frame
= XCAR (tail
);
1996 if (!FRAMEP (frame
))
1999 if (FRAME_VISIBLE_P (f
))
2000 value
= Fcons (frame
, value
);
2006 DEFUN ("raise-frame", Fraise_frame
, Sraise_frame
, 0, 1, "",
2007 doc
: /* Bring FRAME to the front, so it occludes any frames it overlaps.
2008 If FRAME is invisible or iconified, make it visible.
2009 If you don't specify a frame, the selected frame is used.
2010 If Emacs is displaying on an ordinary terminal or some other device which
2011 doesn't support multiple overlapping frames, this function selects FRAME. */)
2017 frame
= selected_frame
;
2019 CHECK_LIVE_FRAME (frame
);
2023 if (FRAME_TERMCAP_P (f
))
2024 /* On a text-only terminal select FRAME. */
2025 Fselect_frame (frame
, Qnil
);
2027 /* Do like the documentation says. */
2028 Fmake_frame_visible (frame
);
2030 if (FRAME_TERMINAL (f
)->frame_raise_lower_hook
)
2031 (*FRAME_TERMINAL (f
)->frame_raise_lower_hook
) (f
, 1);
2036 /* Should we have a corresponding function called Flower_Power? */
2037 DEFUN ("lower-frame", Flower_frame
, Slower_frame
, 0, 1, "",
2038 doc
: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2039 If you don't specify a frame, the selected frame is used.
2040 If Emacs is displaying on an ordinary terminal or some other device which
2041 doesn't support multiple overlapping frames, this function does nothing. */)
2048 frame
= selected_frame
;
2050 CHECK_LIVE_FRAME (frame
);
2054 if (FRAME_TERMINAL (f
)->frame_raise_lower_hook
)
2055 (*FRAME_TERMINAL (f
)->frame_raise_lower_hook
) (f
, 0);
2061 DEFUN ("redirect-frame-focus", Fredirect_frame_focus
, Sredirect_frame_focus
,
2063 doc
: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2064 In other words, switch-frame events caused by events in FRAME will
2065 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2066 FOCUS-FRAME after reading an event typed at FRAME.
2068 If FOCUS-FRAME is omitted or nil, any existing redirection is
2069 cancelled, and the frame again receives its own keystrokes.
2071 Focus redirection is useful for temporarily redirecting keystrokes to
2072 a surrogate minibuffer frame when a frame doesn't have its own
2075 A frame's focus redirection can be changed by `select-frame'. If frame
2076 FOO is selected, and then a different frame BAR is selected, any
2077 frames redirecting their focus to FOO are shifted to redirect their
2078 focus to BAR. This allows focus redirection to work properly when the
2079 user switches from one frame to another using `select-window'.
2081 This means that a frame whose focus is redirected to itself is treated
2082 differently from a frame whose focus is redirected to nil; the former
2083 is affected by `select-frame', while the latter is not.
2085 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2086 (frame
, focus_frame
)
2087 Lisp_Object frame
, focus_frame
;
2091 /* Note that we don't check for a live frame here. It's reasonable
2092 to redirect the focus of a frame you're about to delete, if you
2093 know what other frame should receive those keystrokes. */
2094 CHECK_FRAME (frame
);
2096 if (! NILP (focus_frame
))
2097 CHECK_LIVE_FRAME (focus_frame
);
2101 f
->focus_frame
= focus_frame
;
2103 if (FRAME_TERMINAL (f
)->frame_rehighlight_hook
)
2104 (*FRAME_TERMINAL (f
)->frame_rehighlight_hook
) (f
);
2110 DEFUN ("frame-focus", Fframe_focus
, Sframe_focus
, 1, 1, 0,
2111 doc
: /* Return the frame to which FRAME's keystrokes are currently being sent.
2112 This returns nil if FRAME's focus is not redirected.
2113 See `redirect-frame-focus'. */)
2117 CHECK_LIVE_FRAME (frame
);
2119 return FRAME_FOCUS_FRAME (XFRAME (frame
));
2124 /* Return the value of frame parameter PROP in frame FRAME. */
2127 get_frame_param (frame
, prop
)
2128 register struct frame
*frame
;
2131 register Lisp_Object tem
;
2133 tem
= Fassq (prop
, frame
->param_alist
);
2139 /* Return the buffer-predicate of the selected frame. */
2142 frame_buffer_predicate (frame
)
2145 return XFRAME (frame
)->buffer_predicate
;
2148 /* Return the buffer-list of the selected frame. */
2151 frame_buffer_list (frame
)
2154 return XFRAME (frame
)->buffer_list
;
2157 /* Set the buffer-list of the selected frame. */
2160 set_frame_buffer_list (frame
, list
)
2161 Lisp_Object frame
, list
;
2163 XFRAME (frame
)->buffer_list
= list
;
2166 /* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
2169 frames_discard_buffer (buffer
)
2172 Lisp_Object frame
, tail
;
2174 FOR_EACH_FRAME (tail
, frame
)
2176 XFRAME (frame
)->buffer_list
2177 = Fdelq (buffer
, XFRAME (frame
)->buffer_list
);
2178 XFRAME (frame
)->buried_buffer_list
2179 = Fdelq (buffer
, XFRAME (frame
)->buried_buffer_list
);
2183 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2184 If the alist already has an element for PROP, we change it. */
2187 store_in_alist (alistptr
, prop
, val
)
2188 Lisp_Object
*alistptr
, val
;
2191 register Lisp_Object tem
;
2193 tem
= Fassq (prop
, *alistptr
);
2195 *alistptr
= Fcons (Fcons (prop
, val
), *alistptr
);
2201 frame_name_fnn_p (str
, len
)
2205 if (len
> 1 && str
[0] == 'F')
2209 strtol (str
+ 1, &end_ptr
, 10);
2211 if (end_ptr
== str
+ len
)
2217 /* Set the name of the terminal frame. Also used by MSDOS frames.
2218 Modeled after x_set_name which is used for WINDOW frames. */
2221 set_term_frame_name (f
, name
)
2225 f
->explicit_name
= ! NILP (name
);
2227 /* If NAME is nil, set the name to F<num>. */
2232 /* Check for no change needed in this very common case
2233 before we do any consing. */
2234 if (frame_name_fnn_p (SDATA (f
->name
),
2239 sprintf (namebuf
, "F%d", tty_frame_count
);
2240 name
= build_string (namebuf
);
2244 CHECK_STRING (name
);
2246 /* Don't change the name if it's already NAME. */
2247 if (! NILP (Fstring_equal (name
, f
->name
)))
2250 /* Don't allow the user to set the frame name to F<num>, so it
2251 doesn't clash with the names we generate for terminal frames. */
2252 if (frame_name_fnn_p (SDATA (name
), SBYTES (name
)))
2253 error ("Frame names of the form F<num> are usurped by Emacs");
2257 update_mode_lines
= 1;
2261 store_frame_param (f
, prop
, val
)
2263 Lisp_Object prop
, val
;
2265 register Lisp_Object old_alist_elt
;
2267 /* The buffer-list parameters are stored in a special place and not
2269 if (EQ (prop
, Qbuffer_list
))
2271 f
->buffer_list
= val
;
2274 if (EQ (prop
, Qburied_buffer_list
))
2276 f
->buried_buffer_list
= val
;
2280 /* If PROP is a symbol which is supposed to have frame-local values,
2281 and it is set up based on this frame, switch to the global
2282 binding. That way, we can create or alter the frame-local binding
2283 without messing up the symbol's status. */
2286 Lisp_Object valcontents
;
2287 valcontents
= SYMBOL_VALUE (prop
);
2288 if ((BUFFER_LOCAL_VALUEP (valcontents
))
2289 && XBUFFER_LOCAL_VALUE (valcontents
)->check_frame
2290 && XBUFFER_LOCAL_VALUE (valcontents
)->found_for_frame
2291 && XFRAME (XBUFFER_LOCAL_VALUE (valcontents
)->frame
) == f
)
2292 swap_in_global_binding (prop
);
2295 /* The tty color needed to be set before the frame's parameter
2296 alist was updated with the new value. This is not true any more,
2297 but we still do this test early on. */
2298 if (FRAME_TERMCAP_P (f
) && EQ (prop
, Qtty_color_mode
)
2299 && f
== FRAME_TTY (f
)->previous_frame
)
2300 /* Force redisplay of this tty. */
2301 FRAME_TTY (f
)->previous_frame
= NULL
;
2303 /* Update the frame parameter alist. */
2304 old_alist_elt
= Fassq (prop
, f
->param_alist
);
2305 if (EQ (old_alist_elt
, Qnil
))
2306 f
->param_alist
= Fcons (Fcons (prop
, val
), f
->param_alist
);
2308 Fsetcdr (old_alist_elt
, val
);
2310 /* Update some other special parameters in their special places
2311 in addition to the alist. */
2313 if (EQ (prop
, Qbuffer_predicate
))
2314 f
->buffer_predicate
= val
;
2316 if (! FRAME_WINDOW_P (f
))
2318 if (EQ (prop
, Qmenu_bar_lines
))
2319 set_menu_bar_lines (f
, val
, make_number (FRAME_MENU_BAR_LINES (f
)));
2320 else if (EQ (prop
, Qname
))
2321 set_term_frame_name (f
, val
);
2324 if (EQ (prop
, Qminibuffer
) && WINDOWP (val
))
2326 if (! MINI_WINDOW_P (XWINDOW (val
)))
2327 error ("Surrogate minibuffer windows must be minibuffer windows");
2329 if ((FRAME_HAS_MINIBUF_P (f
) || FRAME_MINIBUF_ONLY_P (f
))
2330 && !EQ (val
, f
->minibuffer_window
))
2331 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2333 /* Install the chosen minibuffer window, with proper buffer. */
2334 f
->minibuffer_window
= val
;
2338 DEFUN ("frame-parameters", Fframe_parameters
, Sframe_parameters
, 0, 1, 0,
2339 doc
: /* Return the parameters-alist of frame FRAME.
2340 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2341 The meaningful PARMs depend on the kind of frame.
2342 If FRAME is omitted, return information on the currently selected frame. */)
2349 struct gcpro gcpro1
;
2352 frame
= selected_frame
;
2354 CHECK_FRAME (frame
);
2357 if (!FRAME_LIVE_P (f
))
2360 alist
= Fcopy_alist (f
->param_alist
);
2363 if (!FRAME_WINDOW_P (f
))
2365 int fg
= FRAME_FOREGROUND_PIXEL (f
);
2366 int bg
= FRAME_BACKGROUND_PIXEL (f
);
2369 /* If the frame's parameter alist says the colors are
2370 unspecified and reversed, take the frame's background pixel
2371 for foreground and vice versa. */
2372 elt
= Fassq (Qforeground_color
, alist
);
2373 if (CONSP (elt
) && STRINGP (XCDR (elt
)))
2375 if (strncmp (SDATA (XCDR (elt
)),
2377 SCHARS (XCDR (elt
))) == 0)
2378 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, bg
));
2379 else if (strncmp (SDATA (XCDR (elt
)),
2381 SCHARS (XCDR (elt
))) == 0)
2382 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2385 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2386 elt
= Fassq (Qbackground_color
, alist
);
2387 if (CONSP (elt
) && STRINGP (XCDR (elt
)))
2389 if (strncmp (SDATA (XCDR (elt
)),
2391 SCHARS (XCDR (elt
))) == 0)
2392 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, fg
));
2393 else if (strncmp (SDATA (XCDR (elt
)),
2395 SCHARS (XCDR (elt
))) == 0)
2396 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2399 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2400 store_in_alist (&alist
, intern ("font"),
2401 build_string (FRAME_MSDOS_P (f
)
2403 : FRAME_W32_P (f
) ? "w32term"
2406 store_in_alist (&alist
, Qname
, f
->name
);
2407 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2408 store_in_alist (&alist
, Qheight
, make_number (height
));
2409 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2410 store_in_alist (&alist
, Qwidth
, make_number (width
));
2411 store_in_alist (&alist
, Qmodeline
, (FRAME_WANTS_MODELINE_P (f
) ? Qt
: Qnil
));
2412 store_in_alist (&alist
, Qminibuffer
,
2413 (! FRAME_HAS_MINIBUF_P (f
) ? Qnil
2414 : FRAME_MINIBUF_ONLY_P (f
) ? Qonly
2415 : FRAME_MINIBUF_WINDOW (f
)));
2416 store_in_alist (&alist
, Qunsplittable
, (FRAME_NO_SPLIT_P (f
) ? Qt
: Qnil
));
2417 store_in_alist (&alist
, Qbuffer_list
, frame_buffer_list (frame
));
2418 store_in_alist (&alist
, Qburied_buffer_list
, XFRAME (frame
)->buried_buffer_list
);
2420 /* I think this should be done with a hook. */
2421 #ifdef HAVE_WINDOW_SYSTEM
2422 if (FRAME_WINDOW_P (f
))
2423 x_report_frame_params (f
, &alist
);
2427 /* This ought to be correct in f->param_alist for an X frame. */
2429 XSETFASTINT (lines
, FRAME_MENU_BAR_LINES (f
));
2430 store_in_alist (&alist
, Qmenu_bar_lines
, lines
);
2438 DEFUN ("frame-parameter", Fframe_parameter
, Sframe_parameter
, 2, 2, 0,
2439 doc
: /* Return FRAME's value for parameter PARAMETER.
2440 If FRAME is nil, describe the currently selected frame. */)
2442 Lisp_Object frame
, parameter
;
2448 frame
= selected_frame
;
2450 CHECK_FRAME (frame
);
2451 CHECK_SYMBOL (parameter
);
2456 if (FRAME_LIVE_P (f
))
2458 /* Avoid consing in frequent cases. */
2459 if (EQ (parameter
, Qname
))
2461 #ifdef HAVE_X_WINDOWS
2462 else if (EQ (parameter
, Qdisplay
) && FRAME_X_P (f
))
2463 value
= XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
);
2464 #endif /* HAVE_X_WINDOWS */
2465 else if (EQ (parameter
, Qbackground_color
)
2466 || EQ (parameter
, Qforeground_color
))
2468 value
= Fassq (parameter
, f
->param_alist
);
2471 value
= XCDR (value
);
2472 /* Fframe_parameters puts the actual fg/bg color names,
2473 even if f->param_alist says otherwise. This is
2474 important when param_alist's notion of colors is
2475 "unspecified". We need to do the same here. */
2476 if (STRINGP (value
) && !FRAME_WINDOW_P (f
))
2478 const char *color_name
;
2481 if (EQ (parameter
, Qbackground_color
))
2483 color_name
= SDATA (value
);
2484 csz
= SCHARS (value
);
2485 if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2486 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2487 else if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2488 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2490 else if (EQ (parameter
, Qforeground_color
))
2492 color_name
= SDATA (value
);
2493 csz
= SCHARS (value
);
2494 if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2495 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2496 else if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2497 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2502 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2504 else if (EQ (parameter
, Qdisplay_type
)
2505 || EQ (parameter
, Qbackground_mode
))
2506 value
= Fcdr (Fassq (parameter
, f
->param_alist
));
2508 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2515 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters
,
2516 Smodify_frame_parameters
, 2, 2, 0,
2517 doc
: /* Modify the parameters of frame FRAME according to ALIST.
2518 If FRAME is nil, it defaults to the selected frame.
2519 ALIST is an alist of parameters to change and their new values.
2520 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2521 The meaningful PARMs depend on the kind of frame.
2522 Undefined PARMs are ignored, but stored in the frame's parameter list
2523 so that `frame-parameters' will return them.
2525 The value of frame parameter FOO can also be accessed
2526 as a frame-local binding for the variable FOO, if you have
2527 enabled such bindings for that variable with `make-variable-frame-local'.
2528 Note that this functionality is obsolete as of Emacs 22.2, and its
2529 use is not recommended. Explicitly check for a frame-parameter instead. */)
2531 Lisp_Object frame
, alist
;
2534 register Lisp_Object tail
, prop
, val
;
2536 if (EQ (frame
, Qnil
))
2537 frame
= selected_frame
;
2538 CHECK_LIVE_FRAME (frame
);
2541 /* I think this should be done with a hook. */
2542 #ifdef HAVE_WINDOW_SYSTEM
2543 if (FRAME_WINDOW_P (f
))
2544 x_set_frame_parameters (f
, alist
);
2548 if (FRAME_MSDOS_P (f
))
2549 IT_set_frame_parameters (f
, alist
);
2554 int length
= XINT (Flength (alist
));
2557 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2559 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2561 /* Extract parm names and values into those vectors. */
2564 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
2569 parms
[i
] = Fcar (elt
);
2570 values
[i
] = Fcdr (elt
);
2574 /* Now process them in reverse of specified order. */
2575 for (i
--; i
>= 0; i
--)
2579 store_frame_param (f
, prop
, val
);
2581 /* Changing the background color might change the background
2582 mode, so that we have to load new defface specs.
2583 Call frame-set-background-mode to do that. */
2584 if (EQ (prop
, Qbackground_color
))
2585 call1 (Qframe_set_background_mode
, frame
);
2591 DEFUN ("frame-char-height", Fframe_char_height
, Sframe_char_height
,
2593 doc
: /* Height in pixels of a line in the font in frame FRAME.
2594 If FRAME is omitted, the selected frame is used.
2595 For a terminal frame, the value is always 1. */)
2602 frame
= selected_frame
;
2603 CHECK_FRAME (frame
);
2606 #ifdef HAVE_WINDOW_SYSTEM
2607 if (FRAME_WINDOW_P (f
))
2608 return make_number (x_char_height (f
));
2611 return make_number (1);
2615 DEFUN ("frame-char-width", Fframe_char_width
, Sframe_char_width
,
2617 doc
: /* Width in pixels of characters in the font in frame FRAME.
2618 If FRAME is omitted, the selected frame is used.
2619 On a graphical screen, the width is the standard width of the default font.
2620 For a terminal screen, the value is always 1. */)
2627 frame
= selected_frame
;
2628 CHECK_FRAME (frame
);
2631 #ifdef HAVE_WINDOW_SYSTEM
2632 if (FRAME_WINDOW_P (f
))
2633 return make_number (x_char_width (f
));
2636 return make_number (1);
2639 DEFUN ("frame-pixel-height", Fframe_pixel_height
,
2640 Sframe_pixel_height
, 0, 1, 0,
2641 doc
: /* Return a FRAME's height in pixels.
2642 This counts only the height available for text lines,
2643 not menu bars on window-system Emacs frames.
2644 For a terminal frame, the result really gives the height in characters.
2645 If FRAME is omitted, the selected frame is used. */)
2652 frame
= selected_frame
;
2653 CHECK_FRAME (frame
);
2656 #ifdef HAVE_WINDOW_SYSTEM
2657 if (FRAME_WINDOW_P (f
))
2658 return make_number (x_pixel_height (f
));
2661 return make_number (FRAME_LINES (f
));
2664 DEFUN ("frame-pixel-width", Fframe_pixel_width
,
2665 Sframe_pixel_width
, 0, 1, 0,
2666 doc
: /* Return FRAME's width in pixels.
2667 For a terminal frame, the result really gives the width in characters.
2668 If FRAME is omitted, the selected frame is used. */)
2675 frame
= selected_frame
;
2676 CHECK_FRAME (frame
);
2679 #ifdef HAVE_WINDOW_SYSTEM
2680 if (FRAME_WINDOW_P (f
))
2681 return make_number (x_pixel_width (f
));
2684 return make_number (FRAME_COLS (f
));
2687 DEFUN ("set-frame-height", Fset_frame_height
, Sset_frame_height
, 2, 3, 0,
2688 doc
: /* Specify that the frame FRAME has LINES lines.
2689 Optional third arg non-nil means that redisplay should use LINES lines
2690 but that the idea of the actual height of the frame should not be changed. */)
2691 (frame
, lines
, pretend
)
2692 Lisp_Object frame
, lines
, pretend
;
2694 register struct frame
*f
;
2696 CHECK_NUMBER (lines
);
2698 frame
= selected_frame
;
2699 CHECK_LIVE_FRAME (frame
);
2702 /* I think this should be done with a hook. */
2703 #ifdef HAVE_WINDOW_SYSTEM
2704 if (FRAME_WINDOW_P (f
))
2706 if (XINT (lines
) != FRAME_LINES (f
))
2707 x_set_window_size (f
, 1, FRAME_COLS (f
), XINT (lines
));
2708 do_pending_window_change (0);
2712 change_frame_size (f
, XINT (lines
), 0, !NILP (pretend
), 0, 0);
2716 DEFUN ("set-frame-width", Fset_frame_width
, Sset_frame_width
, 2, 3, 0,
2717 doc
: /* Specify that the frame FRAME has COLS columns.
2718 Optional third arg non-nil means that redisplay should use COLS columns
2719 but that the idea of the actual width of the frame should not be changed. */)
2720 (frame
, cols
, pretend
)
2721 Lisp_Object frame
, cols
, pretend
;
2723 register struct frame
*f
;
2724 CHECK_NUMBER (cols
);
2726 frame
= selected_frame
;
2727 CHECK_LIVE_FRAME (frame
);
2730 /* I think this should be done with a hook. */
2731 #ifdef HAVE_WINDOW_SYSTEM
2732 if (FRAME_WINDOW_P (f
))
2734 if (XINT (cols
) != FRAME_COLS (f
))
2735 x_set_window_size (f
, 1, XINT (cols
), FRAME_LINES (f
));
2736 do_pending_window_change (0);
2740 change_frame_size (f
, 0, XINT (cols
), !NILP (pretend
), 0, 0);
2744 DEFUN ("set-frame-size", Fset_frame_size
, Sset_frame_size
, 3, 3, 0,
2745 doc
: /* Sets size of FRAME to COLS by ROWS, measured in characters. */)
2747 Lisp_Object frame
, cols
, rows
;
2749 register struct frame
*f
;
2751 CHECK_LIVE_FRAME (frame
);
2752 CHECK_NUMBER (cols
);
2753 CHECK_NUMBER (rows
);
2756 /* I think this should be done with a hook. */
2757 #ifdef HAVE_WINDOW_SYSTEM
2758 if (FRAME_WINDOW_P (f
))
2760 if (XINT (rows
) != FRAME_LINES (f
)
2761 || XINT (cols
) != FRAME_COLS (f
)
2762 || f
->new_text_lines
|| f
->new_text_cols
)
2763 x_set_window_size (f
, 1, XINT (cols
), XINT (rows
));
2764 do_pending_window_change (0);
2768 change_frame_size (f
, XINT (rows
), XINT (cols
), 0, 0, 0);
2773 DEFUN ("set-frame-position", Fset_frame_position
,
2774 Sset_frame_position
, 3, 3, 0,
2775 doc
: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2776 This is actually the position of the upper left corner of the frame.
2777 Negative values for XOFFSET or YOFFSET are interpreted relative to
2778 the rightmost or bottommost possible position (that stays within the screen). */)
2779 (frame
, xoffset
, yoffset
)
2780 Lisp_Object frame
, xoffset
, yoffset
;
2782 register struct frame
*f
;
2784 CHECK_LIVE_FRAME (frame
);
2785 CHECK_NUMBER (xoffset
);
2786 CHECK_NUMBER (yoffset
);
2789 /* I think this should be done with a hook. */
2790 #ifdef HAVE_WINDOW_SYSTEM
2791 if (FRAME_WINDOW_P (f
))
2792 x_set_offset (f
, XINT (xoffset
), XINT (yoffset
), 1);
2799 /***********************************************************************
2801 ***********************************************************************/
2803 /* Connect the frame-parameter names for X frames
2804 to the ways of passing the parameter values to the window system.
2806 The name of a parameter, as a Lisp symbol,
2807 has an `x-frame-parameter' property which is an integer in Lisp
2808 that is an index in this table. */
2810 struct frame_parm_table
{
2812 Lisp_Object
*variable
;
2815 static struct frame_parm_table frame_parms
[] =
2817 {"auto-raise", &Qauto_raise
},
2818 {"auto-lower", &Qauto_lower
},
2819 {"background-color", 0},
2820 {"border-color", &Qborder_color
},
2821 {"border-width", &Qborder_width
},
2822 {"cursor-color", &Qcursor_color
},
2823 {"cursor-type", &Qcursor_type
},
2825 {"foreground-color", 0},
2826 {"icon-name", &Qicon_name
},
2827 {"icon-type", &Qicon_type
},
2828 {"internal-border-width", &Qinternal_border_width
},
2829 {"menu-bar-lines", &Qmenu_bar_lines
},
2830 {"mouse-color", &Qmouse_color
},
2832 {"scroll-bar-width", &Qscroll_bar_width
},
2834 {"unsplittable", &Qunsplittable
},
2835 {"vertical-scroll-bars", &Qvertical_scroll_bars
},
2836 {"visibility", &Qvisibility
},
2837 {"tool-bar-lines", &Qtool_bar_lines
},
2838 {"scroll-bar-foreground", &Qscroll_bar_foreground
},
2839 {"scroll-bar-background", &Qscroll_bar_background
},
2840 {"screen-gamma", &Qscreen_gamma
},
2841 {"line-spacing", &Qline_spacing
},
2842 {"left-fringe", &Qleft_fringe
},
2843 {"right-fringe", &Qright_fringe
},
2844 {"wait-for-wm", &Qwait_for_wm
},
2845 {"fullscreen", &Qfullscreen
},
2846 {"font-backend", &Qfont_backend
},
2850 #ifdef HAVE_WINDOW_SYSTEM
2852 extern Lisp_Object Qbox
;
2853 extern Lisp_Object Qtop
;
2855 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
2856 wanted positions of the WM window (not Emacs window).
2857 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
2858 window (FRAME_X_WINDOW).
2862 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
2869 int newwidth
= FRAME_COLS (f
);
2870 int newheight
= FRAME_LINES (f
);
2871 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2873 *top_pos
= f
->top_pos
;
2874 *left_pos
= f
->left_pos
;
2876 if (f
->want_fullscreen
& FULLSCREEN_HEIGHT
)
2880 ph
= x_display_pixel_height (dpyinfo
);
2881 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2882 ph
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, newheight
) - f
->y_pixels_diff
;
2883 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2887 if (f
->want_fullscreen
& FULLSCREEN_WIDTH
)
2891 pw
= x_display_pixel_width (dpyinfo
);
2892 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2893 pw
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, newwidth
) - f
->x_pixels_diff
;
2894 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2899 *height
= newheight
;
2903 /* Change the parameters of frame F as specified by ALIST.
2904 If a parameter is not specially recognized, do nothing special;
2905 otherwise call the `x_set_...' function for that parameter.
2906 Except for certain geometry properties, always call store_frame_param
2907 to store the new value in the parameter alist. */
2910 x_set_frame_parameters (f
, alist
)
2916 /* If both of these parameters are present, it's more efficient to
2917 set them both at once. So we wait until we've looked at the
2918 entire list before we set them. */
2922 Lisp_Object left
, top
;
2924 /* Same with these. */
2925 Lisp_Object icon_left
, icon_top
;
2927 /* Record in these vectors all the parms specified. */
2929 Lisp_Object
*values
;
2931 int left_no_change
= 0, top_no_change
= 0;
2932 int icon_left_no_change
= 0, icon_top_no_change
= 0;
2933 int size_changed
= 0;
2934 struct gcpro gcpro1
, gcpro2
;
2937 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2940 parms
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2941 values
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2943 /* Extract parm names and values into those vectors. */
2946 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
2951 parms
[i
] = Fcar (elt
);
2952 values
[i
] = Fcdr (elt
);
2955 /* TAIL and ALIST are not used again below here. */
2956 alist
= tail
= Qnil
;
2958 GCPRO2 (*parms
, *values
);
2962 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
2963 because their values appear in VALUES and strings are not valid. */
2964 top
= left
= Qunbound
;
2965 icon_left
= icon_top
= Qunbound
;
2967 /* Provide default values for HEIGHT and WIDTH. */
2968 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2969 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2971 /* Process foreground_color and background_color before anything else.
2972 They are independent of other properties, but other properties (e.g.,
2973 cursor_color) are dependent upon them. */
2974 /* Process default font as well, since fringe widths depends on it. */
2975 for (p
= 0; p
< i
; p
++)
2977 Lisp_Object prop
, val
;
2981 if (EQ (prop
, Qforeground_color
)
2982 || EQ (prop
, Qbackground_color
)
2983 || EQ (prop
, Qfont
))
2985 register Lisp_Object param_index
, old_value
;
2987 old_value
= get_frame_param (f
, prop
);
2988 if (NILP (Fequal (val
, old_value
)))
2990 store_frame_param (f
, prop
, val
);
2992 param_index
= Fget (prop
, Qx_frame_parameter
);
2993 if (NATNUMP (param_index
)
2994 && (XFASTINT (param_index
)
2995 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
2996 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
2997 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
3002 /* Now process them in reverse of specified order. */
3003 for (i
--; i
>= 0; i
--)
3005 Lisp_Object prop
, val
;
3010 if (EQ (prop
, Qwidth
) && NATNUMP (val
))
3013 width
= XFASTINT (val
);
3015 else if (EQ (prop
, Qheight
) && NATNUMP (val
))
3018 height
= XFASTINT (val
);
3020 else if (EQ (prop
, Qtop
))
3022 else if (EQ (prop
, Qleft
))
3024 else if (EQ (prop
, Qicon_top
))
3026 else if (EQ (prop
, Qicon_left
))
3028 else if (EQ (prop
, Qforeground_color
)
3029 || EQ (prop
, Qbackground_color
)
3030 || EQ (prop
, Qfont
))
3031 /* Processed above. */
3035 register Lisp_Object param_index
, old_value
;
3037 old_value
= get_frame_param (f
, prop
);
3039 store_frame_param (f
, prop
, val
);
3041 param_index
= Fget (prop
, Qx_frame_parameter
);
3042 if (NATNUMP (param_index
)
3043 && (XFASTINT (param_index
)
3044 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3045 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
3046 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
3050 /* Don't die if just one of these was set. */
3051 if (EQ (left
, Qunbound
))
3054 if (f
->left_pos
< 0)
3055 left
= Fcons (Qplus
, Fcons (make_number (f
->left_pos
), Qnil
));
3057 XSETINT (left
, f
->left_pos
);
3059 if (EQ (top
, Qunbound
))
3063 top
= Fcons (Qplus
, Fcons (make_number (f
->top_pos
), Qnil
));
3065 XSETINT (top
, f
->top_pos
);
3068 /* If one of the icon positions was not set, preserve or default it. */
3069 if (EQ (icon_left
, Qunbound
) || ! INTEGERP (icon_left
))
3071 icon_left_no_change
= 1;
3072 icon_left
= Fcdr (Fassq (Qicon_left
, f
->param_alist
));
3073 if (NILP (icon_left
))
3074 XSETINT (icon_left
, 0);
3076 if (EQ (icon_top
, Qunbound
) || ! INTEGERP (icon_top
))
3078 icon_top_no_change
= 1;
3079 icon_top
= Fcdr (Fassq (Qicon_top
, f
->param_alist
));
3080 if (NILP (icon_top
))
3081 XSETINT (icon_top
, 0);
3084 /* Don't set these parameters unless they've been explicitly
3085 specified. The window might be mapped or resized while we're in
3086 this function, and we don't want to override that unless the lisp
3087 code has asked for it.
3089 Don't set these parameters unless they actually differ from the
3090 window's current parameters; the window may not actually exist
3095 check_frame_size (f
, &height
, &width
);
3097 XSETFRAME (frame
, f
);
3100 && (width
!= FRAME_COLS (f
)
3101 || height
!= FRAME_LINES (f
)
3102 || f
->new_text_lines
|| f
->new_text_cols
))
3103 Fset_frame_size (frame
, make_number (width
), make_number (height
));
3105 if ((!NILP (left
) || !NILP (top
))
3106 && ! (left_no_change
&& top_no_change
)
3107 && ! (NUMBERP (left
) && XINT (left
) == f
->left_pos
3108 && NUMBERP (top
) && XINT (top
) == f
->top_pos
))
3113 /* Record the signs. */
3114 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3115 if (EQ (left
, Qminus
))
3116 f
->size_hint_flags
|= XNegative
;
3117 else if (INTEGERP (left
))
3119 leftpos
= XINT (left
);
3121 f
->size_hint_flags
|= XNegative
;
3123 else if (CONSP (left
) && EQ (XCAR (left
), Qminus
)
3124 && CONSP (XCDR (left
))
3125 && INTEGERP (XCAR (XCDR (left
))))
3127 leftpos
= - XINT (XCAR (XCDR (left
)));
3128 f
->size_hint_flags
|= XNegative
;
3130 else if (CONSP (left
) && EQ (XCAR (left
), Qplus
)
3131 && CONSP (XCDR (left
))
3132 && INTEGERP (XCAR (XCDR (left
))))
3134 leftpos
= XINT (XCAR (XCDR (left
)));
3137 if (EQ (top
, Qminus
))
3138 f
->size_hint_flags
|= YNegative
;
3139 else if (INTEGERP (top
))
3141 toppos
= XINT (top
);
3143 f
->size_hint_flags
|= YNegative
;
3145 else if (CONSP (top
) && EQ (XCAR (top
), Qminus
)
3146 && CONSP (XCDR (top
))
3147 && INTEGERP (XCAR (XCDR (top
))))
3149 toppos
= - XINT (XCAR (XCDR (top
)));
3150 f
->size_hint_flags
|= YNegative
;
3152 else if (CONSP (top
) && EQ (XCAR (top
), Qplus
)
3153 && CONSP (XCDR (top
))
3154 && INTEGERP (XCAR (XCDR (top
))))
3156 toppos
= XINT (XCAR (XCDR (top
)));
3160 /* Store the numeric value of the position. */
3161 f
->top_pos
= toppos
;
3162 f
->left_pos
= leftpos
;
3164 f
->win_gravity
= NorthWestGravity
;
3166 /* Actually set that position, and convert to absolute. */
3167 x_set_offset (f
, leftpos
, toppos
, -1);
3170 if ((!NILP (icon_left
) || !NILP (icon_top
))
3171 && ! (icon_left_no_change
&& icon_top_no_change
))
3172 x_wm_set_icon_position (f
, XINT (icon_left
), XINT (icon_top
));
3179 /* Insert a description of internally-recorded parameters of frame X
3180 into the parameter alist *ALISTPTR that is to be given to the user.
3181 Only parameters that are specific to the X window system
3182 and whose values are not correctly recorded in the frame's
3183 param_alist need to be considered here. */
3186 x_report_frame_params (f
, alistptr
)
3188 Lisp_Object
*alistptr
;
3193 /* Represent negative positions (off the top or left screen edge)
3194 in a way that Fmodify_frame_parameters will understand correctly. */
3195 XSETINT (tem
, f
->left_pos
);
3196 if (f
->left_pos
>= 0)
3197 store_in_alist (alistptr
, Qleft
, tem
);
3199 store_in_alist (alistptr
, Qleft
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3201 XSETINT (tem
, f
->top_pos
);
3202 if (f
->top_pos
>= 0)
3203 store_in_alist (alistptr
, Qtop
, tem
);
3205 store_in_alist (alistptr
, Qtop
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3207 store_in_alist (alistptr
, Qborder_width
,
3208 make_number (f
->border_width
));
3209 store_in_alist (alistptr
, Qinternal_border_width
,
3210 make_number (FRAME_INTERNAL_BORDER_WIDTH (f
)));
3211 store_in_alist (alistptr
, Qleft_fringe
,
3212 make_number (FRAME_LEFT_FRINGE_WIDTH (f
)));
3213 store_in_alist (alistptr
, Qright_fringe
,
3214 make_number (FRAME_RIGHT_FRINGE_WIDTH (f
)));
3215 store_in_alist (alistptr
, Qscroll_bar_width
,
3216 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3218 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
3219 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3220 /* nil means "use default width"
3221 for non-toolkit scroll bar.
3222 ruler-mode.el depends on this. */
3224 sprintf (buf
, "%ld", (long) FRAME_X_WINDOW (f
));
3225 store_in_alist (alistptr
, Qwindow_id
,
3226 build_string (buf
));
3227 #ifdef HAVE_X_WINDOWS
3228 #ifdef USE_X_TOOLKIT
3229 /* Tooltip frame may not have this widget. */
3230 if (FRAME_X_OUTPUT (f
)->widget
)
3232 sprintf (buf
, "%ld", (long) FRAME_OUTER_WINDOW (f
));
3233 store_in_alist (alistptr
, Qouter_window_id
,
3234 build_string (buf
));
3236 store_in_alist (alistptr
, Qicon_name
, f
->icon_name
);
3237 FRAME_SAMPLE_VISIBILITY (f
);
3238 store_in_alist (alistptr
, Qvisibility
,
3239 (FRAME_VISIBLE_P (f
) ? Qt
3240 : FRAME_ICONIFIED_P (f
) ? Qicon
: Qnil
));
3241 store_in_alist (alistptr
, Qdisplay
,
3242 XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
3244 if (FRAME_X_OUTPUT (f
)->parent_desc
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
3247 XSETFASTINT (tem
, FRAME_X_OUTPUT (f
)->parent_desc
);
3248 store_in_alist (alistptr
, Qexplicit_name
, (f
->explicit_name
? Qt
: Qnil
));
3249 store_in_alist (alistptr
, Qparent_id
, tem
);
3253 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3254 the previous value of that parameter, NEW_VALUE is the new value. */
3257 x_set_fullscreen (f
, new_value
, old_value
)
3259 Lisp_Object new_value
, old_value
;
3261 if (NILP (new_value
))
3262 f
->want_fullscreen
= FULLSCREEN_NONE
;
3263 else if (EQ (new_value
, Qfullboth
) || EQ (new_value
, Qfullscreen
))
3264 f
->want_fullscreen
= FULLSCREEN_BOTH
;
3265 else if (EQ (new_value
, Qfullwidth
))
3266 f
->want_fullscreen
= FULLSCREEN_WIDTH
;
3267 else if (EQ (new_value
, Qfullheight
))
3268 f
->want_fullscreen
= FULLSCREEN_HEIGHT
;
3269 else if (EQ (new_value
, Qmaximized
))
3270 f
->want_fullscreen
= FULLSCREEN_MAXIMIZED
;
3272 if (FRAME_TERMINAL (f
)->fullscreen_hook
!= NULL
)
3273 FRAME_TERMINAL (f
)->fullscreen_hook (f
);
3277 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3278 the previous value of that parameter, NEW_VALUE is the new value. */
3281 x_set_line_spacing (f
, new_value
, old_value
)
3283 Lisp_Object new_value
, old_value
;
3285 if (NILP (new_value
))
3286 f
->extra_line_spacing
= 0;
3287 else if (NATNUMP (new_value
))
3288 f
->extra_line_spacing
= XFASTINT (new_value
);
3290 signal_error ("Invalid line-spacing", new_value
);
3291 if (FRAME_VISIBLE_P (f
))
3296 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3297 the previous value of that parameter, NEW_VALUE is the new value. */
3300 x_set_screen_gamma (f
, new_value
, old_value
)
3302 Lisp_Object new_value
, old_value
;
3304 Lisp_Object bgcolor
;
3306 if (NILP (new_value
))
3308 else if (NUMBERP (new_value
) && XFLOATINT (new_value
) > 0)
3309 /* The value 0.4545 is the normal viewing gamma. */
3310 f
->gamma
= 1.0 / (0.4545 * XFLOATINT (new_value
));
3312 signal_error ("Invalid screen-gamma", new_value
);
3314 /* Apply the new gamma value to the frame background. */
3315 bgcolor
= Fassq (Qbackground_color
, f
->param_alist
);
3316 if (CONSP (bgcolor
) && (bgcolor
= XCDR (bgcolor
), STRINGP (bgcolor
)))
3318 Lisp_Object index
= Fget (Qbackground_color
, Qx_frame_parameter
);
3320 && (XFASTINT (index
)
3321 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3322 && FRAME_RIF (f
)->frame_parm_handlers
[XFASTINT (index
)])
3323 (*FRAME_RIF (f
)->frame_parm_handlers
[XFASTINT (index
)])
3327 Fclear_face_cache (Qnil
);
3332 x_set_font (f
, arg
, oldval
)
3334 Lisp_Object arg
, oldval
;
3336 Lisp_Object frame
, font_object
, lval
;
3339 /* Set the frame parameter back to the old value because we may
3340 fail to use ARG as the new parameter value. */
3341 store_frame_param (f
, Qfont
, oldval
);
3343 /* ARG is a fontset name, a font name, a cons of fontset name and a
3344 font object, or a font object. In the last case, this function
3348 fontset
= fs_query_fontset (arg
, 0);
3351 font_object
= font_open_by_name (f
, SDATA (arg
));
3352 if (NILP (font_object
))
3353 error ("Font `%s' is not defined", SDATA (arg
));
3354 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3356 else if (fontset
> 0)
3358 Lisp_Object ascii_font
= fontset_ascii (fontset
);
3360 font_object
= font_open_by_name (f
, SDATA (ascii_font
));
3361 if (NILP (font_object
))
3362 error ("Font `%s' is not defined", SDATA (arg
));
3363 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3366 error ("The default fontset can't be used for a frame font");
3368 else if (CONSP (arg
) && STRINGP (XCAR (arg
)) && FONT_OBJECT_P (XCDR (arg
)))
3370 /* This is the case that the ASCII font of F's fontset XCAR
3371 (arg) is changed to the font XCDR (arg) by
3372 `set-fontset-font'. */
3373 fontset
= fs_query_fontset (XCAR (arg
), 0);
3375 error ("Unknown fontset: %s", SDATA (XCAR (arg
)));
3376 font_object
= XCDR (arg
);
3377 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3379 else if (FONT_OBJECT_P (arg
))
3382 /* This is to store the XLFD font name in the frame parameter for
3383 backward compatiblity. We should store the font-object
3384 itself in the future. */
3385 arg
= AREF (font_object
, FONT_NAME_INDEX
);
3386 fontset
= FRAME_FONTSET (f
);
3387 /* Check if we can use the current fontset. If not, set FONTSET
3388 to -1 to generate a new fontset from FONT-OBJECT. */
3391 Lisp_Object ascii_font
= fontset_ascii (fontset
);
3392 Lisp_Object spec
= font_spec_from_name (ascii_font
);
3394 if (! font_match_p (spec
, font_object
))
3399 signal_error ("Invalid font", arg
);
3401 if (! NILP (Fequal (font_object
, oldval
)))
3405 lval
= Fassq (Qfullscreen
, f
->param_alist
);
3406 if (CONSP (lval
)) lval
= CDR (lval
);
3408 x_new_font (f
, font_object
, fontset
);
3409 store_frame_param (f
, Qfont
, arg
);
3410 /* Recalculate toolbar height. */
3411 f
->n_tool_bar_rows
= 0;
3412 /* Ensure we redraw it. */
3413 clear_current_matrices (f
);
3415 recompute_basic_faces (f
);
3417 do_pending_window_change (0);
3419 /* We used to call face-set-after-frame-default here, but it leads to
3420 recursive calls (since that function can set the `default' face's
3421 font which in turns changes the frame's `font' parameter).
3422 Also I don't know what this call is meant to do, but it seems the
3423 wrong way to do it anyway (it does a lot more work than what seems
3424 reasonable in response to a change to `font'). */
3429 x_set_font_backend (f
, new_value
, old_value
)
3431 Lisp_Object new_value
, old_value
;
3433 if (! NILP (new_value
)
3434 && !CONSP (new_value
))
3438 CHECK_STRING (new_value
);
3439 p0
= p1
= SDATA (new_value
);
3443 while (*p1
&& ! isspace (*p1
) && *p1
!= ',') p1
++;
3445 new_value
= Fcons (Fintern (make_string (p0
, p1
- p0
), Qnil
),
3451 while ((c
= *++p1
) && isspace (c
));
3455 new_value
= Fnreverse (new_value
);
3458 if (! NILP (old_value
) && ! NILP (Fequal (old_value
, new_value
)))
3462 free_all_realized_faces (Qnil
);
3464 new_value
= font_update_drivers (f
, NILP (new_value
) ? Qt
: new_value
);
3465 if (NILP (new_value
))
3467 if (NILP (old_value
))
3468 error ("No font backend available");
3469 font_update_drivers (f
, old_value
);
3470 error ("None of specified font backends are available");
3472 store_frame_param (f
, Qfont_backend
, new_value
);
3478 XSETFRAME (frame
, f
);
3479 x_set_font (f
, Fframe_parameter (frame
, Qfont
), Qnil
);
3480 ++face_change_count
;
3481 ++windows_or_buffers_changed
;
3487 x_set_fringe_width (f
, new_value
, old_value
)
3489 Lisp_Object new_value
, old_value
;
3491 compute_fringe_widths (f
, 1);
3495 x_set_border_width (f
, arg
, oldval
)
3497 Lisp_Object arg
, oldval
;
3501 if (XINT (arg
) == f
->border_width
)
3504 if (FRAME_X_WINDOW (f
) != 0)
3505 error ("Cannot change the border width of a frame");
3507 f
->border_width
= XINT (arg
);
3511 x_set_internal_border_width (f
, arg
, oldval
)
3513 Lisp_Object arg
, oldval
;
3515 int old
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3518 FRAME_INTERNAL_BORDER_WIDTH (f
) = XINT (arg
);
3519 if (FRAME_INTERNAL_BORDER_WIDTH (f
) < 0)
3520 FRAME_INTERNAL_BORDER_WIDTH (f
) = 0;
3522 #ifdef USE_X_TOOLKIT
3523 if (FRAME_X_OUTPUT (f
)->edit_widget
)
3524 widget_store_internal_border (FRAME_X_OUTPUT (f
)->edit_widget
);
3527 if (FRAME_INTERNAL_BORDER_WIDTH (f
) == old
)
3530 if (FRAME_X_WINDOW (f
) != 0)
3532 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3533 SET_FRAME_GARBAGED (f
);
3534 do_pending_window_change (0);
3537 SET_FRAME_GARBAGED (f
);
3541 x_set_visibility (f
, value
, oldval
)
3543 Lisp_Object value
, oldval
;
3546 XSETFRAME (frame
, f
);
3549 Fmake_frame_invisible (frame
, Qt
);
3550 else if (EQ (value
, Qicon
))
3551 Ficonify_frame (frame
);
3553 Fmake_frame_visible (frame
);
3557 x_set_autoraise (f
, arg
, oldval
)
3559 Lisp_Object arg
, oldval
;
3561 f
->auto_raise
= !EQ (Qnil
, arg
);
3565 x_set_autolower (f
, arg
, oldval
)
3567 Lisp_Object arg
, oldval
;
3569 f
->auto_lower
= !EQ (Qnil
, arg
);
3573 x_set_unsplittable (f
, arg
, oldval
)
3575 Lisp_Object arg
, oldval
;
3577 f
->no_split
= !NILP (arg
);
3581 x_set_vertical_scroll_bars (f
, arg
, oldval
)
3583 Lisp_Object arg
, oldval
;
3585 if ((EQ (arg
, Qleft
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3586 || (EQ (arg
, Qright
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
3587 || (NILP (arg
) && FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3588 || (!NILP (arg
) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)))
3590 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
)
3592 ? vertical_scroll_bar_none
3594 ? vertical_scroll_bar_left
3596 ? vertical_scroll_bar_right
3597 : EQ (Qleft
, Vdefault_frame_scroll_bars
)
3598 ? vertical_scroll_bar_left
3599 : EQ (Qright
, Vdefault_frame_scroll_bars
)
3600 ? vertical_scroll_bar_right
3601 : vertical_scroll_bar_none
);
3603 /* We set this parameter before creating the X window for the
3604 frame, so we can get the geometry right from the start.
3605 However, if the window hasn't been created yet, we shouldn't
3606 call x_set_window_size. */
3607 if (FRAME_X_WINDOW (f
))
3608 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3609 do_pending_window_change (0);
3614 x_set_scroll_bar_width (f
, arg
, oldval
)
3616 Lisp_Object arg
, oldval
;
3618 int wid
= FRAME_COLUMN_WIDTH (f
);
3622 x_set_scroll_bar_default_width (f
);
3624 if (FRAME_X_WINDOW (f
))
3625 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3626 do_pending_window_change (0);
3628 else if (INTEGERP (arg
) && XINT (arg
) > 0
3629 && XFASTINT (arg
) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3631 if (XFASTINT (arg
) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
3632 XSETINT (arg
, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
+ 1);
3634 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = XFASTINT (arg
);
3635 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (XFASTINT (arg
) + wid
-1) / wid
;
3636 if (FRAME_X_WINDOW (f
))
3637 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3638 do_pending_window_change (0);
3641 change_frame_size (f
, 0, FRAME_COLS (f
), 0, 0, 0);
3642 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.hpos
= 0;
3643 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.x
= 0;
3648 /* Return non-nil if frame F wants a bitmap icon. */
3656 tem
= assq_no_quit (Qicon_type
, f
->param_alist
);
3664 x_set_alpha (f
, arg
, oldval
)
3666 Lisp_Object arg
, oldval
;
3673 for (i
= 0; i
< 2; i
++)
3686 else if (FLOATP (item
))
3688 alpha
= XFLOAT_DATA (item
);
3689 if (alpha
< 0.0 || 1.0 < alpha
)
3690 args_out_of_range (make_float (0.0), make_float (1.0));
3692 else if (INTEGERP (item
))
3694 ialpha
= XINT (item
);
3695 if (ialpha
< 0 || 100 < ialpha
)
3696 args_out_of_range (make_number (0), make_number (100));
3698 alpha
= ialpha
/ 100.0;
3701 wrong_type_argument (Qnumberp
, item
);
3705 for (i
= 0; i
< 2; i
++)
3706 f
->alpha
[i
] = newval
[i
];
3708 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA)
3710 x_set_frame_alpha (f
);
3718 /* Subroutines of creating an X frame. */
3720 /* Make sure that Vx_resource_name is set to a reasonable value.
3721 Fix it up, or set it to `emacs' if it is too hopeless. */
3724 validate_x_resource_name ()
3727 /* Number of valid characters in the resource name. */
3729 /* Number of invalid characters in the resource name. */
3734 if (!STRINGP (Vx_resource_class
))
3735 Vx_resource_class
= build_string (EMACS_CLASS
);
3737 if (STRINGP (Vx_resource_name
))
3739 unsigned char *p
= SDATA (Vx_resource_name
);
3742 len
= SBYTES (Vx_resource_name
);
3744 /* Only letters, digits, - and _ are valid in resource names.
3745 Count the valid characters and count the invalid ones. */
3746 for (i
= 0; i
< len
; i
++)
3749 if (! ((c
>= 'a' && c
<= 'z')
3750 || (c
>= 'A' && c
<= 'Z')
3751 || (c
>= '0' && c
<= '9')
3752 || c
== '-' || c
== '_'))
3759 /* Not a string => completely invalid. */
3760 bad_count
= 5, good_count
= 0;
3762 /* If name is valid already, return. */
3766 /* If name is entirely invalid, or nearly so, use `emacs'. */
3768 || (good_count
== 1 && bad_count
> 0))
3770 Vx_resource_name
= build_string ("emacs");
3774 /* Name is partly valid. Copy it and replace the invalid characters
3775 with underscores. */
3777 Vx_resource_name
= new = Fcopy_sequence (Vx_resource_name
);
3779 for (i
= 0; i
< len
; i
++)
3781 int c
= SREF (new, i
);
3782 if (! ((c
>= 'a' && c
<= 'z')
3783 || (c
>= 'A' && c
<= 'Z')
3784 || (c
>= '0' && c
<= '9')
3785 || c
== '-' || c
== '_'))
3791 extern char *x_get_string_resource
P_ ((XrmDatabase
, char *, char *));
3792 extern Display_Info
*check_x_display_info
P_ ((Lisp_Object
));
3795 /* Get specified attribute from resource database RDB.
3796 See Fx_get_resource below for other parameters. */
3799 xrdb_get_resource (rdb
, attribute
, class, component
, subclass
)
3801 Lisp_Object attribute
, class, component
, subclass
;
3803 register char *value
;
3807 CHECK_STRING (attribute
);
3808 CHECK_STRING (class);
3810 if (!NILP (component
))
3811 CHECK_STRING (component
);
3812 if (!NILP (subclass
))
3813 CHECK_STRING (subclass
);
3814 if (NILP (component
) != NILP (subclass
))
3815 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3817 validate_x_resource_name ();
3819 /* Allocate space for the components, the dots which separate them,
3820 and the final '\0'. Make them big enough for the worst case. */
3821 name_key
= (char *) alloca (SBYTES (Vx_resource_name
)
3822 + (STRINGP (component
)
3823 ? SBYTES (component
) : 0)
3824 + SBYTES (attribute
)
3827 class_key
= (char *) alloca (SBYTES (Vx_resource_class
)
3829 + (STRINGP (subclass
)
3830 ? SBYTES (subclass
) : 0)
3833 /* Start with emacs.FRAMENAME for the name (the specific one)
3834 and with `Emacs' for the class key (the general one). */
3835 strcpy (name_key
, SDATA (Vx_resource_name
));
3836 strcpy (class_key
, SDATA (Vx_resource_class
));
3838 strcat (class_key
, ".");
3839 strcat (class_key
, SDATA (class));
3841 if (!NILP (component
))
3843 strcat (class_key
, ".");
3844 strcat (class_key
, SDATA (subclass
));
3846 strcat (name_key
, ".");
3847 strcat (name_key
, SDATA (component
));
3850 strcat (name_key
, ".");
3851 strcat (name_key
, SDATA (attribute
));
3853 value
= x_get_string_resource (rdb
, name_key
, class_key
);
3855 if (value
!= (char *) 0)
3856 return build_string (value
);
3862 DEFUN ("x-get-resource", Fx_get_resource
, Sx_get_resource
, 2, 4, 0,
3863 doc
: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
3864 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
3865 class, where INSTANCE is the name under which Emacs was invoked, or
3866 the name specified by the `-name' or `-rn' command-line arguments.
3868 The optional arguments COMPONENT and SUBCLASS add to the key and the
3869 class, respectively. You must specify both of them or neither.
3870 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
3871 and the class is `Emacs.CLASS.SUBCLASS'. */)
3872 (attribute
, class, component
, subclass
)
3873 Lisp_Object attribute
, class, component
, subclass
;
3875 #ifdef HAVE_X_WINDOWS
3879 return xrdb_get_resource (check_x_display_info (Qnil
)->xrdb
,
3880 attribute
, class, component
, subclass
);
3883 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
3886 display_x_get_resource (dpyinfo
, attribute
, class, component
, subclass
)
3887 Display_Info
*dpyinfo
;
3888 Lisp_Object attribute
, class, component
, subclass
;
3890 return xrdb_get_resource (dpyinfo
->xrdb
,
3891 attribute
, class, component
, subclass
);
3894 /* Used when C code wants a resource value. */
3897 x_get_resource_string (attribute
, class)
3898 char *attribute
, *class;
3902 struct frame
*sf
= SELECTED_FRAME ();
3904 /* Allocate space for the components, the dots which separate them,
3905 and the final '\0'. */
3906 name_key
= (char *) alloca (SBYTES (Vinvocation_name
)
3907 + strlen (attribute
) + 2);
3908 class_key
= (char *) alloca ((sizeof (EMACS_CLASS
) - 1)
3909 + strlen (class) + 2);
3911 sprintf (name_key
, "%s.%s", SDATA (Vinvocation_name
), attribute
);
3912 sprintf (class_key
, "%s.%s", EMACS_CLASS
, class);
3914 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf
)->xrdb
,
3915 name_key
, class_key
);
3919 /* Return the value of parameter PARAM.
3921 First search ALIST, then Vdefault_frame_alist, then the X defaults
3922 database, using ATTRIBUTE as the attribute name and CLASS as its class.
3924 Convert the resource to the type specified by desired_type.
3926 If no default is specified, return Qunbound. If you call
3927 x_get_arg, make sure you deal with Qunbound in a reasonable way,
3928 and don't let it get stored in any Lisp-visible variables! */
3931 x_get_arg (dpyinfo
, alist
, param
, attribute
, class, type
)
3932 Display_Info
*dpyinfo
;
3933 Lisp_Object alist
, param
;
3936 enum resource_types type
;
3938 register Lisp_Object tem
;
3940 tem
= Fassq (param
, alist
);
3944 /* If we find this parm in ALIST, clear it out
3945 so that it won't be "left over" at the end. */
3947 XSETCAR (tem
, Qnil
);
3948 /* In case the parameter appears more than once in the alist,
3950 for (tail
= alist
; CONSP (tail
); tail
= XCDR (tail
))
3951 if (CONSP (XCAR (tail
))
3952 && EQ (XCAR (XCAR (tail
)), param
))
3953 XSETCAR (XCAR (tail
), Qnil
);
3956 tem
= Fassq (param
, Vdefault_frame_alist
);
3958 /* If it wasn't specified in ALIST or the Lisp-level defaults,
3959 look in the X resources. */
3962 if (attribute
&& dpyinfo
)
3964 tem
= display_x_get_resource (dpyinfo
,
3965 build_string (attribute
),
3966 build_string (class),
3974 case RES_TYPE_NUMBER
:
3975 return make_number (atoi (SDATA (tem
)));
3977 case RES_TYPE_FLOAT
:
3978 return make_float (atof (SDATA (tem
)));
3980 case RES_TYPE_BOOLEAN
:
3981 tem
= Fdowncase (tem
);
3982 if (!strcmp (SDATA (tem
), "on")
3984 || !strcmp(SDATA(tem
), "yes")
3986 || !strcmp (SDATA (tem
), "true"))
3991 case RES_TYPE_STRING
:
3994 case RES_TYPE_SYMBOL
:
3995 /* As a special case, we map the values `true' and `on'
3996 to Qt, and `false' and `off' to Qnil. */
3999 lower
= Fdowncase (tem
);
4000 if (!strcmp (SDATA (lower
), "on")
4002 || !strcmp(SDATA(lower
), "yes")
4004 || !strcmp (SDATA (lower
), "true"))
4006 else if (!strcmp (SDATA (lower
), "off")
4008 || !strcmp(SDATA(lower
), "no")
4010 || !strcmp (SDATA (lower
), "false"))
4013 return Fintern (tem
, Qnil
);
4027 x_frame_get_arg (f
, alist
, param
, attribute
, class, type
)
4029 Lisp_Object alist
, param
;
4032 enum resource_types type
;
4034 return x_get_arg (FRAME_X_DISPLAY_INFO (f
),
4035 alist
, param
, attribute
, class, type
);
4038 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
4041 x_frame_get_and_record_arg (f
, alist
, param
, attribute
, class, type
)
4043 Lisp_Object alist
, param
;
4046 enum resource_types type
;
4050 value
= x_get_arg (FRAME_X_DISPLAY_INFO (f
), alist
, param
,
4051 attribute
, class, type
);
4052 if (! NILP (value
) && ! EQ (value
, Qunbound
))
4053 store_frame_param (f
, param
, value
);
4059 /* Record in frame F the specified or default value according to ALIST
4060 of the parameter named PROP (a Lisp symbol).
4061 If no value is specified for PROP, look for an X default for XPROP
4062 on the frame named NAME.
4063 If that is not found either, use the value DEFLT. */
4066 x_default_parameter (f
, alist
, prop
, deflt
, xprop
, xclass
, type
)
4073 enum resource_types type
;
4077 tem
= x_frame_get_arg (f
, alist
, prop
, xprop
, xclass
, type
);
4078 if (EQ (tem
, Qunbound
))
4080 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
4089 /* We used to define x-parse-geometry directly in ns-win.el, but that
4090 confused make-docfile: the documentation string in ns-win.el was
4091 used for x-parse-geometry even in non-NS builds.. */
4093 DEFUN ("x-parse-geometry", Fx_parse_geometry
, Sx_parse_geometry
, 1, 1, 0,
4094 doc
: /* Parse a Nextstep-style geometry string STRING.
4095 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
4096 The properties returned may include `top', `left', `height', and `width'.
4097 This works by calling `ns-parse-geometry'. */)
4101 call1 (Qns_parse_geometry
, string
);
4104 #else /* !HAVE_NS */
4106 DEFUN ("x-parse-geometry", Fx_parse_geometry
, Sx_parse_geometry
, 1, 1, 0,
4107 doc
: /* Parse an X-style geometry string STRING.
4108 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
4109 The properties returned may include `top', `left', `height', and `width'.
4110 The value of `left' or `top' may be an integer,
4111 or a list (+ N) meaning N pixels relative to top/left corner,
4112 or a list (- N) meaning -N pixels relative to bottom/right corner. */)
4117 unsigned int width
, height
;
4120 CHECK_STRING (string
);
4122 geometry
= XParseGeometry ((char *) SDATA (string
),
4123 &x
, &y
, &width
, &height
);
4125 if (geometry
& XValue
)
4127 Lisp_Object element
;
4129 if (x
>= 0 && (geometry
& XNegative
))
4130 element
= Fcons (Qleft
, Fcons (Qminus
, Fcons (make_number (-x
), Qnil
)));
4131 else if (x
< 0 && ! (geometry
& XNegative
))
4132 element
= Fcons (Qleft
, Fcons (Qplus
, Fcons (make_number (x
), Qnil
)));
4134 element
= Fcons (Qleft
, make_number (x
));
4135 result
= Fcons (element
, result
);
4138 if (geometry
& YValue
)
4140 Lisp_Object element
;
4142 if (y
>= 0 && (geometry
& YNegative
))
4143 element
= Fcons (Qtop
, Fcons (Qminus
, Fcons (make_number (-y
), Qnil
)));
4144 else if (y
< 0 && ! (geometry
& YNegative
))
4145 element
= Fcons (Qtop
, Fcons (Qplus
, Fcons (make_number (y
), Qnil
)));
4147 element
= Fcons (Qtop
, make_number (y
));
4148 result
= Fcons (element
, result
);
4151 if (geometry
& WidthValue
)
4152 result
= Fcons (Fcons (Qwidth
, make_number (width
)), result
);
4153 if (geometry
& HeightValue
)
4154 result
= Fcons (Fcons (Qheight
, make_number (height
)), result
);
4158 #endif /* HAVE_NS */
4161 /* Calculate the desired size and position of frame F.
4162 Return the flags saying which aspects were specified.
4164 Also set the win_gravity and size_hint_flags of F.
4166 Adjust height for toolbar if TOOLBAR_P is 1.
4168 This function does not make the coordinates positive. */
4170 #define DEFAULT_ROWS 40
4171 #define DEFAULT_COLS 80
4174 x_figure_window_size (f
, parms
, toolbar_p
)
4179 register Lisp_Object tem0
, tem1
, tem2
;
4180 long window_prompting
= 0;
4181 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
4183 /* Default values if we fall through.
4184 Actually, if that happens we should get
4185 window manager prompting. */
4186 SET_FRAME_COLS (f
, DEFAULT_COLS
);
4187 FRAME_LINES (f
) = DEFAULT_ROWS
;
4188 /* Window managers expect that if program-specified
4189 positions are not (0,0), they're intentional, not defaults. */
4193 /* Ensure that old new_text_cols and new_text_lines will not override the
4195 /* ++KFS: This was specific to W32, but seems ok for all platforms */
4196 f
->new_text_cols
= f
->new_text_lines
= 0;
4198 tem0
= x_get_arg (dpyinfo
, parms
, Qheight
, 0, 0, RES_TYPE_NUMBER
);
4199 tem1
= x_get_arg (dpyinfo
, parms
, Qwidth
, 0, 0, RES_TYPE_NUMBER
);
4200 tem2
= x_get_arg (dpyinfo
, parms
, Quser_size
, 0, 0, RES_TYPE_NUMBER
);
4201 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4203 if (!EQ (tem0
, Qunbound
))
4205 CHECK_NUMBER (tem0
);
4206 FRAME_LINES (f
) = XINT (tem0
);
4208 if (!EQ (tem1
, Qunbound
))
4210 CHECK_NUMBER (tem1
);
4211 SET_FRAME_COLS (f
, XINT (tem1
));
4213 if (!NILP (tem2
) && !EQ (tem2
, Qunbound
))
4214 window_prompting
|= USSize
;
4216 window_prompting
|= PSize
;
4219 f
->scroll_bar_actual_width
4220 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
4222 /* This used to be done _before_ calling x_figure_window_size, but
4223 since the height is reset here, this was really a no-op. I
4224 assume that moving it here does what Gerd intended (although he
4225 no longer can remember what that was... ++KFS, 2003-03-25. */
4227 /* Add the tool-bar height to the initial frame height so that the
4228 user gets a text display area of the size he specified with -g or
4229 via .Xdefaults. Later changes of the tool-bar height don't
4230 change the frame size. This is done so that users can create
4231 tall Emacs frames without having to guess how tall the tool-bar
4233 if (toolbar_p
&& FRAME_TOOL_BAR_LINES (f
))
4235 int margin
, relief
, bar_height
;
4237 relief
= (tool_bar_button_relief
>= 0
4238 ? tool_bar_button_relief
4239 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
4241 if (INTEGERP (Vtool_bar_button_margin
)
4242 && XINT (Vtool_bar_button_margin
) > 0)
4243 margin
= XFASTINT (Vtool_bar_button_margin
);
4244 else if (CONSP (Vtool_bar_button_margin
)
4245 && INTEGERP (XCDR (Vtool_bar_button_margin
))
4246 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4247 margin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4251 bar_height
= DEFAULT_TOOL_BAR_IMAGE_HEIGHT
+ 2 * margin
+ 2 * relief
;
4252 FRAME_LINES (f
) += (bar_height
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
4255 compute_fringe_widths (f
, 0);
4257 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, FRAME_COLS (f
));
4258 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4260 tem0
= x_get_arg (dpyinfo
, parms
, Qtop
, 0, 0, RES_TYPE_NUMBER
);
4261 tem1
= x_get_arg (dpyinfo
, parms
, Qleft
, 0, 0, RES_TYPE_NUMBER
);
4262 tem2
= x_get_arg (dpyinfo
, parms
, Quser_position
, 0, 0, RES_TYPE_NUMBER
);
4263 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4265 if (EQ (tem0
, Qminus
))
4268 window_prompting
|= YNegative
;
4270 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qminus
)
4271 && CONSP (XCDR (tem0
))
4272 && INTEGERP (XCAR (XCDR (tem0
))))
4274 f
->top_pos
= - XINT (XCAR (XCDR (tem0
)));
4275 window_prompting
|= YNegative
;
4277 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qplus
)
4278 && CONSP (XCDR (tem0
))
4279 && INTEGERP (XCAR (XCDR (tem0
))))
4281 f
->top_pos
= XINT (XCAR (XCDR (tem0
)));
4283 else if (EQ (tem0
, Qunbound
))
4287 CHECK_NUMBER (tem0
);
4288 f
->top_pos
= XINT (tem0
);
4290 window_prompting
|= YNegative
;
4293 if (EQ (tem1
, Qminus
))
4296 window_prompting
|= XNegative
;
4298 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qminus
)
4299 && CONSP (XCDR (tem1
))
4300 && INTEGERP (XCAR (XCDR (tem1
))))
4302 f
->left_pos
= - XINT (XCAR (XCDR (tem1
)));
4303 window_prompting
|= XNegative
;
4305 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qplus
)
4306 && CONSP (XCDR (tem1
))
4307 && INTEGERP (XCAR (XCDR (tem1
))))
4309 f
->left_pos
= XINT (XCAR (XCDR (tem1
)));
4311 else if (EQ (tem1
, Qunbound
))
4315 CHECK_NUMBER (tem1
);
4316 f
->left_pos
= XINT (tem1
);
4317 if (f
->left_pos
< 0)
4318 window_prompting
|= XNegative
;
4321 if (!NILP (tem2
) && ! EQ (tem2
, Qunbound
))
4322 window_prompting
|= USPosition
;
4324 window_prompting
|= PPosition
;
4327 if (window_prompting
& XNegative
)
4329 if (window_prompting
& YNegative
)
4330 f
->win_gravity
= SouthEastGravity
;
4332 f
->win_gravity
= NorthEastGravity
;
4336 if (window_prompting
& YNegative
)
4337 f
->win_gravity
= SouthWestGravity
;
4339 f
->win_gravity
= NorthWestGravity
;
4342 f
->size_hint_flags
= window_prompting
;
4344 return window_prompting
;
4349 #endif /* HAVE_WINDOW_SYSTEM */
4353 /***********************************************************************
4355 ***********************************************************************/
4360 Qframep
= intern ("framep");
4361 staticpro (&Qframep
);
4362 Qframe_live_p
= intern ("frame-live-p");
4363 staticpro (&Qframe_live_p
);
4364 Qexplicit_name
= intern ("explicit-name");
4365 staticpro (&Qexplicit_name
);
4366 Qheight
= intern ("height");
4367 staticpro (&Qheight
);
4368 Qicon
= intern ("icon");
4370 Qminibuffer
= intern ("minibuffer");
4371 staticpro (&Qminibuffer
);
4372 Qmodeline
= intern ("modeline");
4373 staticpro (&Qmodeline
);
4374 Qonly
= intern ("only");
4376 Qwidth
= intern ("width");
4377 staticpro (&Qwidth
);
4378 Qgeometry
= intern ("geometry");
4379 staticpro (&Qgeometry
);
4380 Qicon_left
= intern ("icon-left");
4381 staticpro (&Qicon_left
);
4382 Qicon_top
= intern ("icon-top");
4383 staticpro (&Qicon_top
);
4384 Qleft
= intern ("left");
4386 Qright
= intern ("right");
4387 staticpro (&Qright
);
4388 Quser_position
= intern ("user-position");
4389 staticpro (&Quser_position
);
4390 Quser_size
= intern ("user-size");
4391 staticpro (&Quser_size
);
4392 Qwindow_id
= intern ("window-id");
4393 staticpro (&Qwindow_id
);
4394 #ifdef HAVE_X_WINDOWS
4395 Qouter_window_id
= intern ("outer-window-id");
4396 staticpro (&Qouter_window_id
);
4398 Qparent_id
= intern ("parent-id");
4399 staticpro (&Qparent_id
);
4402 Qw32
= intern ("w32");
4404 Qpc
= intern ("pc");
4406 Qmac
= intern ("mac");
4408 Qns
= intern ("ns");
4410 Qvisible
= intern ("visible");
4411 staticpro (&Qvisible
);
4412 Qbuffer_predicate
= intern ("buffer-predicate");
4413 staticpro (&Qbuffer_predicate
);
4414 Qbuffer_list
= intern ("buffer-list");
4415 staticpro (&Qbuffer_list
);
4416 Qburied_buffer_list
= intern ("buried-buffer-list");
4417 staticpro (&Qburied_buffer_list
);
4418 Qdisplay_type
= intern ("display-type");
4419 staticpro (&Qdisplay_type
);
4420 Qbackground_mode
= intern ("background-mode");
4421 staticpro (&Qbackground_mode
);
4422 Qnoelisp
= intern ("noelisp");
4423 staticpro (&Qnoelisp
);
4424 Qtty_color_mode
= intern ("tty-color-mode");
4425 staticpro (&Qtty_color_mode
);
4426 Qtty
= intern ("tty");
4428 Qtty_type
= intern ("tty-type");
4429 staticpro (&Qtty_type
);
4431 Qface_set_after_frame_default
= intern ("face-set-after-frame-default");
4432 staticpro (&Qface_set_after_frame_default
);
4434 Qfullwidth
= intern ("fullwidth");
4435 staticpro (&Qfullwidth
);
4436 Qfullheight
= intern ("fullheight");
4437 staticpro (&Qfullheight
);
4438 Qfullboth
= intern ("fullboth");
4439 staticpro (&Qfullboth
);
4440 Qmaximized
= intern ("maximized");
4441 staticpro (&Qmaximized
);
4442 Qx_resource_name
= intern ("x-resource-name");
4443 staticpro (&Qx_resource_name
);
4445 Qx_frame_parameter
= intern ("x-frame-parameter");
4446 staticpro (&Qx_frame_parameter
);
4448 Qterminal
= intern ("terminal");
4449 staticpro (&Qterminal
);
4450 Qterminal_live_p
= intern ("terminal-live-p");
4451 staticpro (&Qterminal_live_p
);
4454 Qns_parse_geometry
= intern ("ns-parse-geometry");
4455 staticpro (&Qns_parse_geometry
);
4461 for (i
= 0; i
< sizeof (frame_parms
) / sizeof (frame_parms
[0]); i
++)
4463 Lisp_Object v
= intern (frame_parms
[i
].name
);
4464 if (frame_parms
[i
].variable
)
4466 *frame_parms
[i
].variable
= v
;
4467 staticpro (frame_parms
[i
].variable
);
4469 Fput (v
, Qx_frame_parameter
, make_number (i
));
4473 #ifdef HAVE_WINDOW_SYSTEM
4474 DEFVAR_LISP ("x-resource-name", &Vx_resource_name
,
4475 doc
: /* The name Emacs uses to look up X resources.
4476 `x-get-resource' uses this as the first component of the instance name
4477 when requesting resource values.
4478 Emacs initially sets `x-resource-name' to the name under which Emacs
4479 was invoked, or to the value specified with the `-name' or `-rn'
4480 switches, if present.
4482 It may be useful to bind this variable locally around a call
4483 to `x-get-resource'. See also the variable `x-resource-class'. */);
4484 Vx_resource_name
= Qnil
;
4486 DEFVAR_LISP ("x-resource-class", &Vx_resource_class
,
4487 doc
: /* The class Emacs uses to look up X resources.
4488 `x-get-resource' uses this as the first component of the instance class
4489 when requesting resource values.
4491 Emacs initially sets `x-resource-class' to "Emacs".
4493 Setting this variable permanently is not a reasonable thing to do,
4494 but binding this variable locally around a call to `x-get-resource'
4495 is a reasonable practice. See also the variable `x-resource-name'. */);
4496 Vx_resource_class
= build_string (EMACS_CLASS
);
4498 DEFVAR_LISP ("frame-alpha-lower-limit", &Vframe_alpha_lower_limit
,
4499 doc
: /* The lower limit of the frame opacity (alpha transparency).
4500 The value should range from 0 (invisible) to 100 (completely opaque).
4501 You can also use a floating number between 0.0 and 1.0.
4502 The default is 20. */);
4503 Vframe_alpha_lower_limit
= make_number (20);
4506 DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist
,
4507 doc
: /* Alist of default values for frame creation.
4508 These may be set in your init file, like this:
4509 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
4510 These override values given in window system configuration data,
4511 including X Windows' defaults database.
4512 For values specific to the first Emacs frame, see `initial-frame-alist'.
4513 For window-system specific values, see `window-system-default-frame-alist'.
4514 For values specific to the separate minibuffer frame, see
4515 `minibuffer-frame-alist'.
4516 The `menu-bar-lines' element of the list controls whether new frames
4517 have menu bars; `menu-bar-mode' works by altering this element.
4518 Setting this variable does not affect existing frames, only new ones. */);
4519 Vdefault_frame_alist
= Qnil
;
4521 DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars
,
4522 doc
: /* Default position of scroll bars on this window-system. */);
4523 #ifdef HAVE_WINDOW_SYSTEM
4524 #if defined(HAVE_NTGUI) || defined(NS_IMPL_COCOA)
4525 /* MS-Windows and Mac OS X have scroll bars on the right by default. */
4526 Vdefault_frame_scroll_bars
= Qright
;
4528 Vdefault_frame_scroll_bars
= Qleft
;
4531 Vdefault_frame_scroll_bars
= Qnil
;
4534 DEFVAR_LISP ("terminal-frame", &Vterminal_frame
,
4535 doc
: /* The initial frame-object, which represents Emacs's stdout. */);
4537 DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function
,
4538 doc
: /* If non-nil, function to transform normal value of `mouse-position'.
4539 `mouse-position' calls this function, passing its usual return value as
4540 argument, and returns whatever this function returns.
4541 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
4542 which need to do mouse handling at the Lisp level. */);
4543 Vmouse_position_function
= Qnil
;
4545 DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight
,
4546 doc
: /* If non-nil, clickable text is highlighted when mouse is over it.
4547 If the value is an integer, highlighting is only shown after moving the
4548 mouse, while keyboard input turns off the highlight even when the mouse
4549 is over the clickable text. However, the mouse shape still indicates
4550 when the mouse is over clickable text. */);
4551 Vmouse_highlight
= Qt
;
4553 DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions
,
4554 doc
: /* Functions to be run before deleting a frame.
4555 The functions are run with one arg, the frame to be deleted.
4558 Note that functions in this list may be called just before the frame is
4559 actually deleted, or some time later (or even both when an earlier function
4560 in `delete-frame-functions' (indirectly) calls `delete-frame'
4562 Vdelete_frame_functions
= Qnil
;
4563 Qdelete_frame_functions
= intern ("delete-frame-functions");
4564 staticpro (&Qdelete_frame_functions
);
4566 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame
,
4567 doc
: /* Minibufferless frames use this frame's minibuffer.
4569 Emacs cannot create minibufferless frames unless this is set to an
4570 appropriate surrogate.
4572 Emacs consults this variable only when creating minibufferless
4573 frames; once the frame is created, it sticks with its assigned
4574 minibuffer, no matter what this variable is set to. This means that
4575 this variable doesn't necessarily say anything meaningful about the
4576 current set of frames, or where the minibuffer is currently being
4579 This variable is local to the current terminal and cannot be buffer-local. */);
4581 DEFVAR_BOOL ("focus-follows-mouse", &focus_follows_mouse
,
4582 doc
: /* Non-nil if window system changes focus when you move the mouse.
4583 You should set this variable to tell Emacs how your window manager
4584 handles focus, since there is no way in general for Emacs to find out
4586 #ifdef HAVE_WINDOW_SYSTEM
4587 #if defined(HAVE_NTGUI) || defined(HAVE_NS)
4588 focus_follows_mouse
= 0;
4590 focus_follows_mouse
= 1;
4593 focus_follows_mouse
= 0;
4596 staticpro (&Vframe_list
);
4598 defsubr (&Sactive_minibuffer_window
);
4600 defsubr (&Sframe_live_p
);
4601 defsubr (&Swindow_system
);
4602 defsubr (&Smake_terminal_frame
);
4603 defsubr (&Shandle_switch_frame
);
4604 defsubr (&Sselect_frame
);
4605 defsubr (&Sselected_frame
);
4606 defsubr (&Swindow_frame
);
4607 defsubr (&Sframe_root_window
);
4608 defsubr (&Sframe_first_window
);
4609 defsubr (&Sframe_selected_window
);
4610 defsubr (&Sset_frame_selected_window
);
4611 defsubr (&Sframe_list
);
4612 defsubr (&Snext_frame
);
4613 defsubr (&Sprevious_frame
);
4614 defsubr (&Sdelete_frame
);
4615 defsubr (&Smouse_position
);
4616 defsubr (&Smouse_pixel_position
);
4617 defsubr (&Sset_mouse_position
);
4618 defsubr (&Sset_mouse_pixel_position
);
4620 defsubr (&Sframe_configuration
);
4621 defsubr (&Srestore_frame_configuration
);
4623 defsubr (&Smake_frame_visible
);
4624 defsubr (&Smake_frame_invisible
);
4625 defsubr (&Siconify_frame
);
4626 defsubr (&Sframe_visible_p
);
4627 defsubr (&Svisible_frame_list
);
4628 defsubr (&Sraise_frame
);
4629 defsubr (&Slower_frame
);
4630 defsubr (&Sredirect_frame_focus
);
4631 defsubr (&Sframe_focus
);
4632 defsubr (&Sframe_parameters
);
4633 defsubr (&Sframe_parameter
);
4634 defsubr (&Smodify_frame_parameters
);
4635 defsubr (&Sframe_char_height
);
4636 defsubr (&Sframe_char_width
);
4637 defsubr (&Sframe_pixel_height
);
4638 defsubr (&Sframe_pixel_width
);
4639 defsubr (&Sset_frame_height
);
4640 defsubr (&Sset_frame_width
);
4641 defsubr (&Sset_frame_size
);
4642 defsubr (&Sset_frame_position
);
4644 #ifdef HAVE_WINDOW_SYSTEM
4645 defsubr (&Sx_get_resource
);
4646 defsubr (&Sx_parse_geometry
);
4651 /* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
4652 (do not change this comment) */