1 /* Generic frame functions.
2 Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2003, 2004, 2005
3 Free Software Foundation.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
37 /* These help us bind and responding to switch-frame events. */
41 #ifdef HAVE_WINDOW_SYSTEM
44 #include "blockinput.h"
46 #include "termhooks.h"
47 #include "dispextern.h"
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
;
68 Lisp_Object Qframep
, Qframe_live_p
;
69 Lisp_Object Qicon
, Qmodeline
;
71 Lisp_Object Qx
, Qw32
, Qmac
, Qpc
;
73 Lisp_Object Qdisplay_type
;
74 Lisp_Object Qbackground_mode
;
75 Lisp_Object Qinhibit_default_face_x_resources
;
77 Lisp_Object Qx_frame_parameter
;
78 Lisp_Object Qx_resource_name
;
79 Lisp_Object Qdisplay_id
;
80 Lisp_Object Qdisplay_live_p
;
82 /* Frame parameters (set or reported). */
84 Lisp_Object Qauto_raise
, Qauto_lower
;
85 Lisp_Object Qborder_color
, Qborder_width
;
86 Lisp_Object Qcursor_color
, Qcursor_type
;
87 Lisp_Object Qgeometry
; /* Not used */
88 Lisp_Object Qheight
, Qwidth
;
89 Lisp_Object Qleft
, Qright
;
90 Lisp_Object Qicon_left
, Qicon_top
, Qicon_type
, Qicon_name
;
91 Lisp_Object Qinternal_border_width
;
92 Lisp_Object Qmouse_color
;
93 Lisp_Object Qminibuffer
;
94 Lisp_Object Qscroll_bar_width
, Qvertical_scroll_bars
;
95 Lisp_Object Qvisibility
;
96 Lisp_Object Qscroll_bar_foreground
, Qscroll_bar_background
;
97 Lisp_Object Qscreen_gamma
;
98 Lisp_Object Qline_spacing
;
99 Lisp_Object Quser_position
, Quser_size
;
100 Lisp_Object Qwait_for_wm
;
101 Lisp_Object Qwindow_id
;
102 #ifdef HAVE_X_WINDOWS
103 Lisp_Object Qouter_window_id
;
105 Lisp_Object Qparent_id
;
106 Lisp_Object Qtitle
, Qname
;
107 Lisp_Object Qunsplittable
;
108 Lisp_Object Qmenu_bar_lines
, Qtool_bar_lines
;
109 Lisp_Object Qleft_fringe
, Qright_fringe
;
110 Lisp_Object Qbuffer_predicate
, Qbuffer_list
;
111 Lisp_Object Qtty_color_mode
;
112 Lisp_Object Qtty
, Qtty_type
;
113 Lisp_Object Qwindow_system
;
115 Lisp_Object Qfullscreen
, Qfullwidth
, Qfullheight
, Qfullboth
;
117 Lisp_Object Qface_set_after_frame_default
;
119 Lisp_Object Vterminal_frame
;
120 Lisp_Object Vdefault_frame_alist
;
121 Lisp_Object Vdefault_frame_scroll_bars
;
122 Lisp_Object Vmouse_position_function
;
123 Lisp_Object Vmouse_highlight
;
124 Lisp_Object Vdelete_frame_functions
;
127 set_menu_bar_lines_1 (window
, n
)
131 struct window
*w
= XWINDOW (window
);
133 XSETFASTINT (w
->last_modified
, 0);
134 XSETFASTINT (w
->top_line
, XFASTINT (w
->top_line
) + n
);
135 XSETFASTINT (w
->total_lines
, XFASTINT (w
->total_lines
) - n
);
137 if (INTEGERP (w
->orig_top_line
))
138 XSETFASTINT (w
->orig_top_line
, XFASTINT (w
->orig_top_line
) + n
);
139 if (INTEGERP (w
->orig_total_lines
))
140 XSETFASTINT (w
->orig_total_lines
, XFASTINT (w
->orig_total_lines
) - n
);
142 /* Handle just the top child in a vertical split. */
143 if (!NILP (w
->vchild
))
144 set_menu_bar_lines_1 (w
->vchild
, n
);
146 /* Adjust all children in a horizontal split. */
147 for (window
= w
->hchild
; !NILP (window
); window
= w
->next
)
149 w
= XWINDOW (window
);
150 set_menu_bar_lines_1 (window
, n
);
155 set_menu_bar_lines (f
, value
, oldval
)
157 Lisp_Object value
, oldval
;
160 int olines
= FRAME_MENU_BAR_LINES (f
);
162 /* Right now, menu bars don't work properly in minibuf-only frames;
163 most of the commands try to apply themselves to the minibuffer
164 frame itself, and get an error because you can't switch buffers
165 in or split the minibuffer window. */
166 if (FRAME_MINIBUF_ONLY_P (f
))
169 if (INTEGERP (value
))
170 nlines
= XINT (value
);
174 if (nlines
!= olines
)
176 windows_or_buffers_changed
++;
177 FRAME_WINDOW_SIZES_CHANGED (f
) = 1;
178 FRAME_MENU_BAR_LINES (f
) = nlines
;
179 set_menu_bar_lines_1 (f
->root_window
, nlines
- olines
);
184 Lisp_Object Vemacs_iconified
;
185 Lisp_Object Vframe_list
;
187 extern Lisp_Object Vminibuffer_list
;
188 extern Lisp_Object
get_minibuffer ();
189 extern Lisp_Object
Fhandle_switch_frame ();
190 extern Lisp_Object
Fredirect_frame_focus ();
191 extern Lisp_Object
x_get_focus_frame ();
193 DEFUN ("framep", Fframep
, Sframep
, 1, 1, 0,
194 doc
: /* Return non-nil if OBJECT is a frame.
195 Value is t for a termcap frame (a character-only terminal),
196 `x' for an Emacs frame that is really an X window,
197 `w32' for an Emacs frame that is a window on MS-Windows display,
198 `mac' for an Emacs frame on a Macintosh display,
199 `pc' for a direct-write MS-DOS frame.
200 See also `frame-live-p'. */)
204 if (!FRAMEP (object
))
206 switch (XFRAME (object
)->output_method
)
208 case output_initial
: /* The initial frame is like a termcap frame. */
211 case output_x_window
:
215 case output_msdos_raw
:
224 DEFUN ("frame-live-p", Fframe_live_p
, Sframe_live_p
, 1, 1, 0,
225 doc
: /* Return non-nil if OBJECT is a frame which has not been deleted.
226 Value is nil if OBJECT is not a live frame. If object is a live
227 frame, the return value indicates what sort of output device it is
228 displayed on. See the documentation of `framep' for possible
233 return ((FRAMEP (object
)
234 && FRAME_LIVE_P (XFRAME (object
)))
239 DEFUN ("window-system", Fwindow_system
, Swindow_system
, 0, 1, 0,
240 doc
: /* The name of the window system that FRAME is displaying through.
241 The value is a symbol---for instance, 'x' for X windows.
242 The value is nil if Emacs is using a text-only terminal.
244 FRAME defaults to the currently selected frame. */)
250 frame
= selected_frame
;
252 type
= Fframep (frame
);
255 wrong_type_argument (Qframep
, frame
);
268 register struct frame
*f
;
269 register Lisp_Object root_window
;
270 register Lisp_Object mini_window
;
272 f
= allocate_frame ();
273 XSETFRAME (frame
, f
);
275 f
->desired_matrix
= 0;
276 f
->current_matrix
= 0;
279 f
->glyphs_initialized_p
= 0;
280 f
->decode_mode_spec_buffer
= 0;
282 f
->async_visible
= 0;
283 f
->output_data
.nothing
= 0;
285 f
->async_iconified
= 0;
286 f
->wants_modeline
= 1;
291 f
->has_minibuffer
= mini_p
;
292 f
->focus_frame
= Qnil
;
293 f
->explicit_name
= 0;
294 f
->can_have_scroll_bars
= 0;
295 f
->vertical_scroll_bar_type
= vertical_scroll_bar_none
;
296 f
->param_alist
= Qnil
;
297 f
->scroll_bars
= Qnil
;
298 f
->condemned_scroll_bars
= Qnil
;
299 f
->face_alist
= Qnil
;
300 f
->face_cache
= NULL
;
301 f
->menu_bar_items
= Qnil
;
302 f
->menu_bar_vector
= Qnil
;
303 f
->menu_bar_items_used
= 0;
304 f
->buffer_predicate
= Qnil
;
305 f
->buffer_list
= Qnil
;
307 f
->kboard
= initial_kboard
;
311 f
->menu_bar_window
= Qnil
;
312 f
->tool_bar_window
= Qnil
;
313 f
->tool_bar_items
= Qnil
;
314 f
->desired_tool_bar_string
= f
->current_tool_bar_string
= Qnil
;
315 f
->n_tool_bar_items
= 0;
316 f
->left_fringe_width
= f
->right_fringe_width
= 0;
318 f
->scroll_bar_actual_width
= 0;
320 f
->internal_border_width
= 0;
321 f
->column_width
= 1; /* !FRAME_WINDOW_P value */
322 f
->line_height
= 1; /* !FRAME_WINDOW_P value */
323 f
->x_pixels_diff
= f
->y_pixels_diff
= 0;
324 #ifdef HAVE_WINDOW_SYSTEM
325 f
->want_fullscreen
= FULLSCREEN_NONE
;
327 f
->size_hint_flags
= 0;
330 root_window
= make_window ();
333 mini_window
= make_window ();
334 XWINDOW (root_window
)->next
= mini_window
;
335 XWINDOW (mini_window
)->prev
= root_window
;
336 XWINDOW (mini_window
)->mini_p
= Qt
;
337 XWINDOW (mini_window
)->frame
= frame
;
338 f
->minibuffer_window
= mini_window
;
343 XWINDOW (root_window
)->next
= Qnil
;
344 f
->minibuffer_window
= Qnil
;
347 XWINDOW (root_window
)->frame
= frame
;
350 just so that there is "something there."
351 Correct size will be set up later with change_frame_size. */
353 SET_FRAME_COLS (f
, 10);
354 FRAME_LINES (f
) = 10;
356 XSETFASTINT (XWINDOW (root_window
)->total_cols
, 10);
357 XSETFASTINT (XWINDOW (root_window
)->total_lines
, (mini_p
? 9 : 10));
361 XSETFASTINT (XWINDOW (mini_window
)->total_cols
, 10);
362 XSETFASTINT (XWINDOW (mini_window
)->top_line
, 9);
363 XSETFASTINT (XWINDOW (mini_window
)->total_lines
, 1);
366 /* Choose a buffer for the frame's root window. */
370 XWINDOW (root_window
)->buffer
= Qt
;
371 buf
= Fcurrent_buffer ();
372 /* If buf is a 'hidden' buffer (i.e. one whose name starts with
373 a space), try to find another one. */
374 if (SREF (Fbuffer_name (buf
), 0) == ' ')
375 buf
= Fother_buffer (buf
, Qnil
, Qnil
);
377 /* Use set_window_buffer, not Fset_window_buffer, and don't let
378 hooks be run by it. The reason is that the whole frame/window
379 arrangement is not yet fully intialized at this point. Windows
380 don't have the right size, glyph matrices aren't initialized
381 etc. Running Lisp functions at this point surely ends in a
383 set_window_buffer (root_window
, buf
, 0, 0);
384 f
->buffer_list
= Fcons (buf
, Qnil
);
389 XWINDOW (mini_window
)->buffer
= Qt
;
390 set_window_buffer (mini_window
,
391 (NILP (Vminibuffer_list
)
393 : Fcar (Vminibuffer_list
)),
397 f
->root_window
= root_window
;
398 f
->selected_window
= root_window
;
399 /* Make sure this window seems more recently used than
400 a newly-created, never-selected window. */
401 ++window_select_count
;
402 XSETFASTINT (XWINDOW (f
->selected_window
)->use_time
, window_select_count
);
404 f
->default_face_done_p
= 0;
409 #ifdef HAVE_WINDOW_SYSTEM
410 /* Make a frame using a separate minibuffer window on another frame.
411 MINI_WINDOW is the minibuffer window to use. nil means use the
412 default (the global minibuffer). */
415 make_frame_without_minibuffer (mini_window
, kb
, display
)
416 register Lisp_Object mini_window
;
420 register struct frame
*f
;
423 if (!NILP (mini_window
))
424 CHECK_LIVE_WINDOW (mini_window
);
427 if (!NILP (mini_window
)
428 && XFRAME (XWINDOW (mini_window
)->frame
)->kboard
!= kb
)
429 error ("frame and minibuffer must be on the same display");
432 /* Make a frame containing just a root window. */
435 if (NILP (mini_window
))
437 /* Use default-minibuffer-frame if possible. */
438 if (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
439 || ! FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
)))
441 Lisp_Object frame_dummy
;
443 XSETFRAME (frame_dummy
, f
);
444 GCPRO1 (frame_dummy
);
445 /* If there's no minibuffer frame to use, create one. */
446 kb
->Vdefault_minibuffer_frame
=
447 call1 (intern ("make-initial-minibuffer-frame"), display
);
451 mini_window
= XFRAME (kb
->Vdefault_minibuffer_frame
)->minibuffer_window
;
454 f
->minibuffer_window
= mini_window
;
456 /* Make the chosen minibuffer window display the proper minibuffer,
457 unless it is already showing a minibuffer. */
458 if (NILP (Fmemq (XWINDOW (mini_window
)->buffer
, Vminibuffer_list
)))
459 Fset_window_buffer (mini_window
,
460 (NILP (Vminibuffer_list
)
462 : Fcar (Vminibuffer_list
)), Qnil
);
466 /* Make a frame containing only a minibuffer window. */
469 make_minibuffer_frame ()
471 /* First make a frame containing just a root window, no minibuffer. */
473 register struct frame
*f
= make_frame (0);
474 register Lisp_Object mini_window
;
475 register Lisp_Object frame
;
477 XSETFRAME (frame
, f
);
482 f
->wants_modeline
= 0;
483 f
->has_minibuffer
= 1;
485 /* Now label the root window as also being the minibuffer.
486 Avoid infinite looping on the window chain by marking next pointer
489 mini_window
= f
->minibuffer_window
= f
->root_window
;
490 XWINDOW (mini_window
)->mini_p
= Qt
;
491 XWINDOW (mini_window
)->next
= Qnil
;
492 XWINDOW (mini_window
)->prev
= Qnil
;
493 XWINDOW (mini_window
)->frame
= frame
;
495 /* Put the proper buffer in that window. */
497 Fset_window_buffer (mini_window
,
498 (NILP (Vminibuffer_list
)
500 : Fcar (Vminibuffer_list
)), Qnil
);
503 #endif /* HAVE_WINDOW_SYSTEM */
505 /* Construct a frame that refers to a terminal. */
507 static int terminal_frame_count
;
510 make_initial_frame (void)
513 struct display
*display
;
517 /* Create the initial keyboard. */
520 initial_kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
521 init_kboard (initial_kboard
);
522 initial_kboard
->next_kboard
= all_kboards
;
523 all_kboards
= initial_kboard
;
527 /* The first call must initialize Vframe_list. */
528 if (! (NILP (Vframe_list
) || CONSP (Vframe_list
)))
531 display
= init_initial_display ();
534 XSETFRAME (frame
, f
);
536 Vframe_list
= Fcons (frame
, Vframe_list
);
538 terminal_frame_count
= 1;
539 f
->name
= build_string ("F1");
542 f
->async_visible
= 1;
544 f
->output_method
= display
->type
;
545 f
->display
= display
;
546 f
->display
->reference_count
++;
547 f
->output_data
.nothing
= 0;
549 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
550 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
552 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
553 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
556 f
->kboard
= initial_kboard
;
564 make_terminal_frame (struct display
*display
)
566 register struct frame
*f
;
572 XSETFRAME (frame
, f
);
573 Vframe_list
= Fcons (frame
, Vframe_list
);
575 terminal_frame_count
++;
576 sprintf (name
, "F%d", terminal_frame_count
);
577 f
->name
= build_string (name
);
579 f
->visible
= 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
580 f
->async_visible
= 1; /* Don't let visible be cleared later. */
582 f
->output_data
.x
= &the_only_x_display
;
583 if (!inhibit_window_system
584 && (!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
))
585 || XFRAME (selected_frame
)->output_method
== output_msdos_raw
))
587 f
->output_method
= output_msdos_raw
;
588 /* This initialization of foreground and background pixels is
589 only important for the initial frame created in temacs. If
590 we don't do that, we get black background and foreground in
591 the dumped Emacs because the_only_x_display is a static
592 variable, hence it is born all-zeroes, and zero is the code
593 for the black color. Other frames all inherit their pixels
594 from what's already in the_only_x_display. */
595 if ((!FRAMEP (selected_frame
) || !FRAME_LIVE_P (XFRAME (selected_frame
)))
596 && f
->output_data
.x
->background_pixel
== 0
597 && f
->output_data
.x
->foreground_pixel
== 0)
599 f
->output_data
.x
->background_pixel
= FACE_TTY_DEFAULT_BG_COLOR
;
600 f
->output_data
.x
->foreground_pixel
= FACE_TTY_DEFAULT_FG_COLOR
;
604 f
->output_method
= output_termcap
;
607 f
->output_method
= output_termcap
;
608 f
->output_data
.x
= &tty_display
; /* XXX ??? */
611 make_mac_terminal_frame (f
);
614 f
->output_method
= output_termcap
;
615 f
->display
= display
;
616 f
->display
->reference_count
++;
617 create_tty_output (f
);
619 FRAME_FOREGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_FG_COLOR
;
620 FRAME_BACKGROUND_PIXEL (f
) = FACE_TTY_DEFAULT_BG_COLOR
;
622 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
623 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
626 f
->kboard
= FRAME_TTY (f
)->kboard
;
629 /* Set the top frame to the newly created frame. */
630 if (FRAME_TTY (f
)->top_frame
631 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f
)->top_frame
)))
632 XFRAME (FRAME_TTY (f
)->top_frame
)->async_visible
= 2; /* obscured */
634 FRAME_TTY (f
)->top_frame
= frame
;
638 FRAME_FOREGROUND_PIXEL(f
) = FACE_TTY_DEFAULT_FG_COLOR
;
639 FRAME_BACKGROUND_PIXEL(f
) = FACE_TTY_DEFAULT_BG_COLOR
;
642 #endif /* WINDOWSNT */
646 init_frame_faces (f
);
651 DEFUN ("make-terminal-frame", Fmake_terminal_frame
, Smake_terminal_frame
,
653 doc
: /* Create an additional terminal frame, possibly on another terminal.
654 This function takes one argument, an alist specifying frame parameters.
656 You can create multiple frames on a single text-only terminal, but
657 only one of them (the selected terminal frame) is actually displayed.
659 In practice, generally you don't need to specify any parameters,
660 except when you want to create a new frame on another terminal.
661 In that case, the `tty' parameter specifies the device file to open,
662 and the `tty-type' parameter specifies the terminal type. Example:
664 (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
666 Note that changing the size of one terminal frame automatically
667 affects all frames on the same terminal device. */)
672 struct display
*d
= NULL
;
673 Lisp_Object frame
, tem
;
674 struct frame
*sf
= SELECTED_FRAME ();
677 if (sf
->output_method
!= output_msdos_raw
678 && sf
->output_method
!= output_termcap
)
680 #else /* not MSDOS */
683 if (sf
->output_method
!= output_mac
)
684 error ("Not running on a Macintosh screen; cannot make a new Macintosh frame");
686 #if 0 /* This should work now! */
687 if (sf
->output_method
!= output_termcap
)
688 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
691 #endif /* not MSDOS */
694 Lisp_Object display_device
;
696 display_device
= Fassq (Qdisplay_id
, parms
);
697 if (!NILP (display_device
))
699 display_device
= XCDR (display_device
);
700 CHECK_NUMBER (display_device
);
701 d
= get_display (XINT (display_device
));
703 wrong_type_argument (Qdisplay_live_p
, display_device
);
709 Lisp_Object tty
, tty_type
;
710 char *name
= 0, *type
= 0;
712 tty
= Fassq (Qtty
, parms
);
714 tty
= Fassq (Qtty
, XFRAME (selected_frame
)->param_alist
);
715 if (EQ (tty
, Qnil
) && FRAME_TERMCAP_P (XFRAME (selected_frame
))
716 && FRAME_TTY (XFRAME (selected_frame
))->name
)
717 tty
= build_string (FRAME_TTY (XFRAME (selected_frame
))->name
);
719 tty
= Fassq (Qtty
, Vdefault_frame_alist
);
720 if (! EQ (tty
, Qnil
) && ! STRINGP (tty
))
722 if (EQ (tty
, Qnil
) || !STRINGP (tty
))
725 tty_type
= Fassq (Qtty_type
, parms
);
726 if (EQ (tty_type
, Qnil
))
727 tty_type
= Fassq (Qtty
, XFRAME (selected_frame
)->param_alist
);
728 if (EQ (tty_type
, Qnil
) && FRAME_TERMCAP_P (XFRAME (selected_frame
))
729 && FRAME_TTY (XFRAME (selected_frame
))->type
)
730 tty_type
= build_string (FRAME_TTY (XFRAME (selected_frame
))->type
);
731 if (EQ (tty_type
, Qnil
))
732 tty_type
= Fassq (Qtty_type
, Vdefault_frame_alist
);
733 if (! EQ (tty_type
, Qnil
) && ! STRINGP (tty_type
))
734 tty_type
= XCDR (tty_type
);
735 if (EQ (tty_type
, Qnil
) || !STRINGP (tty_type
))
738 if (! EQ (tty
, Qnil
))
740 name
= (char *) alloca (SBYTES (tty
) + 1);
741 strncpy (name
, SDATA (tty
), SBYTES (tty
));
742 name
[SBYTES (tty
)] = 0;
745 if (! EQ (tty_type
, Qnil
))
747 type
= (char *) alloca (SBYTES (tty_type
) + 1);
748 strncpy (type
, SDATA (tty_type
), SBYTES (tty_type
));
749 type
[SBYTES (tty_type
)] = 0;
752 d
= term_init (name
, type
, 0); /* Errors are not fatal. */
755 f
= make_terminal_frame (d
);
759 get_tty_size (fileno (FRAME_TTY (f
)->input
), &width
, &height
);
760 change_frame_size (f
, height
, width
, 0, 0, 0);
765 XSETFRAME (frame
, f
);
766 Fmodify_frame_parameters (frame
, Vdefault_frame_alist
);
767 Fmodify_frame_parameters (frame
, parms
);
768 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qwindow_system
, Qnil
), Qnil
));
770 /* Make the frame face alist be frame-specific, so that each
771 frame could change its face definitions independently. */
772 f
->face_alist
= Fcopy_alist (sf
->face_alist
);
773 /* Simple Fcopy_alist isn't enough, because we need the contents of
774 the vectors which are the CDRs of associations in face_alist to
775 be copied as well. */
776 for (tem
= f
->face_alist
; CONSP (tem
); tem
= XCDR (tem
))
777 XSETCDR (XCAR (tem
), Fcopy_sequence (XCDR (XCAR (tem
))));
782 /* Perform the switch to frame FRAME.
784 If FRAME is a switch-frame event `(switch-frame FRAME1)', use
787 If TRACK is non-zero and the frame that currently has the focus
788 redirects its focus to the selected frame, redirect that focused
789 frame's focus to FRAME instead.
791 FOR_DELETION non-zero means that the selected frame is being
792 deleted, which includes the possibility that the frame's display
796 do_switch_frame (frame
, track
, for_deletion
)
798 int track
, for_deletion
;
800 struct frame
*sf
= SELECTED_FRAME ();
802 /* If FRAME is a switch-frame event, extract the frame we should
805 && EQ (XCAR (frame
), Qswitch_frame
)
806 && CONSP (XCDR (frame
)))
807 frame
= XCAR (XCDR (frame
));
809 /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
810 a switch-frame event to arrive after a frame is no longer live,
811 especially when deleting the initial frame during startup. */
813 if (! FRAME_LIVE_P (XFRAME (frame
)))
816 if (sf
== XFRAME (frame
))
819 /* This is too greedy; it causes inappropriate focus redirection
820 that's hard to get rid of. */
822 /* If a frame's focus has been redirected toward the currently
823 selected frame, we should change the redirection to point to the
824 newly selected frame. This means that if the focus is redirected
825 from a minibufferless frame to a surrogate minibuffer frame, we
826 can use `other-window' to switch between all the frames using
827 that minibuffer frame, and the focus redirection will follow us
833 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
837 if (!FRAMEP (XCAR (tail
)))
840 focus
= FRAME_FOCUS_FRAME (XFRAME (XCAR (tail
)));
842 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
843 Fredirect_frame_focus (XCAR (tail
), frame
);
847 /* Instead, apply it only to the frame we're pointing to. */
848 #ifdef HAVE_WINDOW_SYSTEM
849 if (track
&& FRAME_WINDOW_P (XFRAME (frame
)))
851 Lisp_Object focus
, xfocus
;
853 xfocus
= x_get_focus_frame (XFRAME (frame
));
856 focus
= FRAME_FOCUS_FRAME (XFRAME (xfocus
));
857 if (FRAMEP (focus
) && XFRAME (focus
) == SELECTED_FRAME ())
858 Fredirect_frame_focus (xfocus
, frame
);
861 #endif /* HAVE_X_WINDOWS */
864 if (!for_deletion
&& FRAME_HAS_MINIBUF_P (sf
))
865 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf
)), 1);
867 if (FRAME_TERMCAP_P (XFRAME (selected_frame
))
868 && FRAME_TERMCAP_P (XFRAME (frame
))
869 && FRAME_TTY (XFRAME (selected_frame
)) == FRAME_TTY (XFRAME (frame
)))
871 XFRAME (selected_frame
)->async_visible
= 2; /* obscured */
872 XFRAME (frame
)->async_visible
= 1;
873 FRAME_TTY (XFRAME (frame
))->top_frame
= frame
;
876 selected_frame
= frame
;
877 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame
)))
878 last_nonminibuf_frame
= XFRAME (selected_frame
);
880 Fselect_window (XFRAME (frame
)->selected_window
, Qnil
);
883 /* Make sure to switch the tty color mode to that of the newly
885 sf
= SELECTED_FRAME ();
886 if (FRAME_TERMCAP_P (sf
))
888 Lisp_Object color_mode_spec
, color_mode
;
890 color_mode_spec
= assq_no_quit (Qtty_color_mode
, sf
->param_alist
);
891 if (CONSP (color_mode_spec
))
892 color_mode
= XCDR (color_mode_spec
);
894 color_mode
= make_number (0);
895 set_tty_color_mode (sf
, color_mode
);
897 #endif /* !WINDOWSNT */
899 /* We want to make sure that the next event generates a frame-switch
900 event to the appropriate frame. This seems kludgy to me, but
901 before you take it out, make sure that evaluating something like
902 (select-window (frame-root-window (new-frame))) doesn't end up
903 with your typing being interpreted in the new frame instead of
904 the one you're actually typing in. */
905 internal_last_event_frame
= Qnil
;
910 DEFUN ("select-frame", Fselect_frame
, Sselect_frame
, 1, 2, "e",
911 doc
: /* Select the frame FRAME.
912 Subsequent editing commands apply to its selected window.
913 The selection of FRAME lasts until the next time the user does
914 something to select a different frame, or until the next time this
915 function is called. If you are using a window system, the previously
916 selected frame may be restored as the selected frame after return to
917 the command loop, because it still may have the window system's input
918 focus. On a text-only terminal, the next redisplay will display FRAME.
920 This function returns FRAME, or nil if FRAME has been deleted. */)
922 Lisp_Object frame
, no_enter
;
924 return do_switch_frame (frame
, 1, 0);
928 DEFUN ("handle-switch-frame", Fhandle_switch_frame
, Shandle_switch_frame
, 1, 2, "e",
929 doc
: /* Handle a switch-frame event EVENT.
930 Switch-frame events are usually bound to this function.
931 A switch-frame event tells Emacs that the window manager has requested
932 that the user's events be directed to the frame mentioned in the event.
933 This function selects the selected window of the frame of EVENT.
935 If EVENT is frame object, handle it as if it were a switch-frame event
938 Lisp_Object event
, no_enter
;
940 /* Preserve prefix arg that the command loop just cleared. */
941 current_kboard
->Vprefix_arg
= Vcurrent_prefix_arg
;
942 call1 (Vrun_hooks
, Qmouse_leave_buffer_hook
);
943 return do_switch_frame (event
, 0, 0);
946 DEFUN ("selected-frame", Fselected_frame
, Sselected_frame
, 0, 0, 0,
947 doc
: /* Return the frame that is now selected. */)
950 return selected_frame
;
953 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
954 doc
: /* Return the frame object that window WINDOW is on. */)
958 CHECK_LIVE_WINDOW (window
);
959 return XWINDOW (window
)->frame
;
962 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
963 doc
: /* Returns the topmost, leftmost window of FRAME.
964 If omitted, FRAME defaults to the currently selected frame. */)
971 w
= SELECTED_FRAME ()->root_window
;
974 CHECK_LIVE_FRAME (frame
);
975 w
= XFRAME (frame
)->root_window
;
977 while (NILP (XWINDOW (w
)->buffer
))
979 if (! NILP (XWINDOW (w
)->hchild
))
980 w
= XWINDOW (w
)->hchild
;
981 else if (! NILP (XWINDOW (w
)->vchild
))
982 w
= XWINDOW (w
)->vchild
;
989 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
990 Sactive_minibuffer_window
, 0, 0, 0,
991 doc
: /* Return the currently active minibuffer window, or nil if none. */)
994 return minibuf_level
? minibuf_window
: Qnil
;
997 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
998 doc
: /* Returns the root-window of FRAME.
999 If omitted, FRAME defaults to the currently selected frame. */)
1006 window
= SELECTED_FRAME ()->root_window
;
1009 CHECK_LIVE_FRAME (frame
);
1010 window
= XFRAME (frame
)->root_window
;
1016 DEFUN ("frame-selected-window", Fframe_selected_window
,
1017 Sframe_selected_window
, 0, 1, 0,
1018 doc
: /* Return the selected window of frame object FRAME.
1019 If omitted, FRAME defaults to the currently selected frame. */)
1026 window
= SELECTED_FRAME ()->selected_window
;
1029 CHECK_LIVE_FRAME (frame
);
1030 window
= XFRAME (frame
)->selected_window
;
1036 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
1037 Sset_frame_selected_window
, 2, 2, 0,
1038 doc
: /* Set the selected window of frame object FRAME to WINDOW.
1040 If FRAME is nil, the selected frame is used.
1041 If FRAME is the selected frame, this makes WINDOW the selected window. */)
1043 Lisp_Object frame
, window
;
1046 frame
= selected_frame
;
1048 CHECK_LIVE_FRAME (frame
);
1049 CHECK_LIVE_WINDOW (window
);
1051 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
1052 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1054 if (EQ (frame
, selected_frame
))
1055 return Fselect_window (window
, Qnil
);
1057 return XFRAME (frame
)->selected_window
= window
;
1061 DEFUN ("frame-display", Fframe_display
, Sframe_display
, 0, 1, 0,
1062 doc
: /* Return the display device that FRAME is displayed on.
1063 If FRAME is nil, the selected frame is used.
1065 The display device is represented by its integer identifier. */)
1072 frame
= selected_frame
;
1074 CHECK_LIVE_FRAME (frame
);
1076 d
= get_display (frame
);
1081 return make_number (d
->id
);
1085 DEFUN ("frame-list", Fframe_list
, Sframe_list
,
1087 doc
: /* Return a list of all frames. */)
1091 frames
= Fcopy_sequence (Vframe_list
);
1092 #ifdef HAVE_WINDOW_SYSTEM
1093 if (FRAMEP (tip_frame
))
1094 frames
= Fdelq (tip_frame
, frames
);
1099 /* Return the next frame in the frame list after FRAME.
1100 If MINIBUF is nil, exclude minibuffer-only frames.
1101 If MINIBUF is a window, include only its own frame
1102 and any frame now using that window as the minibuffer.
1103 If MINIBUF is `visible', include all visible frames.
1104 If MINIBUF is 0, include all visible and iconified frames.
1105 Otherwise, include all frames. */
1108 next_frame (frame
, minibuf
)
1110 Lisp_Object minibuf
;
1115 /* There must always be at least one frame in Vframe_list. */
1116 if (! CONSP (Vframe_list
))
1119 /* If this frame is dead, it won't be in Vframe_list, and we'll loop
1120 forever. Forestall that. */
1121 CHECK_LIVE_FRAME (frame
);
1124 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1131 && ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1132 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1133 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1134 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
)))))
1136 /* Decide whether this frame is eligible to be returned. */
1138 /* If we've looped all the way around without finding any
1139 eligible frames, return the original frame. */
1143 /* Let minibuf decide if this frame is acceptable. */
1146 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1149 else if (EQ (minibuf
, Qvisible
))
1151 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1152 if (FRAME_VISIBLE_P (XFRAME (f
)))
1155 else if (INTEGERP (minibuf
) && XINT (minibuf
) == 0)
1157 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1158 if (FRAME_VISIBLE_P (XFRAME (f
))
1159 || FRAME_ICONIFIED_P (XFRAME (f
)))
1162 else if (WINDOWP (minibuf
))
1164 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1165 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1166 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1167 FRAME_FOCUS_FRAME (XFRAME (f
))))
1179 /* Return the previous frame in the frame list before FRAME.
1180 If MINIBUF is nil, exclude minibuffer-only frames.
1181 If MINIBUF is a window, include only its own frame
1182 and any frame now using that window as the minibuffer.
1183 If MINIBUF is `visible', include all visible frames.
1184 If MINIBUF is 0, include all visible and iconified frames.
1185 Otherwise, include all frames. */
1188 prev_frame (frame
, minibuf
)
1190 Lisp_Object minibuf
;
1195 /* There must always be at least one frame in Vframe_list. */
1196 if (! CONSP (Vframe_list
))
1200 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1208 if (EQ (frame
, f
) && !NILP (prev
))
1211 if ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1212 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1213 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1214 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
))))
1216 /* Decide whether this frame is eligible to be returned,
1217 according to minibuf. */
1220 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1223 else if (WINDOWP (minibuf
))
1225 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1226 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1227 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1228 FRAME_FOCUS_FRAME (XFRAME (f
))))
1231 else if (EQ (minibuf
, Qvisible
))
1233 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1234 if (FRAME_VISIBLE_P (XFRAME (f
)))
1237 else if (XFASTINT (minibuf
) == 0)
1239 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1240 if (FRAME_VISIBLE_P (XFRAME (f
))
1241 || FRAME_ICONIFIED_P (XFRAME (f
)))
1249 /* We've scanned the entire list. */
1251 /* We went through the whole frame list without finding a single
1252 acceptable frame. Return the original frame. */
1255 /* There were no acceptable frames in the list before FRAME; otherwise,
1256 we would have returned directly from the loop. Since PREV is the last
1257 acceptable frame in the list, return it. */
1262 DEFUN ("next-frame", Fnext_frame
, Snext_frame
, 0, 2, 0,
1263 doc
: /* Return the next frame in the frame list after FRAME.
1264 It considers only frames on the same terminal as FRAME.
1265 By default, skip minibuffer-only frames.
1266 If omitted, FRAME defaults to the selected frame.
1267 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1268 If MINIFRAME is a window, include only its own frame
1269 and any frame now using that window as the minibuffer.
1270 If MINIFRAME is `visible', include all visible frames.
1271 If MINIFRAME is 0, include all visible and iconified frames.
1272 Otherwise, include all frames. */)
1274 Lisp_Object frame
, miniframe
;
1277 frame
= selected_frame
;
1279 CHECK_LIVE_FRAME (frame
);
1280 return next_frame (frame
, miniframe
);
1283 DEFUN ("previous-frame", Fprevious_frame
, Sprevious_frame
, 0, 2, 0,
1284 doc
: /* Return the previous frame in the frame list before FRAME.
1285 It considers only frames on the same terminal as FRAME.
1286 By default, skip minibuffer-only frames.
1287 If omitted, FRAME defaults to the selected frame.
1288 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1289 If MINIFRAME is a window, include only its own frame
1290 and any frame now using that window as the minibuffer.
1291 If MINIFRAME is `visible', include all visible frames.
1292 If MINIFRAME is 0, include all visible and iconified frames.
1293 Otherwise, include all frames. */)
1295 Lisp_Object frame
, miniframe
;
1298 frame
= selected_frame
;
1299 CHECK_LIVE_FRAME (frame
);
1300 return prev_frame (frame
, miniframe
);
1303 /* Return 1 if it is ok to delete frame F;
1304 0 if all frames aside from F are invisible.
1305 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1308 other_visible_frames (f
)
1311 /* We know the selected frame is visible,
1312 so if F is some other frame, it can't be the sole visible one. */
1313 if (f
== SELECTED_FRAME ())
1318 for (frames
= Vframe_list
;
1320 frames
= XCDR (frames
))
1324 this = XCAR (frames
);
1325 /* Verify that the frame's window still exists
1326 and we can still talk to it. And note any recent change
1328 #ifdef HAVE_WINDOW_SYSTEM
1329 if (FRAME_WINDOW_P (XFRAME (this)))
1331 x_sync (XFRAME (this));
1332 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1336 if (FRAME_VISIBLE_P (XFRAME (this))
1337 || FRAME_ICONIFIED_P (XFRAME (this))
1338 /* Allow deleting the terminal frame when at least
1339 one X frame exists! */
1340 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f
)))
1348 DEFUN ("delete-frame", Fdelete_frame
, Sdelete_frame
, 0, 2, "",
1349 doc
: /* Delete FRAME, permanently eliminating it from use.
1350 If omitted, FRAME defaults to the selected frame.
1351 A frame may not be deleted if its minibuffer is used by other frames.
1352 Normally, you may not delete a frame if all other frames are invisible,
1353 but if the second optional argument FORCE is non-nil, you may do so.
1355 This function runs `delete-frame-functions' before actually deleting the
1356 frame, unless the frame is a tooltip.
1357 The functions are run with one arg, the frame to be deleted. */)
1359 Lisp_Object frame
, force
;
1362 struct frame
*sf
= SELECTED_FRAME ();
1363 int minibuffer_selected
;
1365 if (EQ (frame
, Qnil
))
1368 XSETFRAME (frame
, f
);
1372 CHECK_FRAME (frame
);
1376 if (! FRAME_LIVE_P (f
))
1379 if (NILP (force
) && !other_visible_frames (f
)
1381 /* Terminal frame deleted before any other visible frames are
1383 && strcmp (SDATA (f
->name
), "F1") != 0
1386 error ("Attempt to delete the sole visible or iconified frame");
1389 /* This is a nice idea, but x_connection_closed needs to be able
1390 to delete the last frame, if it is gone. */
1391 if (NILP (XCDR (Vframe_list
)))
1392 error ("Attempt to delete the only frame");
1395 /* Does this frame have a minibuffer, and is it the surrogate
1396 minibuffer for any other frame? */
1397 if (FRAME_HAS_MINIBUF_P (XFRAME (frame
)))
1401 for (frames
= Vframe_list
;
1403 frames
= XCDR (frames
))
1406 this = XCAR (frames
);
1408 if (! EQ (this, frame
)
1410 WINDOW_FRAME (XWINDOW
1411 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1412 error ("Attempt to delete a surrogate minibuffer frame");
1416 /* Run `delete-frame-functions' unless frame is a tooltip. */
1417 if (!NILP (Vrun_hooks
)
1418 && NILP (Fframe_parameter (frame
, intern ("tooltip"))))
1420 Lisp_Object args
[2];
1421 args
[0] = intern ("delete-frame-functions");
1423 Frun_hook_with_args (2, args
);
1426 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1427 if (! FRAME_LIVE_P (f
))
1430 minibuffer_selected
= EQ (minibuf_window
, selected_window
);
1432 /* Don't let the frame remain selected. */
1435 Lisp_Object tail
, frame1
;
1437 /* Look for another visible frame on the same terminal. */
1438 frame1
= next_frame (frame
, Qvisible
);
1440 /* If there is none, find *some* other frame. */
1441 if (NILP (frame1
) || EQ (frame1
, frame
))
1443 FOR_EACH_FRAME (tail
, frame1
)
1445 if (! EQ (frame
, frame1
) && FRAME_LIVE_P (XFRAME (frame1
)))
1450 do_switch_frame (frame1
, 0, 1);
1451 sf
= SELECTED_FRAME ();
1454 /* Don't allow minibuf_window to remain on a deleted frame. */
1455 if (EQ (f
->minibuffer_window
, minibuf_window
))
1457 Fset_window_buffer (sf
->minibuffer_window
,
1458 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1459 minibuf_window
= sf
->minibuffer_window
;
1461 /* If the dying minibuffer window was selected,
1462 select the new one. */
1463 if (minibuffer_selected
)
1464 Fselect_window (minibuf_window
, Qnil
);
1467 /* Don't let echo_area_window to remain on a deleted frame. */
1468 if (EQ (f
->minibuffer_window
, echo_area_window
))
1469 echo_area_window
= sf
->minibuffer_window
;
1471 /* Clear any X selections for this frame. */
1472 #ifdef HAVE_X_WINDOWS
1474 x_clear_frame_selections (f
);
1477 if (FRAME_MAC_P (f
))
1478 x_clear_frame_selections (f
);
1482 This function must be called before the window tree of the
1483 frame is deleted because windows contain dynamically allocated
1487 /* Mark all the windows that used to be on FRAME as deleted, and then
1488 remove the reference to them. */
1489 delete_all_subwindows (XWINDOW (f
->root_window
));
1490 f
->root_window
= Qnil
;
1492 Vframe_list
= Fdelq (frame
, Vframe_list
);
1493 FRAME_SET_VISIBLE (f
, 0);
1497 if (f
->decode_mode_spec_buffer
)
1498 xfree (f
->decode_mode_spec_buffer
);
1499 if (FRAME_INSERT_COST (f
))
1500 xfree (FRAME_INSERT_COST (f
));
1501 if (FRAME_DELETEN_COST (f
))
1502 xfree (FRAME_DELETEN_COST (f
));
1503 if (FRAME_INSERTN_COST (f
))
1504 xfree (FRAME_INSERTN_COST (f
));
1505 if (FRAME_DELETE_COST (f
))
1506 xfree (FRAME_DELETE_COST (f
));
1507 if (FRAME_MESSAGE_BUF (f
))
1508 xfree (FRAME_MESSAGE_BUF (f
));
1510 /* Since some events are handled at the interrupt level, we may get
1511 an event for f at any time; if we zero out the frame's display
1512 now, then we may trip up the event-handling code. Instead, we'll
1513 promise that the display of the frame must be valid until we have
1514 called the window-system-dependent frame destruction routine. */
1516 if (FRAME_DISPLAY (f
)->delete_frame_hook
)
1517 (*FRAME_DISPLAY (f
)->delete_frame_hook
) (f
);
1520 struct display
*display
= FRAME_DISPLAY (f
);
1522 f
->output_data
.nothing
= 0;
1523 f
->display
= 0; /* Now the frame is dead. */
1525 /* If needed, delete the device that this frame was on.
1526 (This must be done after the frame is killed.) */
1527 display
->reference_count
--;
1528 if (display
->reference_count
== 0)
1530 if (display
->delete_display_hook
)
1531 (*display
->delete_display_hook
) (display
);
1533 delete_display (display
);
1537 /* If we've deleted the last_nonminibuf_frame, then try to find
1539 if (f
== last_nonminibuf_frame
)
1543 last_nonminibuf_frame
= 0;
1545 for (frames
= Vframe_list
;
1547 frames
= XCDR (frames
))
1549 f
= XFRAME (XCAR (frames
));
1550 if (!FRAME_MINIBUF_ONLY_P (f
))
1552 last_nonminibuf_frame
= f
;
1558 /* If there's no other frame on the same kboard, get out of
1559 single-kboard state if we're in it for this kboard. */
1562 /* Some frame we found on the same kboard, or nil if there are none. */
1563 Lisp_Object frame_on_same_kboard
;
1565 frame_on_same_kboard
= Qnil
;
1567 for (frames
= Vframe_list
;
1569 frames
= XCDR (frames
))
1574 this = XCAR (frames
);
1579 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
))
1580 frame_on_same_kboard
= this;
1583 if (NILP (frame_on_same_kboard
))
1584 not_single_kboard_state (FRAME_KBOARD (f
));
1588 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1589 find another one. Prefer minibuffer-only frames, but also notice
1590 frames with other windows. */
1591 if (EQ (frame
, FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
))
1595 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1596 Lisp_Object frame_with_minibuf
;
1597 /* Some frame we found on the same kboard, or nil if there are none. */
1598 Lisp_Object frame_on_same_kboard
;
1600 frame_on_same_kboard
= Qnil
;
1601 frame_with_minibuf
= Qnil
;
1603 for (frames
= Vframe_list
;
1605 frames
= XCDR (frames
))
1610 this = XCAR (frames
);
1615 /* Consider only frames on the same kboard
1616 and only those with minibuffers. */
1617 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
)
1618 && FRAME_HAS_MINIBUF_P (f1
))
1620 frame_with_minibuf
= this;
1621 if (FRAME_MINIBUF_ONLY_P (f1
))
1625 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
))
1626 frame_on_same_kboard
= this;
1629 if (!NILP (frame_on_same_kboard
))
1631 /* We know that there must be some frame with a minibuffer out
1632 there. If this were not true, all of the frames present
1633 would have to be minibufferless, which implies that at some
1634 point their minibuffer frames must have been deleted, but
1635 that is prohibited at the top; you can't delete surrogate
1636 minibuffer frames. */
1637 if (NILP (frame_with_minibuf
))
1640 FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
= frame_with_minibuf
;
1643 /* No frames left on this kboard--say no minibuffer either. */
1644 FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
= Qnil
;
1647 /* Cause frame titles to update--necessary if we now have just one frame. */
1648 update_mode_lines
= 1;
1653 /* Return mouse position in character cell units. */
1655 DEFUN ("mouse-position", Fmouse_position
, Smouse_position
, 0, 0, 0,
1656 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1657 The position is given in character cells, where (0, 0) is the
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 ();
1679 /* It's okay for the hook to refrain from storing anything. */
1680 if (FRAME_DISPLAY (f
)->mouse_position_hook
)
1681 (*FRAME_DISPLAY (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
1707 If Emacs is running on a mouseless terminal or hasn't been programmed
1708 to read the mouse position, it returns the selected frame for FRAME
1709 and nil for X and Y. */)
1713 Lisp_Object lispy_dummy
;
1714 enum scroll_bar_part party_dummy
;
1716 unsigned long long_dummy
;
1718 f
= SELECTED_FRAME ();
1722 /* It's okay for the hook to refrain from storing anything. */
1723 if (FRAME_DISPLAY (f
)->mouse_position_hook
)
1724 (*FRAME_DISPLAY (f
)->mouse_position_hook
) (&f
, -1,
1725 &lispy_dummy
, &party_dummy
,
1729 XSETFRAME (lispy_dummy
, f
);
1730 return Fcons (lispy_dummy
, Fcons (x
, y
));
1733 DEFUN ("set-mouse-position", Fset_mouse_position
, Sset_mouse_position
, 3, 3, 0,
1734 doc
: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1735 Coordinates are relative to the frame, not a window,
1736 so the coordinates of the top left character in the frame
1737 may be nonzero due to left-hand scroll bars or the menu bar.
1739 This function is a no-op for an X frame that is not visible.
1740 If you have just created a frame, you must wait for it to become visible
1741 before calling this function on it, like this.
1742 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1744 Lisp_Object frame
, x
, y
;
1746 CHECK_LIVE_FRAME (frame
);
1750 /* I think this should be done with a hook. */
1751 #ifdef HAVE_WINDOW_SYSTEM
1752 if (FRAME_WINDOW_P (XFRAME (frame
)))
1753 /* Warping the mouse will cause enternotify and focus events. */
1754 x_set_mouse_position (XFRAME (frame
), XINT (x
), XINT (y
));
1756 #if defined (MSDOS) && defined (HAVE_MOUSE)
1757 if (FRAME_MSDOS_P (XFRAME (frame
)))
1759 Fselect_frame (frame
, Qnil
);
1760 mouse_moveto (XINT (x
), XINT (y
));
1768 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position
,
1769 Sset_mouse_pixel_position
, 3, 3, 0,
1770 doc
: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
1771 Note, this is a no-op for an X frame that is not visible.
1772 If you have just created a frame, you must wait for it to become visible
1773 before calling this function on it, like this.
1774 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1776 Lisp_Object frame
, x
, y
;
1778 CHECK_LIVE_FRAME (frame
);
1782 /* I think this should be done with a hook. */
1783 #ifdef HAVE_WINDOW_SYSTEM
1784 if (FRAME_WINDOW_P (XFRAME (frame
)))
1785 /* Warping the mouse will cause enternotify and focus events. */
1786 x_set_mouse_pixel_position (XFRAME (frame
), XINT (x
), XINT (y
));
1788 #if defined (MSDOS) && defined (HAVE_MOUSE)
1789 if (FRAME_MSDOS_P (XFRAME (frame
)))
1791 Fselect_frame (frame
, Qnil
);
1792 mouse_moveto (XINT (x
), XINT (y
));
1800 static void make_frame_visible_1
P_ ((Lisp_Object
));
1802 DEFUN ("make-frame-visible", Fmake_frame_visible
, Smake_frame_visible
,
1804 doc
: /* Make the frame FRAME visible (assuming it is an X window).
1805 If omitted, FRAME defaults to the currently selected frame. */)
1810 frame
= selected_frame
;
1812 CHECK_LIVE_FRAME (frame
);
1814 /* I think this should be done with a hook. */
1815 #ifdef HAVE_WINDOW_SYSTEM
1816 if (FRAME_WINDOW_P (XFRAME (frame
)))
1818 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1819 x_make_frame_visible (XFRAME (frame
));
1823 make_frame_visible_1 (XFRAME (frame
)->root_window
);
1825 /* Make menu bar update for the Buffers and Frames menus. */
1826 windows_or_buffers_changed
++;
1831 /* Update the display_time slot of the buffers shown in WINDOW
1832 and all its descendents. */
1835 make_frame_visible_1 (window
)
1840 for (;!NILP (window
); window
= w
->next
)
1842 w
= XWINDOW (window
);
1844 if (!NILP (w
->buffer
))
1845 XBUFFER (w
->buffer
)->display_time
= Fcurrent_time ();
1847 if (!NILP (w
->vchild
))
1848 make_frame_visible_1 (w
->vchild
);
1849 if (!NILP (w
->hchild
))
1850 make_frame_visible_1 (w
->hchild
);
1854 DEFUN ("make-frame-invisible", Fmake_frame_invisible
, Smake_frame_invisible
,
1856 doc
: /* Make the frame FRAME invisible (assuming it is an X window).
1857 If omitted, FRAME defaults to the currently selected frame.
1858 Normally you may not make FRAME invisible if all other frames are invisible,
1859 but if the second optional argument FORCE is non-nil, you may do so. */)
1861 Lisp_Object frame
, force
;
1864 frame
= selected_frame
;
1866 CHECK_LIVE_FRAME (frame
);
1868 if (NILP (force
) && !other_visible_frames (XFRAME (frame
)))
1869 error ("Attempt to make invisible the sole visible or iconified frame");
1871 #if 0 /* This isn't logically necessary, and it can do GC. */
1872 /* Don't let the frame remain selected. */
1873 if (EQ (frame
, selected_frame
))
1874 do_switch_frame (next_frame (frame
, Qt
), 0, 0)
1877 /* Don't allow minibuf_window to remain on a deleted frame. */
1878 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1880 struct frame
*sf
= XFRAME (selected_frame
);
1881 Fset_window_buffer (sf
->minibuffer_window
,
1882 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1883 minibuf_window
= sf
->minibuffer_window
;
1886 /* I think this should be done with a hook. */
1887 #ifdef HAVE_WINDOW_SYSTEM
1888 if (FRAME_WINDOW_P (XFRAME (frame
)))
1889 x_make_frame_invisible (XFRAME (frame
));
1892 /* Make menu bar update for the Buffers and Frames menus. */
1893 windows_or_buffers_changed
++;
1898 DEFUN ("iconify-frame", Ficonify_frame
, Siconify_frame
,
1900 doc
: /* Make the frame FRAME into an icon.
1901 If omitted, FRAME defaults to the currently selected frame. */)
1906 frame
= selected_frame
;
1908 CHECK_LIVE_FRAME (frame
);
1910 #if 0 /* This isn't logically necessary, and it can do GC. */
1911 /* Don't let the frame remain selected. */
1912 if (EQ (frame
, selected_frame
))
1913 Fhandle_switch_frame (next_frame (frame
, Qt
), Qnil
);
1916 /* Don't allow minibuf_window to remain on a deleted frame. */
1917 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1919 struct frame
*sf
= XFRAME (selected_frame
);
1920 Fset_window_buffer (sf
->minibuffer_window
,
1921 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1922 minibuf_window
= sf
->minibuffer_window
;
1925 /* I think this should be done with a hook. */
1926 #ifdef HAVE_WINDOW_SYSTEM
1927 if (FRAME_WINDOW_P (XFRAME (frame
)))
1928 x_iconify_frame (XFRAME (frame
));
1931 /* Make menu bar update for the Buffers and Frames menus. */
1932 windows_or_buffers_changed
++;
1937 DEFUN ("frame-visible-p", Fframe_visible_p
, Sframe_visible_p
,
1939 doc
: /* Return t if FRAME is now \"visible\" (actually in use for display).
1940 A frame that is not \"visible\" is not updated and, if it works through
1941 a window system, it may not show at all.
1942 Return the symbol `icon' if frame is visible only as an icon.
1944 On a text-only terminal, all frames are considered visible, whether
1945 they are currently being displayed or not, and this function returns t
1950 CHECK_LIVE_FRAME (frame
);
1952 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1954 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1956 if (FRAME_ICONIFIED_P (XFRAME (frame
)))
1961 DEFUN ("visible-frame-list", Fvisible_frame_list
, Svisible_frame_list
,
1963 doc
: /* Return a list of all frames now \"visible\" (being updated). */)
1966 Lisp_Object tail
, frame
;
1971 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1973 frame
= XCAR (tail
);
1974 if (!FRAMEP (frame
))
1977 if (FRAME_VISIBLE_P (f
))
1978 value
= Fcons (frame
, value
);
1984 DEFUN ("raise-frame", Fraise_frame
, Sraise_frame
, 0, 1, "",
1985 doc
: /* Bring FRAME to the front, so it occludes any frames it overlaps.
1986 If FRAME is invisible or iconified, make it visible.
1987 If you don't specify a frame, the selected frame is used.
1988 If Emacs is displaying on an ordinary terminal or some other device which
1989 doesn't support multiple overlapping frames, this function does nothing. */)
1995 frame
= selected_frame
;
1997 CHECK_LIVE_FRAME (frame
);
2001 /* Do like the documentation says. */
2002 Fmake_frame_visible (frame
);
2004 if (FRAME_DISPLAY (f
)->frame_raise_lower_hook
)
2005 (*FRAME_DISPLAY (f
)->frame_raise_lower_hook
) (f
, 1);
2010 /* Should we have a corresponding function called Flower_Power? */
2011 DEFUN ("lower-frame", Flower_frame
, Slower_frame
, 0, 1, "",
2012 doc
: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2013 If you don't specify a frame, the selected frame is used.
2014 If Emacs is displaying on an ordinary terminal or some other device which
2015 doesn't support multiple overlapping frames, this function does nothing. */)
2022 frame
= selected_frame
;
2024 CHECK_LIVE_FRAME (frame
);
2028 if (FRAME_DISPLAY (f
)->frame_raise_lower_hook
)
2029 (*FRAME_DISPLAY (f
)->frame_raise_lower_hook
) (f
, 0);
2035 DEFUN ("redirect-frame-focus", Fredirect_frame_focus
, Sredirect_frame_focus
,
2037 doc
: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2038 In other words, switch-frame events caused by events in FRAME will
2039 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2040 FOCUS-FRAME after reading an event typed at FRAME.
2042 If FOCUS-FRAME is omitted or nil, any existing redirection is
2043 cancelled, and the frame again receives its own keystrokes.
2045 Focus redirection is useful for temporarily redirecting keystrokes to
2046 a surrogate minibuffer frame when a frame doesn't have its own
2049 A frame's focus redirection can be changed by select-frame. If frame
2050 FOO is selected, and then a different frame BAR is selected, any
2051 frames redirecting their focus to FOO are shifted to redirect their
2052 focus to BAR. This allows focus redirection to work properly when the
2053 user switches from one frame to another using `select-window'.
2055 This means that a frame whose focus is redirected to itself is treated
2056 differently from a frame whose focus is redirected to nil; the former
2057 is affected by select-frame, while the latter is not.
2059 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2060 (frame
, focus_frame
)
2061 Lisp_Object frame
, focus_frame
;
2065 /* Note that we don't check for a live frame here. It's reasonable
2066 to redirect the focus of a frame you're about to delete, if you
2067 know what other frame should receive those keystrokes. */
2068 CHECK_FRAME (frame
);
2070 if (! NILP (focus_frame
))
2071 CHECK_LIVE_FRAME (focus_frame
);
2075 f
->focus_frame
= focus_frame
;
2077 if (FRAME_DISPLAY (f
)->frame_rehighlight_hook
)
2078 (*FRAME_DISPLAY (f
)->frame_rehighlight_hook
) (f
);
2084 DEFUN ("frame-focus", Fframe_focus
, Sframe_focus
, 1, 1, 0,
2085 doc
: /* Return the frame to which FRAME's keystrokes are currently being sent.
2086 This returns nil if FRAME's focus is not redirected.
2087 See `redirect-frame-focus'. */)
2091 CHECK_LIVE_FRAME (frame
);
2093 return FRAME_FOCUS_FRAME (XFRAME (frame
));
2098 /* Return the value of frame parameter PROP in frame FRAME. */
2101 get_frame_param (frame
, prop
)
2102 register struct frame
*frame
;
2105 register Lisp_Object tem
;
2107 tem
= Fassq (prop
, frame
->param_alist
);
2113 /* Return the buffer-predicate of the selected frame. */
2116 frame_buffer_predicate (frame
)
2119 return XFRAME (frame
)->buffer_predicate
;
2122 /* Return the buffer-list of the selected frame. */
2125 frame_buffer_list (frame
)
2128 return XFRAME (frame
)->buffer_list
;
2131 /* Set the buffer-list of the selected frame. */
2134 set_frame_buffer_list (frame
, list
)
2135 Lisp_Object frame
, list
;
2137 XFRAME (frame
)->buffer_list
= list
;
2140 /* Discard BUFFER from the buffer-list of each frame. */
2143 frames_discard_buffer (buffer
)
2146 Lisp_Object frame
, tail
;
2148 FOR_EACH_FRAME (tail
, frame
)
2150 XFRAME (frame
)->buffer_list
2151 = Fdelq (buffer
, XFRAME (frame
)->buffer_list
);
2155 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2156 If the alist already has an element for PROP, we change it. */
2159 store_in_alist (alistptr
, prop
, val
)
2160 Lisp_Object
*alistptr
, val
;
2163 register Lisp_Object tem
;
2165 tem
= Fassq (prop
, *alistptr
);
2167 *alistptr
= Fcons (Fcons (prop
, val
), *alistptr
);
2173 frame_name_fnn_p (str
, len
)
2177 if (len
> 1 && str
[0] == 'F')
2181 strtol (str
+ 1, &end_ptr
, 10);
2183 if (end_ptr
== str
+ len
)
2189 /* Set the name of the terminal frame. Also used by MSDOS frames.
2190 Modeled after x_set_name which is used for WINDOW frames. */
2193 set_term_frame_name (f
, name
)
2197 f
->explicit_name
= ! NILP (name
);
2199 /* If NAME is nil, set the name to F<num>. */
2204 /* Check for no change needed in this very common case
2205 before we do any consing. */
2206 if (frame_name_fnn_p (SDATA (f
->name
),
2210 terminal_frame_count
++;
2211 sprintf (namebuf
, "F%d", terminal_frame_count
);
2212 name
= build_string (namebuf
);
2216 CHECK_STRING (name
);
2218 /* Don't change the name if it's already NAME. */
2219 if (! NILP (Fstring_equal (name
, f
->name
)))
2222 /* Don't allow the user to set the frame name to F<num>, so it
2223 doesn't clash with the names we generate for terminal frames. */
2224 if (frame_name_fnn_p (SDATA (name
), SBYTES (name
)))
2225 error ("Frame names of the form F<num> are usurped by Emacs");
2229 update_mode_lines
= 1;
2233 store_frame_param (f
, prop
, val
)
2235 Lisp_Object prop
, val
;
2237 register Lisp_Object old_alist_elt
;
2239 /* The buffer-alist parameter is stored in a special place and is
2240 not in the alist. */
2241 if (EQ (prop
, Qbuffer_list
))
2243 f
->buffer_list
= val
;
2247 /* If PROP is a symbol which is supposed to have frame-local values,
2248 and it is set up based on this frame, switch to the global
2249 binding. That way, we can create or alter the frame-local binding
2250 without messing up the symbol's status. */
2253 Lisp_Object valcontents
;
2254 valcontents
= SYMBOL_VALUE (prop
);
2255 if ((BUFFER_LOCAL_VALUEP (valcontents
)
2256 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
2257 && XBUFFER_LOCAL_VALUE (valcontents
)->check_frame
2258 && XFRAME (XBUFFER_LOCAL_VALUE (valcontents
)->frame
) == f
)
2259 swap_in_global_binding (prop
);
2263 /* The tty color mode needs to be set before the frame's parameter
2264 alist is updated with the new value, because set_tty_color_mode
2265 wants to look at the old mode. */
2266 if (FRAME_TERMCAP_P (f
) && EQ (prop
, Qtty_color_mode
))
2267 set_tty_color_mode (f
, val
);
2270 /* Update the frame parameter alist. */
2271 old_alist_elt
= Fassq (prop
, f
->param_alist
);
2272 if (EQ (old_alist_elt
, Qnil
))
2273 f
->param_alist
= Fcons (Fcons (prop
, val
), f
->param_alist
);
2275 Fsetcdr (old_alist_elt
, val
);
2277 /* Update some other special parameters in their special places
2278 in addition to the alist. */
2280 if (EQ (prop
, Qbuffer_predicate
))
2281 f
->buffer_predicate
= val
;
2283 if (! FRAME_WINDOW_P (f
))
2285 if (EQ (prop
, Qmenu_bar_lines
))
2286 set_menu_bar_lines (f
, val
, make_number (FRAME_MENU_BAR_LINES (f
)));
2287 else if (EQ (prop
, Qname
))
2288 set_term_frame_name (f
, val
);
2291 if (EQ (prop
, Qminibuffer
) && WINDOWP (val
))
2293 if (! MINI_WINDOW_P (XWINDOW (val
)))
2294 error ("Surrogate minibuffer windows must be minibuffer windows");
2296 if ((FRAME_HAS_MINIBUF_P (f
) || FRAME_MINIBUF_ONLY_P (f
))
2297 && !EQ (val
, f
->minibuffer_window
))
2298 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2300 /* Install the chosen minibuffer window, with proper buffer. */
2301 f
->minibuffer_window
= val
;
2305 DEFUN ("frame-parameters", Fframe_parameters
, Sframe_parameters
, 0, 1, 0,
2306 doc
: /* Return the parameters-alist of frame FRAME.
2307 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2308 The meaningful PARMs depend on the kind of frame.
2309 If FRAME is omitted, return information on the currently selected frame. */)
2316 struct gcpro gcpro1
;
2319 frame
= selected_frame
;
2321 CHECK_FRAME (frame
);
2324 if (!FRAME_LIVE_P (f
))
2327 alist
= Fcopy_alist (f
->param_alist
);
2330 if (!FRAME_WINDOW_P (f
))
2332 int fg
= FRAME_FOREGROUND_PIXEL (f
);
2333 int bg
= FRAME_BACKGROUND_PIXEL (f
);
2336 /* If the frame's parameter alist says the colors are
2337 unspecified and reversed, take the frame's background pixel
2338 for foreground and vice versa. */
2339 elt
= Fassq (Qforeground_color
, alist
);
2340 if (!NILP (elt
) && CONSP (elt
) && STRINGP (XCDR (elt
)))
2342 if (strncmp (SDATA (XCDR (elt
)),
2344 SCHARS (XCDR (elt
))) == 0)
2345 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, bg
));
2346 else if (strncmp (SDATA (XCDR (elt
)),
2348 SCHARS (XCDR (elt
))) == 0)
2349 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2352 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2353 elt
= Fassq (Qbackground_color
, alist
);
2354 if (!NILP (elt
) && CONSP (elt
) && STRINGP (XCDR (elt
)))
2356 if (strncmp (SDATA (XCDR (elt
)),
2358 SCHARS (XCDR (elt
))) == 0)
2359 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, fg
));
2360 else if (strncmp (SDATA (XCDR (elt
)),
2362 SCHARS (XCDR (elt
))) == 0)
2363 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2366 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2367 store_in_alist (&alist
, intern ("font"),
2368 build_string (FRAME_MSDOS_P (f
)
2370 : FRAME_W32_P (f
) ? "w32term"
2373 store_in_alist (&alist
, Qname
, f
->name
);
2374 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2375 store_in_alist (&alist
, Qheight
, make_number (height
));
2376 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2377 store_in_alist (&alist
, Qwidth
, make_number (width
));
2378 store_in_alist (&alist
, Qmodeline
, (FRAME_WANTS_MODELINE_P (f
) ? Qt
: Qnil
));
2379 store_in_alist (&alist
, Qminibuffer
,
2380 (! FRAME_HAS_MINIBUF_P (f
) ? Qnil
2381 : FRAME_MINIBUF_ONLY_P (f
) ? Qonly
2382 : FRAME_MINIBUF_WINDOW (f
)));
2383 store_in_alist (&alist
, Qunsplittable
, (FRAME_NO_SPLIT_P (f
) ? Qt
: Qnil
));
2384 store_in_alist (&alist
, Qbuffer_list
, frame_buffer_list (frame
));
2386 /* I think this should be done with a hook. */
2387 #ifdef HAVE_WINDOW_SYSTEM
2388 if (FRAME_WINDOW_P (f
))
2389 x_report_frame_params (f
, &alist
);
2393 /* This ought to be correct in f->param_alist for an X frame. */
2395 XSETFASTINT (lines
, FRAME_MENU_BAR_LINES (f
));
2396 store_in_alist (&alist
, Qmenu_bar_lines
, lines
);
2404 DEFUN ("frame-parameter", Fframe_parameter
, Sframe_parameter
, 2, 2, 0,
2405 doc
: /* Return FRAME's value for parameter PARAMETER.
2406 If FRAME is nil, describe the currently selected frame. */)
2408 Lisp_Object frame
, parameter
;
2414 frame
= selected_frame
;
2416 CHECK_FRAME (frame
);
2417 CHECK_SYMBOL (parameter
);
2422 if (FRAME_LIVE_P (f
))
2424 /* Avoid consing in frequent cases. */
2425 if (EQ (parameter
, Qname
))
2427 #ifdef HAVE_X_WINDOWS
2428 else if (EQ (parameter
, Qdisplay
) && FRAME_X_P (f
))
2429 value
= XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
);
2430 #endif /* HAVE_X_WINDOWS */
2431 else if (EQ (parameter
, Qbackground_color
)
2432 || EQ (parameter
, Qforeground_color
))
2434 value
= Fassq (parameter
, f
->param_alist
);
2437 value
= XCDR (value
);
2438 /* Fframe_parameters puts the actual fg/bg color names,
2439 even if f->param_alist says otherwise. This is
2440 important when param_alist's notion of colors is
2441 "unspecified". We need to do the same here. */
2442 if (STRINGP (value
) && !FRAME_WINDOW_P (f
))
2444 const char *color_name
;
2447 if (EQ (parameter
, Qbackground_color
))
2449 color_name
= SDATA (value
);
2450 csz
= SCHARS (value
);
2451 if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2452 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2453 else if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2454 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2456 else if (EQ (parameter
, Qforeground_color
))
2458 color_name
= SDATA (value
);
2459 csz
= SCHARS (value
);
2460 if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2461 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2462 else if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2463 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2468 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2470 else if (EQ (parameter
, Qdisplay_type
)
2471 || EQ (parameter
, Qbackground_mode
))
2472 value
= Fcdr (Fassq (parameter
, f
->param_alist
));
2474 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2481 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters
,
2482 Smodify_frame_parameters
, 2, 2, 0,
2483 doc
: /* Modify the parameters of frame FRAME according to ALIST.
2484 If FRAME is nil, it defaults to the selected frame.
2485 ALIST is an alist of parameters to change and their new values.
2486 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2487 The meaningful PARMs depend on the kind of frame.
2488 Undefined PARMs are ignored, but stored in the frame's parameter list
2489 so that `frame-parameters' will return them.
2491 The value of frame parameter FOO can also be accessed
2492 as a frame-local binding for the variable FOO, if you have
2493 enabled such bindings for that variable with `make-variable-frame-local'. */)
2495 Lisp_Object frame
, alist
;
2498 register Lisp_Object tail
, prop
, val
;
2499 int count
= SPECPDL_INDEX ();
2501 /* Bind this to t to inhibit initialization of the default face from
2502 X resources in face-set-after-frame-default. If we don't inhibit
2503 this, modifying the `font' frame parameter, for example, while
2504 there is a `default.attributeFont' X resource, won't work,
2505 because `default's font is reset to the value of the X resource
2506 and that resets the `font' frame parameter. */
2507 specbind (Qinhibit_default_face_x_resources
, Qt
);
2509 if (EQ (frame
, Qnil
))
2510 frame
= selected_frame
;
2511 CHECK_LIVE_FRAME (frame
);
2514 /* I think this should be done with a hook. */
2515 #ifdef HAVE_WINDOW_SYSTEM
2516 if (FRAME_WINDOW_P (f
))
2517 x_set_frame_parameters (f
, alist
);
2521 if (FRAME_MSDOS_P (f
))
2522 IT_set_frame_parameters (f
, alist
);
2527 int length
= XINT (Flength (alist
));
2530 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2532 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2534 /* Extract parm names and values into those vectors. */
2537 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2542 parms
[i
] = Fcar (elt
);
2543 values
[i
] = Fcdr (elt
);
2547 /* Now process them in reverse of specified order. */
2548 for (i
--; i
>= 0; i
--)
2552 store_frame_param (f
, prop
, val
);
2556 return unbind_to (count
, Qnil
);
2559 DEFUN ("frame-char-height", Fframe_char_height
, Sframe_char_height
,
2561 doc
: /* Height in pixels of a line in the font in frame FRAME.
2562 If FRAME is omitted, the selected frame is used.
2563 For a terminal frame, the value is always 1. */)
2570 frame
= selected_frame
;
2571 CHECK_FRAME (frame
);
2574 #ifdef HAVE_WINDOW_SYSTEM
2575 if (FRAME_WINDOW_P (f
))
2576 return make_number (x_char_height (f
));
2579 return make_number (1);
2583 DEFUN ("frame-char-width", Fframe_char_width
, Sframe_char_width
,
2585 doc
: /* Width in pixels of characters in the font in frame FRAME.
2586 If FRAME is omitted, the selected frame is used.
2587 The width is the same for all characters, because
2588 currently Emacs supports only fixed-width fonts.
2589 For a terminal screen, the value is always 1. */)
2596 frame
= selected_frame
;
2597 CHECK_FRAME (frame
);
2600 #ifdef HAVE_WINDOW_SYSTEM
2601 if (FRAME_WINDOW_P (f
))
2602 return make_number (x_char_width (f
));
2605 return make_number (1);
2608 DEFUN ("frame-pixel-height", Fframe_pixel_height
,
2609 Sframe_pixel_height
, 0, 1, 0,
2610 doc
: /* Return a FRAME's height in pixels.
2611 This counts only the height available for text lines,
2612 not menu bars on window-system Emacs frames.
2613 For a terminal frame, the result really gives the height in characters.
2614 If FRAME is omitted, the selected frame is used. */)
2621 frame
= selected_frame
;
2622 CHECK_FRAME (frame
);
2625 #ifdef HAVE_WINDOW_SYSTEM
2626 if (FRAME_WINDOW_P (f
))
2627 return make_number (x_pixel_height (f
));
2630 return make_number (FRAME_LINES (f
));
2633 DEFUN ("frame-pixel-width", Fframe_pixel_width
,
2634 Sframe_pixel_width
, 0, 1, 0,
2635 doc
: /* Return FRAME's width in pixels.
2636 For a terminal frame, the result really gives the width in characters.
2637 If FRAME is omitted, the selected frame is used. */)
2644 frame
= selected_frame
;
2645 CHECK_FRAME (frame
);
2648 #ifdef HAVE_WINDOW_SYSTEM
2649 if (FRAME_WINDOW_P (f
))
2650 return make_number (x_pixel_width (f
));
2653 return make_number (FRAME_COLS (f
));
2656 DEFUN ("set-frame-height", Fset_frame_height
, Sset_frame_height
, 2, 3, 0,
2657 doc
: /* Specify that the frame FRAME has LINES lines.
2658 Optional third arg non-nil means that redisplay should use LINES lines
2659 but that the idea of the actual height of the frame should not be changed. */)
2660 (frame
, lines
, pretend
)
2661 Lisp_Object frame
, lines
, pretend
;
2663 register struct frame
*f
;
2665 CHECK_NUMBER (lines
);
2667 frame
= selected_frame
;
2668 CHECK_LIVE_FRAME (frame
);
2671 /* I think this should be done with a hook. */
2672 #ifdef HAVE_WINDOW_SYSTEM
2673 if (FRAME_WINDOW_P (f
))
2675 if (XINT (lines
) != FRAME_LINES (f
))
2676 x_set_window_size (f
, 1, FRAME_COLS (f
), XINT (lines
));
2677 do_pending_window_change (0);
2681 change_frame_size (f
, XINT (lines
), 0, !NILP (pretend
), 0, 0);
2685 DEFUN ("set-frame-width", Fset_frame_width
, Sset_frame_width
, 2, 3, 0,
2686 doc
: /* Specify that the frame FRAME has COLS columns.
2687 Optional third arg non-nil means that redisplay should use COLS columns
2688 but that the idea of the actual width of the frame should not be changed. */)
2689 (frame
, cols
, pretend
)
2690 Lisp_Object frame
, cols
, pretend
;
2692 register struct frame
*f
;
2693 CHECK_NUMBER (cols
);
2695 frame
= selected_frame
;
2696 CHECK_LIVE_FRAME (frame
);
2699 /* I think this should be done with a hook. */
2700 #ifdef HAVE_WINDOW_SYSTEM
2701 if (FRAME_WINDOW_P (f
))
2703 if (XINT (cols
) != FRAME_COLS (f
))
2704 x_set_window_size (f
, 1, XINT (cols
), FRAME_LINES (f
));
2705 do_pending_window_change (0);
2709 change_frame_size (f
, 0, XINT (cols
), !NILP (pretend
), 0, 0);
2713 DEFUN ("set-frame-size", Fset_frame_size
, Sset_frame_size
, 3, 3, 0,
2714 doc
: /* Sets size of FRAME to COLS by ROWS, measured in characters. */)
2716 Lisp_Object frame
, cols
, rows
;
2718 register struct frame
*f
;
2720 CHECK_LIVE_FRAME (frame
);
2721 CHECK_NUMBER (cols
);
2722 CHECK_NUMBER (rows
);
2725 /* I think this should be done with a hook. */
2726 #ifdef HAVE_WINDOW_SYSTEM
2727 if (FRAME_WINDOW_P (f
))
2729 if (XINT (rows
) != FRAME_LINES (f
)
2730 || XINT (cols
) != FRAME_COLS (f
)
2731 || f
->new_text_lines
|| f
->new_text_cols
)
2732 x_set_window_size (f
, 1, XINT (cols
), XINT (rows
));
2733 do_pending_window_change (0);
2737 change_frame_size (f
, XINT (rows
), XINT (cols
), 0, 0, 0);
2742 DEFUN ("set-frame-position", Fset_frame_position
,
2743 Sset_frame_position
, 3, 3, 0,
2744 doc
: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2745 This is actually the position of the upper left corner of the frame.
2746 Negative values for XOFFSET or YOFFSET are interpreted relative to
2747 the rightmost or bottommost possible position (that stays within the screen). */)
2748 (frame
, xoffset
, yoffset
)
2749 Lisp_Object frame
, xoffset
, yoffset
;
2751 register struct frame
*f
;
2753 CHECK_LIVE_FRAME (frame
);
2754 CHECK_NUMBER (xoffset
);
2755 CHECK_NUMBER (yoffset
);
2758 /* I think this should be done with a hook. */
2759 #ifdef HAVE_WINDOW_SYSTEM
2760 if (FRAME_WINDOW_P (f
))
2761 x_set_offset (f
, XINT (xoffset
), XINT (yoffset
), 1);
2768 /***********************************************************************
2770 ***********************************************************************/
2772 /* Connect the frame-parameter names for X frames
2773 to the ways of passing the parameter values to the window system.
2775 The name of a parameter, as a Lisp symbol,
2776 has an `x-frame-parameter' property which is an integer in Lisp
2777 that is an index in this table. */
2779 struct frame_parm_table
{
2781 Lisp_Object
*variable
;
2784 static struct frame_parm_table frame_parms
[] =
2786 {"auto-raise", &Qauto_raise
},
2787 {"auto-lower", &Qauto_lower
},
2788 {"background-color", 0},
2789 {"border-color", &Qborder_color
},
2790 {"border-width", &Qborder_width
},
2791 {"cursor-color", &Qcursor_color
},
2792 {"cursor-type", &Qcursor_type
},
2794 {"foreground-color", 0},
2795 {"icon-name", &Qicon_name
},
2796 {"icon-type", &Qicon_type
},
2797 {"internal-border-width", &Qinternal_border_width
},
2798 {"menu-bar-lines", &Qmenu_bar_lines
},
2799 {"mouse-color", &Qmouse_color
},
2801 {"scroll-bar-width", &Qscroll_bar_width
},
2803 {"unsplittable", &Qunsplittable
},
2804 {"vertical-scroll-bars", &Qvertical_scroll_bars
},
2805 {"visibility", &Qvisibility
},
2806 {"tool-bar-lines", &Qtool_bar_lines
},
2807 {"scroll-bar-foreground", &Qscroll_bar_foreground
},
2808 {"scroll-bar-background", &Qscroll_bar_background
},
2809 {"screen-gamma", &Qscreen_gamma
},
2810 {"line-spacing", &Qline_spacing
},
2811 {"left-fringe", &Qleft_fringe
},
2812 {"right-fringe", &Qright_fringe
},
2813 {"wait-for-wm", &Qwait_for_wm
},
2814 {"fullscreen", &Qfullscreen
},
2817 #ifdef HAVE_WINDOW_SYSTEM
2819 extern Lisp_Object Qbox
;
2820 extern Lisp_Object Qtop
;
2822 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
2823 wanted positions of the WM window (not emacs window).
2824 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
2825 window (FRAME_X_WINDOW).
2829 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
2836 int newwidth
= FRAME_COLS (f
);
2837 int newheight
= FRAME_LINES (f
);
2839 *top_pos
= f
->top_pos
;
2840 *left_pos
= f
->left_pos
;
2842 if (f
->want_fullscreen
& FULLSCREEN_HEIGHT
)
2846 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
2847 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2848 ph
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, newheight
) - f
->y_pixels_diff
;
2849 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2853 if (f
->want_fullscreen
& FULLSCREEN_WIDTH
)
2857 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
2858 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2859 pw
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, newwidth
) - f
->x_pixels_diff
;
2860 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2865 *height
= newheight
;
2869 /* Change the parameters of frame F as specified by ALIST.
2870 If a parameter is not specially recognized, do nothing special;
2871 otherwise call the `x_set_...' function for that parameter.
2872 Except for certain geometry properties, always call store_frame_param
2873 to store the new value in the parameter alist. */
2876 x_set_frame_parameters (f
, alist
)
2882 /* If both of these parameters are present, it's more efficient to
2883 set them both at once. So we wait until we've looked at the
2884 entire list before we set them. */
2888 Lisp_Object left
, top
;
2890 /* Same with these. */
2891 Lisp_Object icon_left
, icon_top
;
2893 /* Record in these vectors all the parms specified. */
2895 Lisp_Object
*values
;
2897 int left_no_change
= 0, top_no_change
= 0;
2898 int icon_left_no_change
= 0, icon_top_no_change
= 0;
2899 int fullscreen_is_being_set
= 0;
2901 struct gcpro gcpro1
, gcpro2
;
2904 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2907 parms
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2908 values
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2910 /* Extract parm names and values into those vectors. */
2913 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2918 parms
[i
] = Fcar (elt
);
2919 values
[i
] = Fcdr (elt
);
2922 /* TAIL and ALIST are not used again below here. */
2923 alist
= tail
= Qnil
;
2925 GCPRO2 (*parms
, *values
);
2929 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
2930 because their values appear in VALUES and strings are not valid. */
2931 top
= left
= Qunbound
;
2932 icon_left
= icon_top
= Qunbound
;
2934 /* Provide default values for HEIGHT and WIDTH. */
2935 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2936 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2938 /* Process foreground_color and background_color before anything else.
2939 They are independent of other properties, but other properties (e.g.,
2940 cursor_color) are dependent upon them. */
2941 /* Process default font as well, since fringe widths depends on it. */
2942 /* Also, process fullscreen, width and height depend upon that */
2943 for (p
= 0; p
< i
; p
++)
2945 Lisp_Object prop
, val
;
2949 if (EQ (prop
, Qforeground_color
)
2950 || EQ (prop
, Qbackground_color
)
2952 || EQ (prop
, Qfullscreen
))
2954 register Lisp_Object param_index
, old_value
;
2956 old_value
= get_frame_param (f
, prop
);
2957 fullscreen_is_being_set
|= EQ (prop
, Qfullscreen
);
2959 if (NILP (Fequal (val
, old_value
)))
2961 store_frame_param (f
, prop
, val
);
2963 param_index
= Fget (prop
, Qx_frame_parameter
);
2964 if (NATNUMP (param_index
)
2965 && (XFASTINT (param_index
)
2966 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
2967 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
2968 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
2973 /* Now process them in reverse of specified order. */
2974 for (i
--; i
>= 0; i
--)
2976 Lisp_Object prop
, val
;
2981 if (EQ (prop
, Qwidth
) && NUMBERP (val
))
2982 width
= XFASTINT (val
);
2983 else if (EQ (prop
, Qheight
) && NUMBERP (val
))
2984 height
= XFASTINT (val
);
2985 else if (EQ (prop
, Qtop
))
2987 else if (EQ (prop
, Qleft
))
2989 else if (EQ (prop
, Qicon_top
))
2991 else if (EQ (prop
, Qicon_left
))
2993 else if (EQ (prop
, Qforeground_color
)
2994 || EQ (prop
, Qbackground_color
)
2996 || EQ (prop
, Qfullscreen
))
2997 /* Processed above. */
3001 register Lisp_Object param_index
, old_value
;
3003 old_value
= get_frame_param (f
, prop
);
3005 store_frame_param (f
, prop
, val
);
3007 param_index
= Fget (prop
, Qx_frame_parameter
);
3008 if (NATNUMP (param_index
)
3009 && (XFASTINT (param_index
)
3010 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3011 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
3012 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
3016 /* Don't die if just one of these was set. */
3017 if (EQ (left
, Qunbound
))
3020 if (f
->left_pos
< 0)
3021 left
= Fcons (Qplus
, Fcons (make_number (f
->left_pos
), Qnil
));
3023 XSETINT (left
, f
->left_pos
);
3025 if (EQ (top
, Qunbound
))
3029 top
= Fcons (Qplus
, Fcons (make_number (f
->top_pos
), Qnil
));
3031 XSETINT (top
, f
->top_pos
);
3034 /* If one of the icon positions was not set, preserve or default it. */
3035 if (EQ (icon_left
, Qunbound
) || ! INTEGERP (icon_left
))
3037 icon_left_no_change
= 1;
3038 icon_left
= Fcdr (Fassq (Qicon_left
, f
->param_alist
));
3039 if (NILP (icon_left
))
3040 XSETINT (icon_left
, 0);
3042 if (EQ (icon_top
, Qunbound
) || ! INTEGERP (icon_top
))
3044 icon_top_no_change
= 1;
3045 icon_top
= Fcdr (Fassq (Qicon_top
, f
->param_alist
));
3046 if (NILP (icon_top
))
3047 XSETINT (icon_top
, 0);
3050 if (FRAME_VISIBLE_P (f
) && fullscreen_is_being_set
)
3052 /* If the frame is visible already and the fullscreen parameter is
3053 being set, it is too late to set WM manager hints to specify
3055 Here we first get the width, height and position that applies to
3056 fullscreen. We then move the frame to the appropriate
3057 position. Resize of the frame is taken care of in the code after
3058 this if-statement. */
3059 int new_left
, new_top
;
3061 x_fullscreen_adjust (f
, &width
, &height
, &new_top
, &new_left
);
3062 if (new_top
!= f
->top_pos
|| new_left
!= f
->left_pos
)
3063 x_set_offset (f
, new_left
, new_top
, 1);
3066 /* Don't set these parameters unless they've been explicitly
3067 specified. The window might be mapped or resized while we're in
3068 this function, and we don't want to override that unless the lisp
3069 code has asked for it.
3071 Don't set these parameters unless they actually differ from the
3072 window's current parameters; the window may not actually exist
3077 check_frame_size (f
, &height
, &width
);
3079 XSETFRAME (frame
, f
);
3081 if (width
!= FRAME_COLS (f
)
3082 || height
!= FRAME_LINES (f
)
3083 || f
->new_text_lines
|| f
->new_text_cols
)
3084 Fset_frame_size (frame
, make_number (width
), make_number (height
));
3086 if ((!NILP (left
) || !NILP (top
))
3087 && ! (left_no_change
&& top_no_change
)
3088 && ! (NUMBERP (left
) && XINT (left
) == f
->left_pos
3089 && NUMBERP (top
) && XINT (top
) == f
->top_pos
))
3094 /* Record the signs. */
3095 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3096 if (EQ (left
, Qminus
))
3097 f
->size_hint_flags
|= XNegative
;
3098 else if (INTEGERP (left
))
3100 leftpos
= XINT (left
);
3102 f
->size_hint_flags
|= XNegative
;
3104 else if (CONSP (left
) && EQ (XCAR (left
), Qminus
)
3105 && CONSP (XCDR (left
))
3106 && INTEGERP (XCAR (XCDR (left
))))
3108 leftpos
= - XINT (XCAR (XCDR (left
)));
3109 f
->size_hint_flags
|= XNegative
;
3111 else if (CONSP (left
) && EQ (XCAR (left
), Qplus
)
3112 && CONSP (XCDR (left
))
3113 && INTEGERP (XCAR (XCDR (left
))))
3115 leftpos
= XINT (XCAR (XCDR (left
)));
3118 if (EQ (top
, Qminus
))
3119 f
->size_hint_flags
|= YNegative
;
3120 else if (INTEGERP (top
))
3122 toppos
= XINT (top
);
3124 f
->size_hint_flags
|= YNegative
;
3126 else if (CONSP (top
) && EQ (XCAR (top
), Qminus
)
3127 && CONSP (XCDR (top
))
3128 && INTEGERP (XCAR (XCDR (top
))))
3130 toppos
= - XINT (XCAR (XCDR (top
)));
3131 f
->size_hint_flags
|= YNegative
;
3133 else if (CONSP (top
) && EQ (XCAR (top
), Qplus
)
3134 && CONSP (XCDR (top
))
3135 && INTEGERP (XCAR (XCDR (top
))))
3137 toppos
= XINT (XCAR (XCDR (top
)));
3141 /* Store the numeric value of the position. */
3142 f
->top_pos
= toppos
;
3143 f
->left_pos
= leftpos
;
3145 f
->win_gravity
= NorthWestGravity
;
3147 /* Actually set that position, and convert to absolute. */
3148 x_set_offset (f
, leftpos
, toppos
, -1);
3151 if ((!NILP (icon_left
) || !NILP (icon_top
))
3152 && ! (icon_left_no_change
&& icon_top_no_change
))
3153 x_wm_set_icon_position (f
, XINT (icon_left
), XINT (icon_top
));
3160 /* Insert a description of internally-recorded parameters of frame X
3161 into the parameter alist *ALISTPTR that is to be given to the user.
3162 Only parameters that are specific to the X window system
3163 and whose values are not correctly recorded in the frame's
3164 param_alist need to be considered here. */
3167 x_report_frame_params (f
, alistptr
)
3169 Lisp_Object
*alistptr
;
3174 /* Represent negative positions (off the top or left screen edge)
3175 in a way that Fmodify_frame_parameters will understand correctly. */
3176 XSETINT (tem
, f
->left_pos
);
3177 if (f
->left_pos
>= 0)
3178 store_in_alist (alistptr
, Qleft
, tem
);
3180 store_in_alist (alistptr
, Qleft
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3182 XSETINT (tem
, f
->top_pos
);
3183 if (f
->top_pos
>= 0)
3184 store_in_alist (alistptr
, Qtop
, tem
);
3186 store_in_alist (alistptr
, Qtop
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3188 store_in_alist (alistptr
, Qborder_width
,
3189 make_number (f
->border_width
));
3190 store_in_alist (alistptr
, Qinternal_border_width
,
3191 make_number (FRAME_INTERNAL_BORDER_WIDTH (f
)));
3192 store_in_alist (alistptr
, Qleft_fringe
,
3193 make_number (FRAME_LEFT_FRINGE_WIDTH (f
)));
3194 store_in_alist (alistptr
, Qright_fringe
,
3195 make_number (FRAME_RIGHT_FRINGE_WIDTH (f
)));
3196 store_in_alist (alistptr
, Qscroll_bar_width
,
3197 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3199 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
3200 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3201 /* nil means "use default width"
3202 for non-toolkit scroll bar.
3203 ruler-mode.el depends on this. */
3205 sprintf (buf
, "%ld", (long) FRAME_X_WINDOW (f
));
3206 store_in_alist (alistptr
, Qwindow_id
,
3207 build_string (buf
));
3208 #ifdef HAVE_X_WINDOWS
3209 #ifdef USE_X_TOOLKIT
3210 /* Tooltip frame may not have this widget. */
3211 if (FRAME_X_OUTPUT (f
)->widget
)
3213 sprintf (buf
, "%ld", (long) FRAME_OUTER_WINDOW (f
));
3214 store_in_alist (alistptr
, Qouter_window_id
,
3215 build_string (buf
));
3217 store_in_alist (alistptr
, Qicon_name
, f
->icon_name
);
3218 FRAME_SAMPLE_VISIBILITY (f
);
3219 store_in_alist (alistptr
, Qvisibility
,
3220 (FRAME_VISIBLE_P (f
) ? Qt
3221 : FRAME_ICONIFIED_P (f
) ? Qicon
: Qnil
));
3222 store_in_alist (alistptr
, Qdisplay
,
3223 XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
3225 if (FRAME_X_OUTPUT (f
)->parent_desc
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
3228 XSETFASTINT (tem
, FRAME_X_OUTPUT (f
)->parent_desc
);
3229 store_in_alist (alistptr
, Qparent_id
, tem
);
3233 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3234 the previous value of that parameter, NEW_VALUE is the new value. */
3237 x_set_fullscreen (f
, new_value
, old_value
)
3239 Lisp_Object new_value
, old_value
;
3241 if (NILP (new_value
))
3242 f
->want_fullscreen
= FULLSCREEN_NONE
;
3243 else if (EQ (new_value
, Qfullboth
))
3244 f
->want_fullscreen
= FULLSCREEN_BOTH
;
3245 else if (EQ (new_value
, Qfullwidth
))
3246 f
->want_fullscreen
= FULLSCREEN_WIDTH
;
3247 else if (EQ (new_value
, Qfullheight
))
3248 f
->want_fullscreen
= FULLSCREEN_HEIGHT
;
3252 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3253 the previous value of that parameter, NEW_VALUE is the new value. */
3256 x_set_line_spacing (f
, new_value
, old_value
)
3258 Lisp_Object new_value
, old_value
;
3260 if (NILP (new_value
))
3261 f
->extra_line_spacing
= 0;
3262 else if (NATNUMP (new_value
))
3263 f
->extra_line_spacing
= XFASTINT (new_value
);
3265 Fsignal (Qerror
, Fcons (build_string ("Invalid line-spacing"),
3266 Fcons (new_value
, Qnil
)));
3267 if (FRAME_VISIBLE_P (f
))
3272 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3273 the previous value of that parameter, NEW_VALUE is the new value. */
3276 x_set_screen_gamma (f
, new_value
, old_value
)
3278 Lisp_Object new_value
, old_value
;
3280 if (NILP (new_value
))
3282 else if (NUMBERP (new_value
) && XFLOATINT (new_value
) > 0)
3283 /* The value 0.4545 is the normal viewing gamma. */
3284 f
->gamma
= 1.0 / (0.4545 * XFLOATINT (new_value
));
3286 Fsignal (Qerror
, Fcons (build_string ("Invalid screen-gamma"),
3287 Fcons (new_value
, Qnil
)));
3289 clear_face_cache (0);
3294 x_set_font (f
, arg
, oldval
)
3296 Lisp_Object arg
, oldval
;
3299 Lisp_Object fontset_name
;
3301 int old_fontset
= FRAME_FONTSET(f
);
3305 fontset_name
= Fquery_fontset (arg
, Qnil
);
3308 result
= (STRINGP (fontset_name
)
3309 ? x_new_fontset (f
, SDATA (fontset_name
))
3310 : x_new_font (f
, SDATA (arg
)));
3313 if (EQ (result
, Qnil
))
3314 error ("Font `%s' is not defined", SDATA (arg
));
3315 else if (EQ (result
, Qt
))
3316 error ("The characters of the given font have varying widths");
3317 else if (STRINGP (result
))
3319 set_default_ascii_font (result
);
3320 if (STRINGP (fontset_name
))
3322 /* Fontset names are built from ASCII font names, so the
3323 names may be equal despite there was a change. */
3324 if (old_fontset
== FRAME_FONTSET (f
))
3327 else if (!NILP (Fequal (result
, oldval
)))
3330 store_frame_param (f
, Qfont
, result
);
3331 recompute_basic_faces (f
);
3336 do_pending_window_change (0);
3338 /* Don't call `face-set-after-frame-default' when faces haven't been
3339 initialized yet. This is the case when called from
3340 Fx_create_frame. In that case, the X widget or window doesn't
3341 exist either, and we can end up in x_report_frame_params with a
3342 null widget which gives a segfault. */
3343 if (FRAME_FACE_CACHE (f
))
3345 XSETFRAME (frame
, f
);
3346 call1 (Qface_set_after_frame_default
, frame
);
3352 x_set_fringe_width (f
, new_value
, old_value
)
3354 Lisp_Object new_value
, old_value
;
3356 compute_fringe_widths (f
, 1);
3360 x_set_border_width (f
, arg
, oldval
)
3362 Lisp_Object arg
, oldval
;
3366 if (XINT (arg
) == f
->border_width
)
3370 if (FRAME_X_WINDOW (f
) != 0)
3371 error ("Cannot change the border width of a window");
3372 #endif /* MAC_TODO */
3374 f
->border_width
= XINT (arg
);
3378 x_set_internal_border_width (f
, arg
, oldval
)
3380 Lisp_Object arg
, oldval
;
3382 int old
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3385 FRAME_INTERNAL_BORDER_WIDTH (f
) = XINT (arg
);
3386 if (FRAME_INTERNAL_BORDER_WIDTH (f
) < 0)
3387 FRAME_INTERNAL_BORDER_WIDTH (f
) = 0;
3389 #ifdef USE_X_TOOLKIT
3390 if (FRAME_X_OUTPUT (f
)->edit_widget
)
3391 widget_store_internal_border (FRAME_X_OUTPUT (f
)->edit_widget
);
3394 if (FRAME_INTERNAL_BORDER_WIDTH (f
) == old
)
3397 if (FRAME_X_WINDOW (f
) != 0)
3399 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3400 SET_FRAME_GARBAGED (f
);
3401 do_pending_window_change (0);
3404 SET_FRAME_GARBAGED (f
);
3408 x_set_visibility (f
, value
, oldval
)
3410 Lisp_Object value
, oldval
;
3413 XSETFRAME (frame
, f
);
3416 Fmake_frame_invisible (frame
, Qt
);
3417 else if (EQ (value
, Qicon
))
3418 Ficonify_frame (frame
);
3420 Fmake_frame_visible (frame
);
3424 x_set_autoraise (f
, arg
, oldval
)
3426 Lisp_Object arg
, oldval
;
3428 f
->auto_raise
= !EQ (Qnil
, arg
);
3432 x_set_autolower (f
, arg
, oldval
)
3434 Lisp_Object arg
, oldval
;
3436 f
->auto_lower
= !EQ (Qnil
, arg
);
3440 x_set_unsplittable (f
, arg
, oldval
)
3442 Lisp_Object arg
, oldval
;
3444 f
->no_split
= !NILP (arg
);
3448 x_set_vertical_scroll_bars (f
, arg
, oldval
)
3450 Lisp_Object arg
, oldval
;
3452 if ((EQ (arg
, Qleft
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3453 || (EQ (arg
, Qright
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
3454 || (NILP (arg
) && FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3455 || (!NILP (arg
) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)))
3457 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
)
3459 ? vertical_scroll_bar_none
3461 ? vertical_scroll_bar_left
3463 ? vertical_scroll_bar_right
3464 : EQ (Qleft
, Vdefault_frame_scroll_bars
)
3465 ? vertical_scroll_bar_left
3466 : EQ (Qright
, Vdefault_frame_scroll_bars
)
3467 ? vertical_scroll_bar_right
3468 : vertical_scroll_bar_none
);
3470 /* We set this parameter before creating the X window for the
3471 frame, so we can get the geometry right from the start.
3472 However, if the window hasn't been created yet, we shouldn't
3473 call x_set_window_size. */
3474 if (FRAME_X_WINDOW (f
))
3475 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3476 do_pending_window_change (0);
3481 x_set_scroll_bar_width (f
, arg
, oldval
)
3483 Lisp_Object arg
, oldval
;
3485 int wid
= FRAME_COLUMN_WIDTH (f
);
3489 x_set_scroll_bar_default_width (f
);
3491 if (FRAME_X_WINDOW (f
))
3492 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3493 do_pending_window_change (0);
3495 else if (INTEGERP (arg
) && XINT (arg
) > 0
3496 && XFASTINT (arg
) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3498 if (XFASTINT (arg
) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
3499 XSETINT (arg
, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
+ 1);
3501 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = XFASTINT (arg
);
3502 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (XFASTINT (arg
) + wid
-1) / wid
;
3503 if (FRAME_X_WINDOW (f
))
3504 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3505 do_pending_window_change (0);
3508 change_frame_size (f
, 0, FRAME_COLS (f
), 0, 0, 0);
3509 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.hpos
= 0;
3510 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.x
= 0;
3515 /* Return non-nil if frame F wants a bitmap icon. */
3523 tem
= assq_no_quit (Qicon_type
, f
->param_alist
);
3531 /* Subroutines of creating an X frame. */
3533 /* Make sure that Vx_resource_name is set to a reasonable value.
3534 Fix it up, or set it to `emacs' if it is too hopeless. */
3537 validate_x_resource_name ()
3540 /* Number of valid characters in the resource name. */
3542 /* Number of invalid characters in the resource name. */
3547 if (!STRINGP (Vx_resource_class
))
3548 Vx_resource_class
= build_string (EMACS_CLASS
);
3550 if (STRINGP (Vx_resource_name
))
3552 unsigned char *p
= SDATA (Vx_resource_name
);
3555 len
= SBYTES (Vx_resource_name
);
3557 /* Only letters, digits, - and _ are valid in resource names.
3558 Count the valid characters and count the invalid ones. */
3559 for (i
= 0; i
< len
; i
++)
3562 if (! ((c
>= 'a' && c
<= 'z')
3563 || (c
>= 'A' && c
<= 'Z')
3564 || (c
>= '0' && c
<= '9')
3565 || c
== '-' || c
== '_'))
3572 /* Not a string => completely invalid. */
3573 bad_count
= 5, good_count
= 0;
3575 /* If name is valid already, return. */
3579 /* If name is entirely invalid, or nearly so, use `emacs'. */
3581 || (good_count
== 1 && bad_count
> 0))
3583 Vx_resource_name
= build_string ("emacs");
3587 /* Name is partly valid. Copy it and replace the invalid characters
3588 with underscores. */
3590 Vx_resource_name
= new = Fcopy_sequence (Vx_resource_name
);
3592 for (i
= 0; i
< len
; i
++)
3594 int c
= SREF (new, i
);
3595 if (! ((c
>= 'a' && c
<= 'z')
3596 || (c
>= 'A' && c
<= 'Z')
3597 || (c
>= '0' && c
<= '9')
3598 || c
== '-' || c
== '_'))
3604 extern char *x_get_string_resource
P_ ((XrmDatabase
, char *, char *));
3605 extern Display_Info
*check_x_display_info
P_ ((Lisp_Object
));
3608 /* Get specified attribute from resource database RDB.
3609 See Fx_get_resource below for other parameters. */
3612 xrdb_get_resource (rdb
, attribute
, class, component
, subclass
)
3614 Lisp_Object attribute
, class, component
, subclass
;
3616 register char *value
;
3620 CHECK_STRING (attribute
);
3621 CHECK_STRING (class);
3623 if (!NILP (component
))
3624 CHECK_STRING (component
);
3625 if (!NILP (subclass
))
3626 CHECK_STRING (subclass
);
3627 if (NILP (component
) != NILP (subclass
))
3628 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3630 validate_x_resource_name ();
3632 /* Allocate space for the components, the dots which separate them,
3633 and the final '\0'. Make them big enough for the worst case. */
3634 name_key
= (char *) alloca (SBYTES (Vx_resource_name
)
3635 + (STRINGP (component
)
3636 ? SBYTES (component
) : 0)
3637 + SBYTES (attribute
)
3640 class_key
= (char *) alloca (SBYTES (Vx_resource_class
)
3642 + (STRINGP (subclass
)
3643 ? SBYTES (subclass
) : 0)
3646 /* Start with emacs.FRAMENAME for the name (the specific one)
3647 and with `Emacs' for the class key (the general one). */
3648 strcpy (name_key
, SDATA (Vx_resource_name
));
3649 strcpy (class_key
, SDATA (Vx_resource_class
));
3651 strcat (class_key
, ".");
3652 strcat (class_key
, SDATA (class));
3654 if (!NILP (component
))
3656 strcat (class_key
, ".");
3657 strcat (class_key
, SDATA (subclass
));
3659 strcat (name_key
, ".");
3660 strcat (name_key
, SDATA (component
));
3663 strcat (name_key
, ".");
3664 strcat (name_key
, SDATA (attribute
));
3666 value
= x_get_string_resource (rdb
, name_key
, class_key
);
3668 if (value
!= (char *) 0)
3669 return build_string (value
);
3675 DEFUN ("x-get-resource", Fx_get_resource
, Sx_get_resource
, 2, 4, 0,
3676 doc
: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
3677 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
3678 class, where INSTANCE is the name under which Emacs was invoked, or
3679 the name specified by the `-name' or `-rn' command-line arguments.
3681 The optional arguments COMPONENT and SUBCLASS add to the key and the
3682 class, respectively. You must specify both of them or neither.
3683 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
3684 and the class is `Emacs.CLASS.SUBCLASS'. */)
3685 (attribute
, class, component
, subclass
)
3686 Lisp_Object attribute
, class, component
, subclass
;
3688 #ifdef HAVE_X_WINDOWS
3692 return xrdb_get_resource (check_x_display_info (Qnil
)->xrdb
,
3693 attribute
, class, component
, subclass
);
3696 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
3699 display_x_get_resource (dpyinfo
, attribute
, class, component
, subclass
)
3700 Display_Info
*dpyinfo
;
3701 Lisp_Object attribute
, class, component
, subclass
;
3703 return xrdb_get_resource (dpyinfo
->xrdb
,
3704 attribute
, class, component
, subclass
);
3707 /* Used when C code wants a resource value. */
3710 x_get_resource_string (attribute
, class)
3711 char *attribute
, *class;
3715 struct frame
*sf
= SELECTED_FRAME ();
3717 /* Allocate space for the components, the dots which separate them,
3718 and the final '\0'. */
3719 name_key
= (char *) alloca (SBYTES (Vinvocation_name
)
3720 + strlen (attribute
) + 2);
3721 class_key
= (char *) alloca ((sizeof (EMACS_CLASS
) - 1)
3722 + strlen (class) + 2);
3724 sprintf (name_key
, "%s.%s", SDATA (Vinvocation_name
), attribute
);
3725 sprintf (class_key
, "%s.%s", EMACS_CLASS
, class);
3727 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf
)->xrdb
,
3728 name_key
, class_key
);
3732 /* Return the value of parameter PARAM.
3734 First search ALIST, then Vdefault_frame_alist, then the X defaults
3735 database, using ATTRIBUTE as the attribute name and CLASS as its class.
3737 Convert the resource to the type specified by desired_type.
3739 If no default is specified, return Qunbound. If you call
3740 x_get_arg, make sure you deal with Qunbound in a reasonable way,
3741 and don't let it get stored in any Lisp-visible variables! */
3744 x_get_arg (dpyinfo
, alist
, param
, attribute
, class, type
)
3745 Display_Info
*dpyinfo
;
3746 Lisp_Object alist
, param
;
3749 enum resource_types type
;
3751 register Lisp_Object tem
;
3753 tem
= Fassq (param
, alist
);
3755 tem
= Fassq (param
, Vdefault_frame_alist
);
3760 tem
= display_x_get_resource (dpyinfo
,
3761 build_string (attribute
),
3762 build_string (class),
3770 case RES_TYPE_NUMBER
:
3771 return make_number (atoi (SDATA (tem
)));
3773 case RES_TYPE_FLOAT
:
3774 return make_float (atof (SDATA (tem
)));
3776 case RES_TYPE_BOOLEAN
:
3777 tem
= Fdowncase (tem
);
3778 if (!strcmp (SDATA (tem
), "on")
3779 || !strcmp (SDATA (tem
), "true"))
3784 case RES_TYPE_STRING
:
3787 case RES_TYPE_SYMBOL
:
3788 /* As a special case, we map the values `true' and `on'
3789 to Qt, and `false' and `off' to Qnil. */
3792 lower
= Fdowncase (tem
);
3793 if (!strcmp (SDATA (lower
), "on")
3794 || !strcmp (SDATA (lower
), "true"))
3796 else if (!strcmp (SDATA (lower
), "off")
3797 || !strcmp (SDATA (lower
), "false"))
3800 return Fintern (tem
, Qnil
);
3814 x_frame_get_arg (f
, alist
, param
, attribute
, class, type
)
3816 Lisp_Object alist
, param
;
3819 enum resource_types type
;
3821 return x_get_arg (FRAME_X_DISPLAY_INFO (f
),
3822 alist
, param
, attribute
, class, type
);
3825 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
3828 x_frame_get_and_record_arg (f
, alist
, param
, attribute
, class, type
)
3830 Lisp_Object alist
, param
;
3833 enum resource_types type
;
3837 value
= x_get_arg (FRAME_X_DISPLAY_INFO (f
), alist
, param
,
3838 attribute
, class, type
);
3840 store_frame_param (f
, param
, value
);
3846 /* Record in frame F the specified or default value according to ALIST
3847 of the parameter named PROP (a Lisp symbol).
3848 If no value is specified for PROP, look for an X default for XPROP
3849 on the frame named NAME.
3850 If that is not found either, use the value DEFLT. */
3853 x_default_parameter (f
, alist
, prop
, deflt
, xprop
, xclass
, type
)
3860 enum resource_types type
;
3864 tem
= x_frame_get_arg (f
, alist
, prop
, xprop
, xclass
, type
);
3865 if (EQ (tem
, Qunbound
))
3867 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
3874 DEFUN ("x-parse-geometry", Fx_parse_geometry
, Sx_parse_geometry
, 1, 1, 0,
3875 doc
: /* Parse an X-style geometry string STRING.
3876 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
3877 The properties returned may include `top', `left', `height', and `width'.
3878 The value of `left' or `top' may be an integer,
3879 or a list (+ N) meaning N pixels relative to top/left corner,
3880 or a list (- N) meaning -N pixels relative to bottom/right corner. */)
3885 unsigned int width
, height
;
3888 CHECK_STRING (string
);
3890 geometry
= XParseGeometry ((char *) SDATA (string
),
3891 &x
, &y
, &width
, &height
);
3894 if (!!(geometry
& XValue
) != !!(geometry
& YValue
))
3895 error ("Must specify both x and y position, or neither");
3899 if (geometry
& XValue
)
3901 Lisp_Object element
;
3903 if (x
>= 0 && (geometry
& XNegative
))
3904 element
= Fcons (Qleft
, Fcons (Qminus
, Fcons (make_number (-x
), Qnil
)));
3905 else if (x
< 0 && ! (geometry
& XNegative
))
3906 element
= Fcons (Qleft
, Fcons (Qplus
, Fcons (make_number (x
), Qnil
)));
3908 element
= Fcons (Qleft
, make_number (x
));
3909 result
= Fcons (element
, result
);
3912 if (geometry
& YValue
)
3914 Lisp_Object element
;
3916 if (y
>= 0 && (geometry
& YNegative
))
3917 element
= Fcons (Qtop
, Fcons (Qminus
, Fcons (make_number (-y
), Qnil
)));
3918 else if (y
< 0 && ! (geometry
& YNegative
))
3919 element
= Fcons (Qtop
, Fcons (Qplus
, Fcons (make_number (y
), Qnil
)));
3921 element
= Fcons (Qtop
, make_number (y
));
3922 result
= Fcons (element
, result
);
3925 if (geometry
& WidthValue
)
3926 result
= Fcons (Fcons (Qwidth
, make_number (width
)), result
);
3927 if (geometry
& HeightValue
)
3928 result
= Fcons (Fcons (Qheight
, make_number (height
)), result
);
3933 /* Calculate the desired size and position of frame F.
3934 Return the flags saying which aspects were specified.
3936 Also set the win_gravity and size_hint_flags of F.
3938 Adjust height for toolbar if TOOLBAR_P is 1.
3940 This function does not make the coordinates positive. */
3942 #define DEFAULT_ROWS 40
3943 #define DEFAULT_COLS 80
3946 x_figure_window_size (f
, parms
, toolbar_p
)
3951 register Lisp_Object tem0
, tem1
, tem2
;
3952 long window_prompting
= 0;
3953 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3955 /* Default values if we fall through.
3956 Actually, if that happens we should get
3957 window manager prompting. */
3958 SET_FRAME_COLS (f
, DEFAULT_COLS
);
3959 FRAME_LINES (f
) = DEFAULT_ROWS
;
3960 /* Window managers expect that if program-specified
3961 positions are not (0,0), they're intentional, not defaults. */
3965 /* Ensure that old new_text_cols and new_text_lines will not override the
3967 /* ++KFS: This was specific to W32, but seems ok for all platforms */
3968 f
->new_text_cols
= f
->new_text_lines
= 0;
3970 tem0
= x_get_arg (dpyinfo
, parms
, Qheight
, 0, 0, RES_TYPE_NUMBER
);
3971 tem1
= x_get_arg (dpyinfo
, parms
, Qwidth
, 0, 0, RES_TYPE_NUMBER
);
3972 tem2
= x_get_arg (dpyinfo
, parms
, Quser_size
, 0, 0, RES_TYPE_NUMBER
);
3973 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
3975 if (!EQ (tem0
, Qunbound
))
3977 CHECK_NUMBER (tem0
);
3978 FRAME_LINES (f
) = XINT (tem0
);
3980 if (!EQ (tem1
, Qunbound
))
3982 CHECK_NUMBER (tem1
);
3983 SET_FRAME_COLS (f
, XINT (tem1
));
3985 if (!NILP (tem2
) && !EQ (tem2
, Qunbound
))
3986 window_prompting
|= USSize
;
3988 window_prompting
|= PSize
;
3991 f
->scroll_bar_actual_width
3992 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
3994 /* This used to be done _before_ calling x_figure_window_size, but
3995 since the height is reset here, this was really a no-op. I
3996 assume that moving it here does what Gerd intended (although he
3997 no longer can remember what that was... ++KFS, 2003-03-25. */
3999 /* Add the tool-bar height to the initial frame height so that the
4000 user gets a text display area of the size he specified with -g or
4001 via .Xdefaults. Later changes of the tool-bar height don't
4002 change the frame size. This is done so that users can create
4003 tall Emacs frames without having to guess how tall the tool-bar
4005 if (toolbar_p
&& FRAME_TOOL_BAR_LINES (f
))
4007 int margin
, relief
, bar_height
;
4009 relief
= (tool_bar_button_relief
>= 0
4010 ? tool_bar_button_relief
4011 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
4013 if (INTEGERP (Vtool_bar_button_margin
)
4014 && XINT (Vtool_bar_button_margin
) > 0)
4015 margin
= XFASTINT (Vtool_bar_button_margin
);
4016 else if (CONSP (Vtool_bar_button_margin
)
4017 && INTEGERP (XCDR (Vtool_bar_button_margin
))
4018 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4019 margin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4023 bar_height
= DEFAULT_TOOL_BAR_IMAGE_HEIGHT
+ 2 * margin
+ 2 * relief
;
4024 FRAME_LINES (f
) += (bar_height
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
4027 compute_fringe_widths (f
, 0);
4029 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, FRAME_COLS (f
));
4030 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4032 tem0
= x_get_arg (dpyinfo
, parms
, Qtop
, 0, 0, RES_TYPE_NUMBER
);
4033 tem1
= x_get_arg (dpyinfo
, parms
, Qleft
, 0, 0, RES_TYPE_NUMBER
);
4034 tem2
= x_get_arg (dpyinfo
, parms
, Quser_position
, 0, 0, RES_TYPE_NUMBER
);
4035 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4037 if (EQ (tem0
, Qminus
))
4040 window_prompting
|= YNegative
;
4042 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qminus
)
4043 && CONSP (XCDR (tem0
))
4044 && INTEGERP (XCAR (XCDR (tem0
))))
4046 f
->top_pos
= - XINT (XCAR (XCDR (tem0
)));
4047 window_prompting
|= YNegative
;
4049 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qplus
)
4050 && CONSP (XCDR (tem0
))
4051 && INTEGERP (XCAR (XCDR (tem0
))))
4053 f
->top_pos
= XINT (XCAR (XCDR (tem0
)));
4055 else if (EQ (tem0
, Qunbound
))
4059 CHECK_NUMBER (tem0
);
4060 f
->top_pos
= XINT (tem0
);
4062 window_prompting
|= YNegative
;
4065 if (EQ (tem1
, Qminus
))
4068 window_prompting
|= XNegative
;
4070 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qminus
)
4071 && CONSP (XCDR (tem1
))
4072 && INTEGERP (XCAR (XCDR (tem1
))))
4074 f
->left_pos
= - XINT (XCAR (XCDR (tem1
)));
4075 window_prompting
|= XNegative
;
4077 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qplus
)
4078 && CONSP (XCDR (tem1
))
4079 && INTEGERP (XCAR (XCDR (tem1
))))
4081 f
->left_pos
= XINT (XCAR (XCDR (tem1
)));
4083 else if (EQ (tem1
, Qunbound
))
4087 CHECK_NUMBER (tem1
);
4088 f
->left_pos
= XINT (tem1
);
4089 if (f
->left_pos
< 0)
4090 window_prompting
|= XNegative
;
4093 if (!NILP (tem2
) && ! EQ (tem2
, Qunbound
))
4094 window_prompting
|= USPosition
;
4096 window_prompting
|= PPosition
;
4099 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
4104 /* It takes both for some WM:s to place it where we want */
4105 window_prompting
= USPosition
| PPosition
;
4106 x_fullscreen_adjust (f
, &width
, &height
, &top
, &left
);
4107 FRAME_COLS (f
) = width
;
4108 FRAME_LINES (f
) = height
;
4109 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
4110 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
4115 if (window_prompting
& XNegative
)
4117 if (window_prompting
& YNegative
)
4118 f
->win_gravity
= SouthEastGravity
;
4120 f
->win_gravity
= NorthEastGravity
;
4124 if (window_prompting
& YNegative
)
4125 f
->win_gravity
= SouthWestGravity
;
4127 f
->win_gravity
= NorthWestGravity
;
4130 f
->size_hint_flags
= window_prompting
;
4132 return window_prompting
;
4137 #endif /* HAVE_WINDOW_SYSTEM */
4141 /***********************************************************************
4143 ***********************************************************************/
4148 Qframep
= intern ("framep");
4149 staticpro (&Qframep
);
4150 Qframe_live_p
= intern ("frame-live-p");
4151 staticpro (&Qframe_live_p
);
4152 Qheight
= intern ("height");
4153 staticpro (&Qheight
);
4154 Qicon
= intern ("icon");
4156 Qminibuffer
= intern ("minibuffer");
4157 staticpro (&Qminibuffer
);
4158 Qmodeline
= intern ("modeline");
4159 staticpro (&Qmodeline
);
4160 Qonly
= intern ("only");
4162 Qwidth
= intern ("width");
4163 staticpro (&Qwidth
);
4164 Qgeometry
= intern ("geometry");
4165 staticpro (&Qgeometry
);
4166 Qicon_left
= intern ("icon-left");
4167 staticpro (&Qicon_left
);
4168 Qicon_top
= intern ("icon-top");
4169 staticpro (&Qicon_top
);
4170 Qleft
= intern ("left");
4172 Qright
= intern ("right");
4173 staticpro (&Qright
);
4174 Quser_position
= intern ("user-position");
4175 staticpro (&Quser_position
);
4176 Quser_size
= intern ("user-size");
4177 staticpro (&Quser_size
);
4178 Qwindow_id
= intern ("window-id");
4179 staticpro (&Qwindow_id
);
4180 #ifdef HAVE_X_WINDOWS
4181 Qouter_window_id
= intern ("outer-window-id");
4182 staticpro (&Qouter_window_id
);
4184 Qparent_id
= intern ("parent-id");
4185 staticpro (&Qparent_id
);
4188 Qw32
= intern ("w32");
4190 Qpc
= intern ("pc");
4192 Qmac
= intern ("mac");
4194 Qvisible
= intern ("visible");
4195 staticpro (&Qvisible
);
4196 Qbuffer_predicate
= intern ("buffer-predicate");
4197 staticpro (&Qbuffer_predicate
);
4198 Qbuffer_list
= intern ("buffer-list");
4199 staticpro (&Qbuffer_list
);
4200 Qdisplay_type
= intern ("display-type");
4201 staticpro (&Qdisplay_type
);
4202 Qbackground_mode
= intern ("background-mode");
4203 staticpro (&Qbackground_mode
);
4204 Qtty_color_mode
= intern ("tty-color-mode");
4205 staticpro (&Qtty_color_mode
);
4206 Qtty
= intern ("tty");
4208 Qtty_type
= intern ("tty-type");
4209 staticpro (&Qtty_type
);
4210 Qwindow_system
= intern ("window-system");
4211 staticpro (&Qwindow_system
);
4213 Qface_set_after_frame_default
= intern ("face-set-after-frame-default");
4214 staticpro (&Qface_set_after_frame_default
);
4216 Qfullwidth
= intern ("fullwidth");
4217 staticpro (&Qfullwidth
);
4218 Qfullheight
= intern ("fullheight");
4219 staticpro (&Qfullheight
);
4220 Qfullboth
= intern ("fullboth");
4221 staticpro (&Qfullboth
);
4222 Qx_resource_name
= intern ("x-resource-name");
4223 staticpro (&Qx_resource_name
);
4225 Qx_frame_parameter
= intern ("x-frame-parameter");
4226 staticpro (&Qx_frame_parameter
);
4228 Qdisplay_id
= intern ("display-id");
4229 staticpro (&Qdisplay_id
);
4230 Qdisplay_live_p
= intern ("display-live-p");
4231 staticpro (&Qdisplay_live_p
);
4236 for (i
= 0; i
< sizeof (frame_parms
) / sizeof (frame_parms
[0]); i
++)
4238 Lisp_Object v
= intern (frame_parms
[i
].name
);
4239 if (frame_parms
[i
].variable
)
4241 *frame_parms
[i
].variable
= v
;
4242 staticpro (frame_parms
[i
].variable
);
4244 Fput (v
, Qx_frame_parameter
, make_number (i
));
4248 #ifdef HAVE_WINDOW_SYSTEM
4249 DEFVAR_LISP ("x-resource-name", &Vx_resource_name
,
4250 doc
: /* The name Emacs uses to look up X resources.
4251 `x-get-resource' uses this as the first component of the instance name
4252 when requesting resource values.
4253 Emacs initially sets `x-resource-name' to the name under which Emacs
4254 was invoked, or to the value specified with the `-name' or `-rn'
4255 switches, if present.
4257 It may be useful to bind this variable locally around a call
4258 to `x-get-resource'. See also the variable `x-resource-class'. */);
4259 Vx_resource_name
= Qnil
;
4261 DEFVAR_LISP ("x-resource-class", &Vx_resource_class
,
4262 doc
: /* The class Emacs uses to look up X resources.
4263 `x-get-resource' uses this as the first component of the instance class
4264 when requesting resource values.
4266 Emacs initially sets `x-resource-class' to "Emacs".
4268 Setting this variable permanently is not a reasonable thing to do,
4269 but binding this variable locally around a call to `x-get-resource'
4270 is a reasonable practice. See also the variable `x-resource-name'. */);
4271 Vx_resource_class
= build_string (EMACS_CLASS
);
4274 DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist
,
4275 doc
: /* Alist of default values for frame creation.
4276 These may be set in your init file, like this:
4277 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
4278 These override values given in window system configuration data,
4279 including X Windows' defaults database.
4280 For values specific to the first Emacs frame, see `initial-frame-alist'.
4281 For values specific to the separate minibuffer frame, see
4282 `minibuffer-frame-alist'.
4283 The `menu-bar-lines' element of the list controls whether new frames
4284 have menu bars; `menu-bar-mode' works by altering this element.
4285 Setting this variable does not affect existing frames, only new ones. */);
4286 Vdefault_frame_alist
= Qnil
;
4288 DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars
,
4289 doc
: /* Default position of scroll bars on this window-system. */);
4290 #ifdef HAVE_WINDOW_SYSTEM
4291 #if defined(HAVE_NTGUI) || defined(MAC_OS)
4292 /* MS-Windows has scroll bars on the right by default. */
4293 Vdefault_frame_scroll_bars
= Qright
;
4295 Vdefault_frame_scroll_bars
= Qleft
;
4298 Vdefault_frame_scroll_bars
= Qnil
;
4301 Qinhibit_default_face_x_resources
4302 = intern ("inhibit-default-face-x-resources");
4303 staticpro (&Qinhibit_default_face_x_resources
);
4305 DEFVAR_LISP ("terminal-frame", &Vterminal_frame
,
4306 doc
: /* The initial frame-object, which represents Emacs's stdout. */);
4308 DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified
,
4309 doc
: /* Non-nil if all of emacs is iconified and frame updates are not needed. */);
4310 Vemacs_iconified
= Qnil
;
4312 DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function
,
4313 doc
: /* If non-nil, function to transform normal value of `mouse-position'.
4314 `mouse-position' calls this function, passing its usual return value as
4315 argument, and returns whatever this function returns.
4316 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
4317 which need to do mouse handling at the Lisp level. */);
4318 Vmouse_position_function
= Qnil
;
4320 DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight
,
4321 doc
: /* If non-nil, clickable text is highlighted when mouse is over it.
4322 If the value is an integer, highlighting is only shown after moving the
4323 mouse, while keyboard input turns off the highlight even when the mouse
4324 is over the clickable text. However, the mouse shape still indicates
4325 when the mouse is over clickable text. */);
4326 Vmouse_highlight
= Qt
;
4328 DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions
,
4329 doc
: /* Functions to be run before deleting a frame.
4330 The functions are run with one arg, the frame to be deleted.
4331 See `delete-frame'. */);
4332 Vdelete_frame_functions
= Qnil
;
4334 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame
,
4335 doc
: /* Minibufferless frames use this frame's minibuffer.
4337 Emacs cannot create minibufferless frames unless this is set to an
4338 appropriate surrogate.
4340 Emacs consults this variable only when creating minibufferless
4341 frames; once the frame is created, it sticks with its assigned
4342 minibuffer, no matter what this variable is set to. This means that
4343 this variable doesn't necessarily say anything meaningful about the
4344 current set of frames, or where the minibuffer is currently being
4347 This variable is local to the current terminal and cannot be buffer-local. */);
4349 staticpro (&Vframe_list
);
4351 defsubr (&Sactive_minibuffer_window
);
4353 defsubr (&Sframe_live_p
);
4354 defsubr (&Swindow_system
);
4355 defsubr (&Smake_terminal_frame
);
4356 defsubr (&Shandle_switch_frame
);
4357 defsubr (&Sselect_frame
);
4358 defsubr (&Sselected_frame
);
4359 defsubr (&Swindow_frame
);
4360 defsubr (&Sframe_root_window
);
4361 defsubr (&Sframe_first_window
);
4362 defsubr (&Sframe_selected_window
);
4363 defsubr (&Sset_frame_selected_window
);
4364 defsubr (&Sframe_display
);
4365 defsubr (&Sframe_list
);
4366 defsubr (&Snext_frame
);
4367 defsubr (&Sprevious_frame
);
4368 defsubr (&Sdelete_frame
);
4369 defsubr (&Smouse_position
);
4370 defsubr (&Smouse_pixel_position
);
4371 defsubr (&Sset_mouse_position
);
4372 defsubr (&Sset_mouse_pixel_position
);
4374 defsubr (&Sframe_configuration
);
4375 defsubr (&Srestore_frame_configuration
);
4377 defsubr (&Smake_frame_visible
);
4378 defsubr (&Smake_frame_invisible
);
4379 defsubr (&Siconify_frame
);
4380 defsubr (&Sframe_visible_p
);
4381 defsubr (&Svisible_frame_list
);
4382 defsubr (&Sraise_frame
);
4383 defsubr (&Slower_frame
);
4384 defsubr (&Sredirect_frame_focus
);
4385 defsubr (&Sframe_focus
);
4386 defsubr (&Sframe_parameters
);
4387 defsubr (&Sframe_parameter
);
4388 defsubr (&Smodify_frame_parameters
);
4389 defsubr (&Sframe_char_height
);
4390 defsubr (&Sframe_char_width
);
4391 defsubr (&Sframe_pixel_height
);
4392 defsubr (&Sframe_pixel_width
);
4393 defsubr (&Sset_frame_height
);
4394 defsubr (&Sset_frame_width
);
4395 defsubr (&Sset_frame_size
);
4396 defsubr (&Sset_frame_position
);
4398 #ifdef HAVE_WINDOW_SYSTEM
4399 defsubr (&Sx_get_resource
);
4400 defsubr (&Sx_parse_geometry
);
4405 /* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
4406 (do not change this comment) */