1 /* Generic frame functions.
2 Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2003, 2004
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 ("ignore-event", Fignore_event
, Signore_event
, 0, 0, "",
947 doc
: /* Do nothing, but preserve any prefix argument already specified.
948 This is a suitable binding for `iconify-frame' and `make-frame-visible'. */)
951 current_kboard
->Vprefix_arg
= Vcurrent_prefix_arg
;
955 DEFUN ("selected-frame", Fselected_frame
, Sselected_frame
, 0, 0, 0,
956 doc
: /* Return the frame that is now selected. */)
959 return selected_frame
;
962 DEFUN ("window-frame", Fwindow_frame
, Swindow_frame
, 1, 1, 0,
963 doc
: /* Return the frame object that window WINDOW is on. */)
967 CHECK_LIVE_WINDOW (window
);
968 return XWINDOW (window
)->frame
;
971 DEFUN ("frame-first-window", Fframe_first_window
, Sframe_first_window
, 0, 1, 0,
972 doc
: /* Returns the topmost, leftmost window of FRAME.
973 If omitted, FRAME defaults to the currently selected frame. */)
980 w
= SELECTED_FRAME ()->root_window
;
983 CHECK_LIVE_FRAME (frame
);
984 w
= XFRAME (frame
)->root_window
;
986 while (NILP (XWINDOW (w
)->buffer
))
988 if (! NILP (XWINDOW (w
)->hchild
))
989 w
= XWINDOW (w
)->hchild
;
990 else if (! NILP (XWINDOW (w
)->vchild
))
991 w
= XWINDOW (w
)->vchild
;
998 DEFUN ("active-minibuffer-window", Factive_minibuffer_window
,
999 Sactive_minibuffer_window
, 0, 0, 0,
1000 doc
: /* Return the currently active minibuffer window, or nil if none. */)
1003 return minibuf_level
? minibuf_window
: Qnil
;
1006 DEFUN ("frame-root-window", Fframe_root_window
, Sframe_root_window
, 0, 1, 0,
1007 doc
: /* Returns the root-window of FRAME.
1008 If omitted, FRAME defaults to the currently selected frame. */)
1015 window
= SELECTED_FRAME ()->root_window
;
1018 CHECK_LIVE_FRAME (frame
);
1019 window
= XFRAME (frame
)->root_window
;
1025 DEFUN ("frame-selected-window", Fframe_selected_window
,
1026 Sframe_selected_window
, 0, 1, 0,
1027 doc
: /* Return the selected window of frame object FRAME.
1028 If omitted, FRAME defaults to the currently selected frame. */)
1035 window
= SELECTED_FRAME ()->selected_window
;
1038 CHECK_LIVE_FRAME (frame
);
1039 window
= XFRAME (frame
)->selected_window
;
1045 DEFUN ("set-frame-selected-window", Fset_frame_selected_window
,
1046 Sset_frame_selected_window
, 2, 2, 0,
1047 doc
: /* Set the selected window of frame object FRAME to WINDOW.
1049 If FRAME is nil, the selected frame is used.
1050 If FRAME is the selected frame, this makes WINDOW the selected window. */)
1052 Lisp_Object frame
, window
;
1055 frame
= selected_frame
;
1057 CHECK_LIVE_FRAME (frame
);
1058 CHECK_LIVE_WINDOW (window
);
1060 if (! EQ (frame
, WINDOW_FRAME (XWINDOW (window
))))
1061 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1063 if (EQ (frame
, selected_frame
))
1064 return Fselect_window (window
, Qnil
);
1066 return XFRAME (frame
)->selected_window
= window
;
1070 DEFUN ("frame-display", Fframe_display
, Sframe_display
, 0, 1, 0,
1071 doc
: /* Return the display device that FRAME is displayed on.
1072 If FRAME is nil, the selected frame is used.
1074 The display device is represented by its integer identifier. */)
1081 frame
= selected_frame
;
1083 CHECK_LIVE_FRAME (frame
);
1085 d
= get_display (frame
);
1090 return make_number (d
->id
);
1094 DEFUN ("frame-list", Fframe_list
, Sframe_list
,
1096 doc
: /* Return a list of all frames. */)
1100 frames
= Fcopy_sequence (Vframe_list
);
1101 #ifdef HAVE_WINDOW_SYSTEM
1102 if (FRAMEP (tip_frame
))
1103 frames
= Fdelq (tip_frame
, frames
);
1108 /* Return the next frame in the frame list after FRAME.
1109 If MINIBUF is nil, exclude minibuffer-only frames.
1110 If MINIBUF is a window, include only its own frame
1111 and any frame now using that window as the minibuffer.
1112 If MINIBUF is `visible', include all visible frames.
1113 If MINIBUF is 0, include all visible and iconified frames.
1114 Otherwise, include all frames. */
1117 next_frame (frame
, minibuf
)
1119 Lisp_Object minibuf
;
1124 /* There must always be at least one frame in Vframe_list. */
1125 if (! CONSP (Vframe_list
))
1128 /* If this frame is dead, it won't be in Vframe_list, and we'll loop
1129 forever. Forestall that. */
1130 CHECK_LIVE_FRAME (frame
);
1133 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1140 && ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1141 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1142 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1143 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
)))))
1145 /* Decide whether this frame is eligible to be returned. */
1147 /* If we've looped all the way around without finding any
1148 eligible frames, return the original frame. */
1152 /* Let minibuf decide if this frame is acceptable. */
1155 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1158 else if (EQ (minibuf
, Qvisible
))
1160 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1161 if (FRAME_VISIBLE_P (XFRAME (f
)))
1164 else if (INTEGERP (minibuf
) && XINT (minibuf
) == 0)
1166 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1167 if (FRAME_VISIBLE_P (XFRAME (f
))
1168 || FRAME_ICONIFIED_P (XFRAME (f
)))
1171 else if (WINDOWP (minibuf
))
1173 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1174 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1175 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1176 FRAME_FOCUS_FRAME (XFRAME (f
))))
1188 /* Return the previous frame in the frame list before FRAME.
1189 If MINIBUF is nil, exclude minibuffer-only frames.
1190 If MINIBUF is a window, include only its own frame
1191 and any frame now using that window as the minibuffer.
1192 If MINIBUF is `visible', include all visible frames.
1193 If MINIBUF is 0, include all visible and iconified frames.
1194 Otherwise, include all frames. */
1197 prev_frame (frame
, minibuf
)
1199 Lisp_Object minibuf
;
1204 /* There must always be at least one frame in Vframe_list. */
1205 if (! CONSP (Vframe_list
))
1209 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1217 if (EQ (frame
, f
) && !NILP (prev
))
1220 if ((!FRAME_TERMCAP_P (XFRAME (f
)) && !FRAME_TERMCAP_P (XFRAME (frame
))
1221 && FRAME_KBOARD (XFRAME (f
)) == FRAME_KBOARD (XFRAME (frame
)))
1222 || (FRAME_TERMCAP_P (XFRAME (f
)) && FRAME_TERMCAP_P (XFRAME (frame
))
1223 && FRAME_TTY (XFRAME (f
)) == FRAME_TTY (XFRAME (frame
))))
1225 /* Decide whether this frame is eligible to be returned,
1226 according to minibuf. */
1229 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f
)))
1232 else if (WINDOWP (minibuf
))
1234 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f
)), minibuf
)
1235 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)), f
)
1236 || EQ (WINDOW_FRAME (XWINDOW (minibuf
)),
1237 FRAME_FOCUS_FRAME (XFRAME (f
))))
1240 else if (EQ (minibuf
, Qvisible
))
1242 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1243 if (FRAME_VISIBLE_P (XFRAME (f
)))
1246 else if (XFASTINT (minibuf
) == 0)
1248 FRAME_SAMPLE_VISIBILITY (XFRAME (f
));
1249 if (FRAME_VISIBLE_P (XFRAME (f
))
1250 || FRAME_ICONIFIED_P (XFRAME (f
)))
1258 /* We've scanned the entire list. */
1260 /* We went through the whole frame list without finding a single
1261 acceptable frame. Return the original frame. */
1264 /* There were no acceptable frames in the list before FRAME; otherwise,
1265 we would have returned directly from the loop. Since PREV is the last
1266 acceptable frame in the list, return it. */
1271 DEFUN ("next-frame", Fnext_frame
, Snext_frame
, 0, 2, 0,
1272 doc
: /* Return the next frame in the frame list after FRAME.
1273 It considers only frames on the same terminal as FRAME.
1274 By default, skip minibuffer-only frames.
1275 If omitted, FRAME defaults to the selected frame.
1276 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1277 If MINIFRAME is a window, include only its own frame
1278 and any frame now using that window as the minibuffer.
1279 If MINIFRAME is `visible', include all visible frames.
1280 If MINIFRAME is 0, include all visible and iconified frames.
1281 Otherwise, include all frames. */)
1283 Lisp_Object frame
, miniframe
;
1286 frame
= selected_frame
;
1288 CHECK_LIVE_FRAME (frame
);
1289 return next_frame (frame
, miniframe
);
1292 DEFUN ("previous-frame", Fprevious_frame
, Sprevious_frame
, 0, 2, 0,
1293 doc
: /* Return the previous frame in the frame list before FRAME.
1294 It considers only frames on the same terminal as FRAME.
1295 By default, skip minibuffer-only frames.
1296 If omitted, FRAME defaults to the selected frame.
1297 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1298 If MINIFRAME is a window, include only its own frame
1299 and any frame now using that window as the minibuffer.
1300 If MINIFRAME is `visible', include all visible frames.
1301 If MINIFRAME is 0, include all visible and iconified frames.
1302 Otherwise, include all frames. */)
1304 Lisp_Object frame
, miniframe
;
1307 frame
= selected_frame
;
1308 CHECK_LIVE_FRAME (frame
);
1309 return prev_frame (frame
, miniframe
);
1312 /* Return 1 if it is ok to delete frame F;
1313 0 if all frames aside from F are invisible.
1314 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1317 other_visible_frames (f
)
1320 /* We know the selected frame is visible,
1321 so if F is some other frame, it can't be the sole visible one. */
1322 if (f
== SELECTED_FRAME ())
1327 for (frames
= Vframe_list
;
1329 frames
= XCDR (frames
))
1333 this = XCAR (frames
);
1334 /* Verify that the frame's window still exists
1335 and we can still talk to it. And note any recent change
1337 #ifdef HAVE_WINDOW_SYSTEM
1338 if (FRAME_WINDOW_P (XFRAME (this)))
1340 x_sync (XFRAME (this));
1341 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1345 if (FRAME_VISIBLE_P (XFRAME (this))
1346 || FRAME_ICONIFIED_P (XFRAME (this))
1347 /* Allow deleting the terminal frame when at least
1348 one X frame exists! */
1349 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f
)))
1357 DEFUN ("delete-frame", Fdelete_frame
, Sdelete_frame
, 0, 2, "",
1358 doc
: /* Delete FRAME, permanently eliminating it from use.
1359 If omitted, FRAME defaults to the selected frame.
1360 A frame may not be deleted if its minibuffer is used by other frames.
1361 Normally, you may not delete a frame if all other frames are invisible,
1362 but if the second optional argument FORCE is non-nil, you may do so.
1364 This function runs `delete-frame-functions' before actually deleting the
1365 frame, unless the frame is a tooltip.
1366 The functions are run with one arg, the frame to be deleted. */)
1368 Lisp_Object frame
, force
;
1371 struct frame
*sf
= SELECTED_FRAME ();
1372 int minibuffer_selected
;
1374 if (EQ (frame
, Qnil
))
1377 XSETFRAME (frame
, f
);
1381 CHECK_FRAME (frame
);
1385 if (! FRAME_LIVE_P (f
))
1388 if (NILP (force
) && !other_visible_frames (f
)
1390 /* Terminal frame deleted before any other visible frames are
1392 && strcmp (SDATA (f
->name
), "F1") != 0
1395 error ("Attempt to delete the sole visible or iconified frame");
1398 /* This is a nice idea, but x_connection_closed needs to be able
1399 to delete the last frame, if it is gone. */
1400 if (NILP (XCDR (Vframe_list
)))
1401 error ("Attempt to delete the only frame");
1404 /* Does this frame have a minibuffer, and is it the surrogate
1405 minibuffer for any other frame? */
1406 if (FRAME_HAS_MINIBUF_P (XFRAME (frame
)))
1410 for (frames
= Vframe_list
;
1412 frames
= XCDR (frames
))
1415 this = XCAR (frames
);
1417 if (! EQ (this, frame
)
1419 WINDOW_FRAME (XWINDOW
1420 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1421 error ("Attempt to delete a surrogate minibuffer frame");
1425 /* Run `delete-frame-functions' unless frame is a tooltip. */
1426 if (!NILP (Vrun_hooks
)
1427 && NILP (Fframe_parameter (frame
, intern ("tooltip"))))
1429 Lisp_Object args
[2];
1430 args
[0] = intern ("delete-frame-functions");
1432 Frun_hook_with_args (2, args
);
1435 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1436 if (! FRAME_LIVE_P (f
))
1439 minibuffer_selected
= EQ (minibuf_window
, selected_window
);
1441 /* Don't let the frame remain selected. */
1444 Lisp_Object tail
, frame1
;
1446 /* Look for another visible frame on the same terminal. */
1447 frame1
= next_frame (frame
, Qvisible
);
1449 /* If there is none, find *some* other frame. */
1450 if (NILP (frame1
) || EQ (frame1
, frame
))
1452 FOR_EACH_FRAME (tail
, frame1
)
1454 if (! EQ (frame
, frame1
) && FRAME_LIVE_P (XFRAME (frame1
)))
1459 do_switch_frame (frame1
, 0, 1);
1460 sf
= SELECTED_FRAME ();
1463 /* Don't allow minibuf_window to remain on a deleted frame. */
1464 if (EQ (f
->minibuffer_window
, minibuf_window
))
1466 Fset_window_buffer (sf
->minibuffer_window
,
1467 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1468 minibuf_window
= sf
->minibuffer_window
;
1470 /* If the dying minibuffer window was selected,
1471 select the new one. */
1472 if (minibuffer_selected
)
1473 Fselect_window (minibuf_window
, Qnil
);
1476 /* Don't let echo_area_window to remain on a deleted frame. */
1477 if (EQ (f
->minibuffer_window
, echo_area_window
))
1478 echo_area_window
= sf
->minibuffer_window
;
1480 /* Clear any X selections for this frame. */
1481 #ifdef HAVE_X_WINDOWS
1483 x_clear_frame_selections (f
);
1487 This function must be called before the window tree of the
1488 frame is deleted because windows contain dynamically allocated
1492 /* Mark all the windows that used to be on FRAME as deleted, and then
1493 remove the reference to them. */
1494 delete_all_subwindows (XWINDOW (f
->root_window
));
1495 f
->root_window
= Qnil
;
1497 Vframe_list
= Fdelq (frame
, Vframe_list
);
1498 FRAME_SET_VISIBLE (f
, 0);
1502 if (f
->decode_mode_spec_buffer
)
1503 xfree (f
->decode_mode_spec_buffer
);
1504 if (FRAME_INSERT_COST (f
))
1505 xfree (FRAME_INSERT_COST (f
));
1506 if (FRAME_DELETEN_COST (f
))
1507 xfree (FRAME_DELETEN_COST (f
));
1508 if (FRAME_INSERTN_COST (f
))
1509 xfree (FRAME_INSERTN_COST (f
));
1510 if (FRAME_DELETE_COST (f
))
1511 xfree (FRAME_DELETE_COST (f
));
1512 if (FRAME_MESSAGE_BUF (f
))
1513 xfree (FRAME_MESSAGE_BUF (f
));
1515 /* Since some events are handled at the interrupt level, we may get
1516 an event for f at any time; if we zero out the frame's display
1517 now, then we may trip up the event-handling code. Instead, we'll
1518 promise that the display of the frame must be valid until we have
1519 called the window-system-dependent frame destruction routine. */
1521 if (FRAME_DISPLAY (f
)->delete_frame_hook
)
1522 (*FRAME_DISPLAY (f
)->delete_frame_hook
) (f
);
1525 struct display
*display
= FRAME_DISPLAY (f
);
1527 f
->output_data
.nothing
= 0;
1528 f
->display
= 0; /* Now the frame is dead. */
1530 /* If needed, delete the device that this frame was on.
1531 (This must be done after the frame is killed.) */
1532 display
->reference_count
--;
1533 if (display
->reference_count
== 0)
1535 if (display
->delete_display_hook
)
1536 (*display
->delete_display_hook
) (display
);
1538 delete_display (display
);
1542 /* If we've deleted the last_nonminibuf_frame, then try to find
1544 if (f
== last_nonminibuf_frame
)
1548 last_nonminibuf_frame
= 0;
1550 for (frames
= Vframe_list
;
1552 frames
= XCDR (frames
))
1554 f
= XFRAME (XCAR (frames
));
1555 if (!FRAME_MINIBUF_ONLY_P (f
))
1557 last_nonminibuf_frame
= f
;
1563 /* If there's no other frame on the same kboard, get out of
1564 single-kboard state if we're in it for this kboard. */
1567 /* Some frame we found on the same kboard, or nil if there are none. */
1568 Lisp_Object frame_on_same_kboard
;
1570 frame_on_same_kboard
= Qnil
;
1572 for (frames
= Vframe_list
;
1574 frames
= XCDR (frames
))
1579 this = XCAR (frames
);
1584 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
))
1585 frame_on_same_kboard
= this;
1588 if (NILP (frame_on_same_kboard
))
1589 not_single_kboard_state (FRAME_KBOARD (f
));
1593 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1594 find another one. Prefer minibuffer-only frames, but also notice
1595 frames with other windows. */
1596 if (EQ (frame
, FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
))
1600 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1601 Lisp_Object frame_with_minibuf
;
1602 /* Some frame we found on the same kboard, or nil if there are none. */
1603 Lisp_Object frame_on_same_kboard
;
1605 frame_on_same_kboard
= Qnil
;
1606 frame_with_minibuf
= Qnil
;
1608 for (frames
= Vframe_list
;
1610 frames
= XCDR (frames
))
1615 this = XCAR (frames
);
1620 /* Consider only frames on the same kboard
1621 and only those with minibuffers. */
1622 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
)
1623 && FRAME_HAS_MINIBUF_P (f1
))
1625 frame_with_minibuf
= this;
1626 if (FRAME_MINIBUF_ONLY_P (f1
))
1630 if (FRAME_KBOARD (f
) == FRAME_KBOARD (f1
))
1631 frame_on_same_kboard
= this;
1634 if (!NILP (frame_on_same_kboard
))
1636 /* We know that there must be some frame with a minibuffer out
1637 there. If this were not true, all of the frames present
1638 would have to be minibufferless, which implies that at some
1639 point their minibuffer frames must have been deleted, but
1640 that is prohibited at the top; you can't delete surrogate
1641 minibuffer frames. */
1642 if (NILP (frame_with_minibuf
))
1645 FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
= frame_with_minibuf
;
1648 /* No frames left on this kboard--say no minibuffer either. */
1649 FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
= Qnil
;
1652 /* Cause frame titles to update--necessary if we now have just one frame. */
1653 update_mode_lines
= 1;
1658 /* Return mouse position in character cell units. */
1660 DEFUN ("mouse-position", Fmouse_position
, Smouse_position
, 0, 0, 0,
1661 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1662 The position is given in character cells, where (0, 0) is the
1664 If Emacs is running on a mouseless terminal or hasn't been programmed
1665 to read the mouse position, it returns the selected frame for FRAME
1666 and nil for X and Y.
1667 If `mouse-position-function' is non-nil, `mouse-position' calls it,
1668 passing the normal return value to that function as an argument,
1669 and returns whatever that function returns. */)
1673 Lisp_Object lispy_dummy
;
1674 enum scroll_bar_part party_dummy
;
1675 Lisp_Object x
, y
, retval
;
1677 unsigned long long_dummy
;
1678 struct gcpro gcpro1
;
1680 f
= SELECTED_FRAME ();
1684 /* It's okay for the hook to refrain from storing anything. */
1685 if (FRAME_DISPLAY (f
)->mouse_position_hook
)
1686 (*FRAME_DISPLAY (f
)->mouse_position_hook
) (&f
, -1,
1687 &lispy_dummy
, &party_dummy
,
1694 pixel_to_glyph_coords (f
, col
, row
, &col
, &row
, NULL
, 1);
1699 XSETFRAME (lispy_dummy
, f
);
1700 retval
= Fcons (lispy_dummy
, Fcons (x
, y
));
1702 if (!NILP (Vmouse_position_function
))
1703 retval
= call1 (Vmouse_position_function
, retval
);
1704 RETURN_UNGCPRO (retval
);
1707 DEFUN ("mouse-pixel-position", Fmouse_pixel_position
,
1708 Smouse_pixel_position
, 0, 0, 0,
1709 doc
: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1710 The position is given in pixel units, where (0, 0) is the
1712 If Emacs is running on a mouseless terminal or hasn't been programmed
1713 to read the mouse position, it returns the selected frame for FRAME
1714 and nil for X and Y. */)
1718 Lisp_Object lispy_dummy
;
1719 enum scroll_bar_part party_dummy
;
1721 unsigned long long_dummy
;
1723 f
= SELECTED_FRAME ();
1727 /* It's okay for the hook to refrain from storing anything. */
1728 if (FRAME_DISPLAY (f
)->mouse_position_hook
)
1729 (*FRAME_DISPLAY (f
)->mouse_position_hook
) (&f
, -1,
1730 &lispy_dummy
, &party_dummy
,
1734 XSETFRAME (lispy_dummy
, f
);
1735 return Fcons (lispy_dummy
, Fcons (x
, y
));
1738 DEFUN ("set-mouse-position", Fset_mouse_position
, Sset_mouse_position
, 3, 3, 0,
1739 doc
: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1740 Coordinates are relative to the frame, not a window,
1741 so the coordinates of the top left character in the frame
1742 may be nonzero due to left-hand scroll bars or the menu bar.
1744 This function is a no-op for an X frame that is not visible.
1745 If you have just created a frame, you must wait for it to become visible
1746 before calling this function on it, like this.
1747 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1749 Lisp_Object frame
, x
, y
;
1751 CHECK_LIVE_FRAME (frame
);
1755 /* I think this should be done with a hook. */
1756 #ifdef HAVE_WINDOW_SYSTEM
1757 if (FRAME_WINDOW_P (XFRAME (frame
)))
1758 /* Warping the mouse will cause enternotify and focus events. */
1759 x_set_mouse_position (XFRAME (frame
), XINT (x
), XINT (y
));
1761 #if defined (MSDOS) && defined (HAVE_MOUSE)
1762 if (FRAME_MSDOS_P (XFRAME (frame
)))
1764 Fselect_frame (frame
, Qnil
);
1765 mouse_moveto (XINT (x
), XINT (y
));
1773 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position
,
1774 Sset_mouse_pixel_position
, 3, 3, 0,
1775 doc
: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
1776 Note, this is a no-op for an X frame that is not visible.
1777 If you have just created a frame, you must wait for it to become visible
1778 before calling this function on it, like this.
1779 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1781 Lisp_Object frame
, x
, y
;
1783 CHECK_LIVE_FRAME (frame
);
1787 /* I think this should be done with a hook. */
1788 #ifdef HAVE_WINDOW_SYSTEM
1789 if (FRAME_WINDOW_P (XFRAME (frame
)))
1790 /* Warping the mouse will cause enternotify and focus events. */
1791 x_set_mouse_pixel_position (XFRAME (frame
), XINT (x
), XINT (y
));
1793 #if defined (MSDOS) && defined (HAVE_MOUSE)
1794 if (FRAME_MSDOS_P (XFRAME (frame
)))
1796 Fselect_frame (frame
, Qnil
);
1797 mouse_moveto (XINT (x
), XINT (y
));
1805 static void make_frame_visible_1
P_ ((Lisp_Object
));
1807 DEFUN ("make-frame-visible", Fmake_frame_visible
, Smake_frame_visible
,
1809 doc
: /* Make the frame FRAME visible (assuming it is an X window).
1810 If omitted, FRAME defaults to the currently selected frame. */)
1815 frame
= selected_frame
;
1817 CHECK_LIVE_FRAME (frame
);
1819 /* I think this should be done with a hook. */
1820 #ifdef HAVE_WINDOW_SYSTEM
1821 if (FRAME_WINDOW_P (XFRAME (frame
)))
1823 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1824 x_make_frame_visible (XFRAME (frame
));
1828 make_frame_visible_1 (XFRAME (frame
)->root_window
);
1830 /* Make menu bar update for the Buffers and Frames menus. */
1831 windows_or_buffers_changed
++;
1836 /* Update the display_time slot of the buffers shown in WINDOW
1837 and all its descendents. */
1840 make_frame_visible_1 (window
)
1845 for (;!NILP (window
); window
= w
->next
)
1847 w
= XWINDOW (window
);
1849 if (!NILP (w
->buffer
))
1850 XBUFFER (w
->buffer
)->display_time
= Fcurrent_time ();
1852 if (!NILP (w
->vchild
))
1853 make_frame_visible_1 (w
->vchild
);
1854 if (!NILP (w
->hchild
))
1855 make_frame_visible_1 (w
->hchild
);
1859 DEFUN ("make-frame-invisible", Fmake_frame_invisible
, Smake_frame_invisible
,
1861 doc
: /* Make the frame FRAME invisible (assuming it is an X window).
1862 If omitted, FRAME defaults to the currently selected frame.
1863 Normally you may not make FRAME invisible if all other frames are invisible,
1864 but if the second optional argument FORCE is non-nil, you may do so. */)
1866 Lisp_Object frame
, force
;
1869 frame
= selected_frame
;
1871 CHECK_LIVE_FRAME (frame
);
1873 if (NILP (force
) && !other_visible_frames (XFRAME (frame
)))
1874 error ("Attempt to make invisible the sole visible or iconified frame");
1876 #if 0 /* This isn't logically necessary, and it can do GC. */
1877 /* Don't let the frame remain selected. */
1878 if (EQ (frame
, selected_frame
))
1879 do_switch_frame (next_frame (frame
, Qt
), 0, 0)
1882 /* Don't allow minibuf_window to remain on a deleted frame. */
1883 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1885 struct frame
*sf
= XFRAME (selected_frame
);
1886 Fset_window_buffer (sf
->minibuffer_window
,
1887 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1888 minibuf_window
= sf
->minibuffer_window
;
1891 /* I think this should be done with a hook. */
1892 #ifdef HAVE_WINDOW_SYSTEM
1893 if (FRAME_WINDOW_P (XFRAME (frame
)))
1894 x_make_frame_invisible (XFRAME (frame
));
1897 /* Make menu bar update for the Buffers and Frames menus. */
1898 windows_or_buffers_changed
++;
1903 DEFUN ("iconify-frame", Ficonify_frame
, Siconify_frame
,
1905 doc
: /* Make the frame FRAME into an icon.
1906 If omitted, FRAME defaults to the currently selected frame. */)
1911 frame
= selected_frame
;
1913 CHECK_LIVE_FRAME (frame
);
1915 #if 0 /* This isn't logically necessary, and it can do GC. */
1916 /* Don't let the frame remain selected. */
1917 if (EQ (frame
, selected_frame
))
1918 Fhandle_switch_frame (next_frame (frame
, Qt
), Qnil
);
1921 /* Don't allow minibuf_window to remain on a deleted frame. */
1922 if (EQ (XFRAME (frame
)->minibuffer_window
, minibuf_window
))
1924 struct frame
*sf
= XFRAME (selected_frame
);
1925 Fset_window_buffer (sf
->minibuffer_window
,
1926 XWINDOW (minibuf_window
)->buffer
, Qnil
);
1927 minibuf_window
= sf
->minibuffer_window
;
1930 /* I think this should be done with a hook. */
1931 #ifdef HAVE_WINDOW_SYSTEM
1932 if (FRAME_WINDOW_P (XFRAME (frame
)))
1933 x_iconify_frame (XFRAME (frame
));
1936 /* Make menu bar update for the Buffers and Frames menus. */
1937 windows_or_buffers_changed
++;
1942 DEFUN ("frame-visible-p", Fframe_visible_p
, Sframe_visible_p
,
1944 doc
: /* Return t if FRAME is now \"visible\" (actually in use for display).
1945 A frame that is not \"visible\" is not updated and, if it works through
1946 a window system, it may not show at all.
1947 Return the symbol `icon' if frame is visible only as an icon.
1949 On a text-only terminal, all frames are considered visible, whether
1950 they are currently being displayed or not, and this function returns t
1955 CHECK_LIVE_FRAME (frame
);
1957 FRAME_SAMPLE_VISIBILITY (XFRAME (frame
));
1959 if (FRAME_VISIBLE_P (XFRAME (frame
)))
1961 if (FRAME_ICONIFIED_P (XFRAME (frame
)))
1966 DEFUN ("visible-frame-list", Fvisible_frame_list
, Svisible_frame_list
,
1968 doc
: /* Return a list of all frames now \"visible\" (being updated). */)
1971 Lisp_Object tail
, frame
;
1976 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1978 frame
= XCAR (tail
);
1979 if (!FRAMEP (frame
))
1982 if (FRAME_VISIBLE_P (f
))
1983 value
= Fcons (frame
, value
);
1989 DEFUN ("raise-frame", Fraise_frame
, Sraise_frame
, 0, 1, "",
1990 doc
: /* Bring FRAME to the front, so it occludes any frames it overlaps.
1991 If FRAME is invisible or iconified, make it visible.
1992 If you don't specify a frame, the selected frame is used.
1993 If Emacs is displaying on an ordinary terminal or some other device which
1994 doesn't support multiple overlapping frames, this function does nothing. */)
2000 frame
= selected_frame
;
2002 CHECK_LIVE_FRAME (frame
);
2006 /* Do like the documentation says. */
2007 Fmake_frame_visible (frame
);
2009 if (FRAME_DISPLAY (f
)->frame_raise_lower_hook
)
2010 (*FRAME_DISPLAY (f
)->frame_raise_lower_hook
) (f
, 1);
2015 /* Should we have a corresponding function called Flower_Power? */
2016 DEFUN ("lower-frame", Flower_frame
, Slower_frame
, 0, 1, "",
2017 doc
: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2018 If you don't specify a frame, the selected frame is used.
2019 If Emacs is displaying on an ordinary terminal or some other device which
2020 doesn't support multiple overlapping frames, this function does nothing. */)
2027 frame
= selected_frame
;
2029 CHECK_LIVE_FRAME (frame
);
2033 if (FRAME_DISPLAY (f
)->frame_raise_lower_hook
)
2034 (*FRAME_DISPLAY (f
)->frame_raise_lower_hook
) (f
, 0);
2040 DEFUN ("redirect-frame-focus", Fredirect_frame_focus
, Sredirect_frame_focus
,
2042 doc
: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2043 In other words, switch-frame events caused by events in FRAME will
2044 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2045 FOCUS-FRAME after reading an event typed at FRAME.
2047 If FOCUS-FRAME is omitted or nil, any existing redirection is
2048 cancelled, and the frame again receives its own keystrokes.
2050 Focus redirection is useful for temporarily redirecting keystrokes to
2051 a surrogate minibuffer frame when a frame doesn't have its own
2054 A frame's focus redirection can be changed by select-frame. If frame
2055 FOO is selected, and then a different frame BAR is selected, any
2056 frames redirecting their focus to FOO are shifted to redirect their
2057 focus to BAR. This allows focus redirection to work properly when the
2058 user switches from one frame to another using `select-window'.
2060 This means that a frame whose focus is redirected to itself is treated
2061 differently from a frame whose focus is redirected to nil; the former
2062 is affected by select-frame, while the latter is not.
2064 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2065 (frame
, focus_frame
)
2066 Lisp_Object frame
, focus_frame
;
2070 /* Note that we don't check for a live frame here. It's reasonable
2071 to redirect the focus of a frame you're about to delete, if you
2072 know what other frame should receive those keystrokes. */
2073 CHECK_FRAME (frame
);
2075 if (! NILP (focus_frame
))
2076 CHECK_LIVE_FRAME (focus_frame
);
2080 f
->focus_frame
= focus_frame
;
2082 if (FRAME_DISPLAY (f
)->frame_rehighlight_hook
)
2083 (*FRAME_DISPLAY (f
)->frame_rehighlight_hook
) (f
);
2089 DEFUN ("frame-focus", Fframe_focus
, Sframe_focus
, 1, 1, 0,
2090 doc
: /* Return the frame to which FRAME's keystrokes are currently being sent.
2091 This returns nil if FRAME's focus is not redirected.
2092 See `redirect-frame-focus'. */)
2096 CHECK_LIVE_FRAME (frame
);
2098 return FRAME_FOCUS_FRAME (XFRAME (frame
));
2103 /* Return the value of frame parameter PROP in frame FRAME. */
2106 get_frame_param (frame
, prop
)
2107 register struct frame
*frame
;
2110 register Lisp_Object tem
;
2112 tem
= Fassq (prop
, frame
->param_alist
);
2118 /* Return the buffer-predicate of the selected frame. */
2121 frame_buffer_predicate (frame
)
2124 return XFRAME (frame
)->buffer_predicate
;
2127 /* Return the buffer-list of the selected frame. */
2130 frame_buffer_list (frame
)
2133 return XFRAME (frame
)->buffer_list
;
2136 /* Set the buffer-list of the selected frame. */
2139 set_frame_buffer_list (frame
, list
)
2140 Lisp_Object frame
, list
;
2142 XFRAME (frame
)->buffer_list
= list
;
2145 /* Discard BUFFER from the buffer-list of each frame. */
2148 frames_discard_buffer (buffer
)
2151 Lisp_Object frame
, tail
;
2153 FOR_EACH_FRAME (tail
, frame
)
2155 XFRAME (frame
)->buffer_list
2156 = Fdelq (buffer
, XFRAME (frame
)->buffer_list
);
2160 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2161 If the alist already has an element for PROP, we change it. */
2164 store_in_alist (alistptr
, prop
, val
)
2165 Lisp_Object
*alistptr
, val
;
2168 register Lisp_Object tem
;
2170 tem
= Fassq (prop
, *alistptr
);
2172 *alistptr
= Fcons (Fcons (prop
, val
), *alistptr
);
2178 frame_name_fnn_p (str
, len
)
2182 if (len
> 1 && str
[0] == 'F')
2186 strtol (str
+ 1, &end_ptr
, 10);
2188 if (end_ptr
== str
+ len
)
2194 /* Set the name of the terminal frame. Also used by MSDOS frames.
2195 Modeled after x_set_name which is used for WINDOW frames. */
2198 set_term_frame_name (f
, name
)
2202 f
->explicit_name
= ! NILP (name
);
2204 /* If NAME is nil, set the name to F<num>. */
2209 /* Check for no change needed in this very common case
2210 before we do any consing. */
2211 if (frame_name_fnn_p (SDATA (f
->name
),
2215 terminal_frame_count
++;
2216 sprintf (namebuf
, "F%d", terminal_frame_count
);
2217 name
= build_string (namebuf
);
2221 CHECK_STRING (name
);
2223 /* Don't change the name if it's already NAME. */
2224 if (! NILP (Fstring_equal (name
, f
->name
)))
2227 /* Don't allow the user to set the frame name to F<num>, so it
2228 doesn't clash with the names we generate for terminal frames. */
2229 if (frame_name_fnn_p (SDATA (name
), SBYTES (name
)))
2230 error ("Frame names of the form F<num> are usurped by Emacs");
2234 update_mode_lines
= 1;
2238 store_frame_param (f
, prop
, val
)
2240 Lisp_Object prop
, val
;
2242 register Lisp_Object old_alist_elt
;
2244 /* The buffer-alist parameter is stored in a special place and is
2245 not in the alist. */
2246 if (EQ (prop
, Qbuffer_list
))
2248 f
->buffer_list
= val
;
2252 /* If PROP is a symbol which is supposed to have frame-local values,
2253 and it is set up based on this frame, switch to the global
2254 binding. That way, we can create or alter the frame-local binding
2255 without messing up the symbol's status. */
2258 Lisp_Object valcontents
;
2259 valcontents
= SYMBOL_VALUE (prop
);
2260 if ((BUFFER_LOCAL_VALUEP (valcontents
)
2261 || SOME_BUFFER_LOCAL_VALUEP (valcontents
))
2262 && XBUFFER_LOCAL_VALUE (valcontents
)->check_frame
2263 && XFRAME (XBUFFER_LOCAL_VALUE (valcontents
)->frame
) == f
)
2264 swap_in_global_binding (prop
);
2268 /* The tty color mode needs to be set before the frame's parameter
2269 alist is updated with the new value, because set_tty_color_mode
2270 wants to look at the old mode. */
2271 if (FRAME_TERMCAP_P (f
) && EQ (prop
, Qtty_color_mode
))
2272 set_tty_color_mode (f
, val
);
2275 /* Update the frame parameter alist. */
2276 old_alist_elt
= Fassq (prop
, f
->param_alist
);
2277 if (EQ (old_alist_elt
, Qnil
))
2278 f
->param_alist
= Fcons (Fcons (prop
, val
), f
->param_alist
);
2280 Fsetcdr (old_alist_elt
, val
);
2282 /* Update some other special parameters in their special places
2283 in addition to the alist. */
2285 if (EQ (prop
, Qbuffer_predicate
))
2286 f
->buffer_predicate
= val
;
2288 if (! FRAME_WINDOW_P (f
))
2290 if (EQ (prop
, Qmenu_bar_lines
))
2291 set_menu_bar_lines (f
, val
, make_number (FRAME_MENU_BAR_LINES (f
)));
2292 else if (EQ (prop
, Qname
))
2293 set_term_frame_name (f
, val
);
2296 if (EQ (prop
, Qminibuffer
) && WINDOWP (val
))
2298 if (! MINI_WINDOW_P (XWINDOW (val
)))
2299 error ("Surrogate minibuffer windows must be minibuffer windows");
2301 if ((FRAME_HAS_MINIBUF_P (f
) || FRAME_MINIBUF_ONLY_P (f
))
2302 && !EQ (val
, f
->minibuffer_window
))
2303 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2305 /* Install the chosen minibuffer window, with proper buffer. */
2306 f
->minibuffer_window
= val
;
2310 DEFUN ("frame-parameters", Fframe_parameters
, Sframe_parameters
, 0, 1, 0,
2311 doc
: /* Return the parameters-alist of frame FRAME.
2312 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2313 The meaningful PARMs depend on the kind of frame.
2314 If FRAME is omitted, return information on the currently selected frame. */)
2321 struct gcpro gcpro1
;
2324 frame
= selected_frame
;
2326 CHECK_FRAME (frame
);
2329 if (!FRAME_LIVE_P (f
))
2332 alist
= Fcopy_alist (f
->param_alist
);
2335 if (!FRAME_WINDOW_P (f
))
2337 int fg
= FRAME_FOREGROUND_PIXEL (f
);
2338 int bg
= FRAME_BACKGROUND_PIXEL (f
);
2341 /* If the frame's parameter alist says the colors are
2342 unspecified and reversed, take the frame's background pixel
2343 for foreground and vice versa. */
2344 elt
= Fassq (Qforeground_color
, alist
);
2345 if (!NILP (elt
) && CONSP (elt
) && STRINGP (XCDR (elt
)))
2347 if (strncmp (SDATA (XCDR (elt
)),
2349 SCHARS (XCDR (elt
))) == 0)
2350 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, bg
));
2351 else if (strncmp (SDATA (XCDR (elt
)),
2353 SCHARS (XCDR (elt
))) == 0)
2354 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2357 store_in_alist (&alist
, Qforeground_color
, tty_color_name (f
, fg
));
2358 elt
= Fassq (Qbackground_color
, alist
);
2359 if (!NILP (elt
) && CONSP (elt
) && STRINGP (XCDR (elt
)))
2361 if (strncmp (SDATA (XCDR (elt
)),
2363 SCHARS (XCDR (elt
))) == 0)
2364 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, fg
));
2365 else if (strncmp (SDATA (XCDR (elt
)),
2367 SCHARS (XCDR (elt
))) == 0)
2368 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2371 store_in_alist (&alist
, Qbackground_color
, tty_color_name (f
, bg
));
2372 store_in_alist (&alist
, intern ("font"),
2373 build_string (FRAME_MSDOS_P (f
)
2375 : FRAME_W32_P (f
) ? "w32term"
2378 store_in_alist (&alist
, Qname
, f
->name
);
2379 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2380 store_in_alist (&alist
, Qheight
, make_number (height
));
2381 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2382 store_in_alist (&alist
, Qwidth
, make_number (width
));
2383 store_in_alist (&alist
, Qmodeline
, (FRAME_WANTS_MODELINE_P (f
) ? Qt
: Qnil
));
2384 store_in_alist (&alist
, Qminibuffer
,
2385 (! FRAME_HAS_MINIBUF_P (f
) ? Qnil
2386 : FRAME_MINIBUF_ONLY_P (f
) ? Qonly
2387 : FRAME_MINIBUF_WINDOW (f
)));
2388 store_in_alist (&alist
, Qunsplittable
, (FRAME_NO_SPLIT_P (f
) ? Qt
: Qnil
));
2389 store_in_alist (&alist
, Qbuffer_list
, frame_buffer_list (frame
));
2391 /* I think this should be done with a hook. */
2392 #ifdef HAVE_WINDOW_SYSTEM
2393 if (FRAME_WINDOW_P (f
))
2394 x_report_frame_params (f
, &alist
);
2398 /* This ought to be correct in f->param_alist for an X frame. */
2400 XSETFASTINT (lines
, FRAME_MENU_BAR_LINES (f
));
2401 store_in_alist (&alist
, Qmenu_bar_lines
, lines
);
2409 DEFUN ("frame-parameter", Fframe_parameter
, Sframe_parameter
, 2, 2, 0,
2410 doc
: /* Return FRAME's value for parameter PARAMETER.
2411 If FRAME is nil, describe the currently selected frame. */)
2413 Lisp_Object frame
, parameter
;
2419 frame
= selected_frame
;
2421 CHECK_FRAME (frame
);
2422 CHECK_SYMBOL (parameter
);
2427 if (FRAME_LIVE_P (f
))
2429 /* Avoid consing in frequent cases. */
2430 if (EQ (parameter
, Qname
))
2432 #ifdef HAVE_X_WINDOWS
2433 else if (EQ (parameter
, Qdisplay
) && FRAME_X_P (f
))
2434 value
= XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
);
2435 #endif /* HAVE_X_WINDOWS */
2436 else if (EQ (parameter
, Qbackground_color
)
2437 || EQ (parameter
, Qforeground_color
))
2439 value
= Fassq (parameter
, f
->param_alist
);
2442 value
= XCDR (value
);
2443 /* Fframe_parameters puts the actual fg/bg color names,
2444 even if f->param_alist says otherwise. This is
2445 important when param_alist's notion of colors is
2446 "unspecified". We need to do the same here. */
2447 if (STRINGP (value
) && !FRAME_WINDOW_P (f
))
2449 const char *color_name
;
2452 if (EQ (parameter
, Qbackground_color
))
2454 color_name
= SDATA (value
);
2455 csz
= SCHARS (value
);
2456 if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2457 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2458 else if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2459 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2461 else if (EQ (parameter
, Qforeground_color
))
2463 color_name
= SDATA (value
);
2464 csz
= SCHARS (value
);
2465 if (strncmp (color_name
, unspecified_fg
, csz
) == 0)
2466 value
= tty_color_name (f
, FRAME_FOREGROUND_PIXEL (f
));
2467 else if (strncmp (color_name
, unspecified_bg
, csz
) == 0)
2468 value
= tty_color_name (f
, FRAME_BACKGROUND_PIXEL (f
));
2473 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2475 else if (EQ (parameter
, Qdisplay_type
)
2476 || EQ (parameter
, Qbackground_mode
))
2477 value
= Fcdr (Fassq (parameter
, f
->param_alist
));
2479 value
= Fcdr (Fassq (parameter
, Fframe_parameters (frame
)));
2486 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters
,
2487 Smodify_frame_parameters
, 2, 2, 0,
2488 doc
: /* Modify the parameters of frame FRAME according to ALIST.
2489 If FRAME is nil, it defaults to the selected frame.
2490 ALIST is an alist of parameters to change and their new values.
2491 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2492 The meaningful PARMs depend on the kind of frame.
2493 Undefined PARMs are ignored, but stored in the frame's parameter list
2494 so that `frame-parameters' will return them.
2496 The value of frame parameter FOO can also be accessed
2497 as a frame-local binding for the variable FOO, if you have
2498 enabled such bindings for that variable with `make-variable-frame-local'. */)
2500 Lisp_Object frame
, alist
;
2503 register Lisp_Object tail
, prop
, val
;
2504 int count
= SPECPDL_INDEX ();
2506 /* Bind this to t to inhibit initialization of the default face from
2507 X resources in face-set-after-frame-default. If we don't inhibit
2508 this, modifying the `font' frame parameter, for example, while
2509 there is a `default.attributeFont' X resource, won't work,
2510 because `default's font is reset to the value of the X resource
2511 and that resets the `font' frame parameter. */
2512 specbind (Qinhibit_default_face_x_resources
, Qt
);
2514 if (EQ (frame
, Qnil
))
2515 frame
= selected_frame
;
2516 CHECK_LIVE_FRAME (frame
);
2519 /* I think this should be done with a hook. */
2520 #ifdef HAVE_WINDOW_SYSTEM
2521 if (FRAME_WINDOW_P (f
))
2522 x_set_frame_parameters (f
, alist
);
2526 if (FRAME_MSDOS_P (f
))
2527 IT_set_frame_parameters (f
, alist
);
2532 int length
= XINT (Flength (alist
));
2535 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2537 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2539 /* Extract parm names and values into those vectors. */
2542 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2547 parms
[i
] = Fcar (elt
);
2548 values
[i
] = Fcdr (elt
);
2552 /* Now process them in reverse of specified order. */
2553 for (i
--; i
>= 0; i
--)
2557 store_frame_param (f
, prop
, val
);
2561 return unbind_to (count
, Qnil
);
2564 DEFUN ("frame-char-height", Fframe_char_height
, Sframe_char_height
,
2566 doc
: /* Height in pixels of a line in the font in frame FRAME.
2567 If FRAME is omitted, the selected frame is used.
2568 For a terminal frame, the value is always 1. */)
2575 frame
= selected_frame
;
2576 CHECK_FRAME (frame
);
2579 #ifdef HAVE_WINDOW_SYSTEM
2580 if (FRAME_WINDOW_P (f
))
2581 return make_number (x_char_height (f
));
2584 return make_number (1);
2588 DEFUN ("frame-char-width", Fframe_char_width
, Sframe_char_width
,
2590 doc
: /* Width in pixels of characters in the font in frame FRAME.
2591 If FRAME is omitted, the selected frame is used.
2592 The width is the same for all characters, because
2593 currently Emacs supports only fixed-width fonts.
2594 For a terminal screen, the value is always 1. */)
2601 frame
= selected_frame
;
2602 CHECK_FRAME (frame
);
2605 #ifdef HAVE_WINDOW_SYSTEM
2606 if (FRAME_WINDOW_P (f
))
2607 return make_number (x_char_width (f
));
2610 return make_number (1);
2613 DEFUN ("frame-pixel-height", Fframe_pixel_height
,
2614 Sframe_pixel_height
, 0, 1, 0,
2615 doc
: /* Return a FRAME's height in pixels.
2616 This counts only the height available for text lines,
2617 not menu bars on window-system Emacs frames.
2618 For a terminal frame, the result really gives the height in characters.
2619 If FRAME is omitted, the selected frame is used. */)
2626 frame
= selected_frame
;
2627 CHECK_FRAME (frame
);
2630 #ifdef HAVE_WINDOW_SYSTEM
2631 if (FRAME_WINDOW_P (f
))
2632 return make_number (x_pixel_height (f
));
2635 return make_number (FRAME_LINES (f
));
2638 DEFUN ("frame-pixel-width", Fframe_pixel_width
,
2639 Sframe_pixel_width
, 0, 1, 0,
2640 doc
: /* Return FRAME's width in pixels.
2641 For a terminal frame, the result really gives the width in characters.
2642 If FRAME is omitted, the selected frame is used. */)
2649 frame
= selected_frame
;
2650 CHECK_FRAME (frame
);
2653 #ifdef HAVE_WINDOW_SYSTEM
2654 if (FRAME_WINDOW_P (f
))
2655 return make_number (x_pixel_width (f
));
2658 return make_number (FRAME_COLS (f
));
2661 DEFUN ("set-frame-height", Fset_frame_height
, Sset_frame_height
, 2, 3, 0,
2662 doc
: /* Specify that the frame FRAME has LINES lines.
2663 Optional third arg non-nil means that redisplay should use LINES lines
2664 but that the idea of the actual height of the frame should not be changed. */)
2665 (frame
, lines
, pretend
)
2666 Lisp_Object frame
, lines
, pretend
;
2668 register struct frame
*f
;
2670 CHECK_NUMBER (lines
);
2672 frame
= selected_frame
;
2673 CHECK_LIVE_FRAME (frame
);
2676 /* I think this should be done with a hook. */
2677 #ifdef HAVE_WINDOW_SYSTEM
2678 if (FRAME_WINDOW_P (f
))
2680 if (XINT (lines
) != FRAME_LINES (f
))
2681 x_set_window_size (f
, 1, FRAME_COLS (f
), XINT (lines
));
2682 do_pending_window_change (0);
2686 change_frame_size (f
, XINT (lines
), 0, !NILP (pretend
), 0, 0);
2690 DEFUN ("set-frame-width", Fset_frame_width
, Sset_frame_width
, 2, 3, 0,
2691 doc
: /* Specify that the frame FRAME has COLS columns.
2692 Optional third arg non-nil means that redisplay should use COLS columns
2693 but that the idea of the actual width of the frame should not be changed. */)
2694 (frame
, cols
, pretend
)
2695 Lisp_Object frame
, cols
, pretend
;
2697 register struct frame
*f
;
2698 CHECK_NUMBER (cols
);
2700 frame
= selected_frame
;
2701 CHECK_LIVE_FRAME (frame
);
2704 /* I think this should be done with a hook. */
2705 #ifdef HAVE_WINDOW_SYSTEM
2706 if (FRAME_WINDOW_P (f
))
2708 if (XINT (cols
) != FRAME_COLS (f
))
2709 x_set_window_size (f
, 1, XINT (cols
), FRAME_LINES (f
));
2710 do_pending_window_change (0);
2714 change_frame_size (f
, 0, XINT (cols
), !NILP (pretend
), 0, 0);
2718 DEFUN ("set-frame-size", Fset_frame_size
, Sset_frame_size
, 3, 3, 0,
2719 doc
: /* Sets size of FRAME to COLS by ROWS, measured in characters. */)
2721 Lisp_Object frame
, cols
, rows
;
2723 register struct frame
*f
;
2725 CHECK_LIVE_FRAME (frame
);
2726 CHECK_NUMBER (cols
);
2727 CHECK_NUMBER (rows
);
2730 /* I think this should be done with a hook. */
2731 #ifdef HAVE_WINDOW_SYSTEM
2732 if (FRAME_WINDOW_P (f
))
2734 if (XINT (rows
) != FRAME_LINES (f
)
2735 || XINT (cols
) != FRAME_COLS (f
)
2736 || f
->new_text_lines
|| f
->new_text_cols
)
2737 x_set_window_size (f
, 1, XINT (cols
), XINT (rows
));
2738 do_pending_window_change (0);
2742 change_frame_size (f
, XINT (rows
), XINT (cols
), 0, 0, 0);
2747 DEFUN ("set-frame-position", Fset_frame_position
,
2748 Sset_frame_position
, 3, 3, 0,
2749 doc
: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2750 This is actually the position of the upper left corner of the frame.
2751 Negative values for XOFFSET or YOFFSET are interpreted relative to
2752 the rightmost or bottommost possible position (that stays within the screen). */)
2753 (frame
, xoffset
, yoffset
)
2754 Lisp_Object frame
, xoffset
, yoffset
;
2756 register struct frame
*f
;
2758 CHECK_LIVE_FRAME (frame
);
2759 CHECK_NUMBER (xoffset
);
2760 CHECK_NUMBER (yoffset
);
2763 /* I think this should be done with a hook. */
2764 #ifdef HAVE_WINDOW_SYSTEM
2765 if (FRAME_WINDOW_P (f
))
2766 x_set_offset (f
, XINT (xoffset
), XINT (yoffset
), 1);
2773 /***********************************************************************
2775 ***********************************************************************/
2777 /* Connect the frame-parameter names for X frames
2778 to the ways of passing the parameter values to the window system.
2780 The name of a parameter, as a Lisp symbol,
2781 has an `x-frame-parameter' property which is an integer in Lisp
2782 that is an index in this table. */
2784 struct frame_parm_table
{
2786 Lisp_Object
*variable
;
2789 static struct frame_parm_table frame_parms
[] =
2791 {"auto-raise", &Qauto_raise
},
2792 {"auto-lower", &Qauto_lower
},
2793 {"background-color", 0},
2794 {"border-color", &Qborder_color
},
2795 {"border-width", &Qborder_width
},
2796 {"cursor-color", &Qcursor_color
},
2797 {"cursor-type", &Qcursor_type
},
2799 {"foreground-color", 0},
2800 {"icon-name", &Qicon_name
},
2801 {"icon-type", &Qicon_type
},
2802 {"internal-border-width", &Qinternal_border_width
},
2803 {"menu-bar-lines", &Qmenu_bar_lines
},
2804 {"mouse-color", &Qmouse_color
},
2806 {"scroll-bar-width", &Qscroll_bar_width
},
2808 {"unsplittable", &Qunsplittable
},
2809 {"vertical-scroll-bars", &Qvertical_scroll_bars
},
2810 {"visibility", &Qvisibility
},
2811 {"tool-bar-lines", &Qtool_bar_lines
},
2812 {"scroll-bar-foreground", &Qscroll_bar_foreground
},
2813 {"scroll-bar-background", &Qscroll_bar_background
},
2814 {"screen-gamma", &Qscreen_gamma
},
2815 {"line-spacing", &Qline_spacing
},
2816 {"left-fringe", &Qleft_fringe
},
2817 {"right-fringe", &Qright_fringe
},
2818 {"wait-for-wm", &Qwait_for_wm
},
2819 {"fullscreen", &Qfullscreen
},
2822 #ifdef HAVE_WINDOW_SYSTEM
2824 extern Lisp_Object Qbox
;
2825 extern Lisp_Object Qtop
;
2827 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
2828 wanted positions of the WM window (not emacs window).
2829 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
2830 window (FRAME_X_WINDOW).
2834 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
2841 int newwidth
= FRAME_COLS (f
);
2842 int newheight
= FRAME_LINES (f
);
2844 *top_pos
= f
->top_pos
;
2845 *left_pos
= f
->left_pos
;
2847 if (f
->want_fullscreen
& FULLSCREEN_HEIGHT
)
2851 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
2852 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2853 ph
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, newheight
) - f
->y_pixels_diff
;
2854 newheight
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, ph
);
2858 if (f
->want_fullscreen
& FULLSCREEN_WIDTH
)
2862 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
2863 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2864 pw
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, newwidth
) - f
->x_pixels_diff
;
2865 newwidth
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pw
);
2870 *height
= newheight
;
2874 /* Change the parameters of frame F as specified by ALIST.
2875 If a parameter is not specially recognized, do nothing special;
2876 otherwise call the `x_set_...' function for that parameter.
2877 Except for certain geometry properties, always call store_frame_param
2878 to store the new value in the parameter alist. */
2881 x_set_frame_parameters (f
, alist
)
2887 /* If both of these parameters are present, it's more efficient to
2888 set them both at once. So we wait until we've looked at the
2889 entire list before we set them. */
2893 Lisp_Object left
, top
;
2895 /* Same with these. */
2896 Lisp_Object icon_left
, icon_top
;
2898 /* Record in these vectors all the parms specified. */
2900 Lisp_Object
*values
;
2902 int left_no_change
= 0, top_no_change
= 0;
2903 int icon_left_no_change
= 0, icon_top_no_change
= 0;
2904 int fullscreen_is_being_set
= 0;
2906 struct gcpro gcpro1
, gcpro2
;
2909 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2912 parms
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2913 values
= (Lisp_Object
*) alloca (i
* sizeof (Lisp_Object
));
2915 /* Extract parm names and values into those vectors. */
2918 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2923 parms
[i
] = Fcar (elt
);
2924 values
[i
] = Fcdr (elt
);
2927 /* TAIL and ALIST are not used again below here. */
2928 alist
= tail
= Qnil
;
2930 GCPRO2 (*parms
, *values
);
2934 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
2935 because their values appear in VALUES and strings are not valid. */
2936 top
= left
= Qunbound
;
2937 icon_left
= icon_top
= Qunbound
;
2939 /* Provide default values for HEIGHT and WIDTH. */
2940 width
= (f
->new_text_cols
? f
->new_text_cols
: FRAME_COLS (f
));
2941 height
= (f
->new_text_lines
? f
->new_text_lines
: FRAME_LINES (f
));
2943 /* Process foreground_color and background_color before anything else.
2944 They are independent of other properties, but other properties (e.g.,
2945 cursor_color) are dependent upon them. */
2946 /* Process default font as well, since fringe widths depends on it. */
2947 /* Also, process fullscreen, width and height depend upon that */
2948 for (p
= 0; p
< i
; p
++)
2950 Lisp_Object prop
, val
;
2954 if (EQ (prop
, Qforeground_color
)
2955 || EQ (prop
, Qbackground_color
)
2957 || EQ (prop
, Qfullscreen
))
2959 register Lisp_Object param_index
, old_value
;
2961 old_value
= get_frame_param (f
, prop
);
2962 fullscreen_is_being_set
|= EQ (prop
, Qfullscreen
);
2964 if (NILP (Fequal (val
, old_value
)))
2966 store_frame_param (f
, prop
, val
);
2968 param_index
= Fget (prop
, Qx_frame_parameter
);
2969 if (NATNUMP (param_index
)
2970 && (XFASTINT (param_index
)
2971 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
2972 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
2973 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
2978 /* Now process them in reverse of specified order. */
2979 for (i
--; i
>= 0; i
--)
2981 Lisp_Object prop
, val
;
2986 if (EQ (prop
, Qwidth
) && NUMBERP (val
))
2987 width
= XFASTINT (val
);
2988 else if (EQ (prop
, Qheight
) && NUMBERP (val
))
2989 height
= XFASTINT (val
);
2990 else if (EQ (prop
, Qtop
))
2992 else if (EQ (prop
, Qleft
))
2994 else if (EQ (prop
, Qicon_top
))
2996 else if (EQ (prop
, Qicon_left
))
2998 else if (EQ (prop
, Qforeground_color
)
2999 || EQ (prop
, Qbackground_color
)
3001 || EQ (prop
, Qfullscreen
))
3002 /* Processed above. */
3006 register Lisp_Object param_index
, old_value
;
3008 old_value
= get_frame_param (f
, prop
);
3010 store_frame_param (f
, prop
, val
);
3012 param_index
= Fget (prop
, Qx_frame_parameter
);
3013 if (NATNUMP (param_index
)
3014 && (XFASTINT (param_index
)
3015 < sizeof (frame_parms
)/sizeof (frame_parms
[0]))
3016 && FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])
3017 (*(FRAME_RIF (f
)->frame_parm_handlers
[XINT (param_index
)])) (f
, val
, old_value
);
3021 /* Don't die if just one of these was set. */
3022 if (EQ (left
, Qunbound
))
3025 if (f
->left_pos
< 0)
3026 left
= Fcons (Qplus
, Fcons (make_number (f
->left_pos
), Qnil
));
3028 XSETINT (left
, f
->left_pos
);
3030 if (EQ (top
, Qunbound
))
3034 top
= Fcons (Qplus
, Fcons (make_number (f
->top_pos
), Qnil
));
3036 XSETINT (top
, f
->top_pos
);
3039 /* If one of the icon positions was not set, preserve or default it. */
3040 if (EQ (icon_left
, Qunbound
) || ! INTEGERP (icon_left
))
3042 icon_left_no_change
= 1;
3043 icon_left
= Fcdr (Fassq (Qicon_left
, f
->param_alist
));
3044 if (NILP (icon_left
))
3045 XSETINT (icon_left
, 0);
3047 if (EQ (icon_top
, Qunbound
) || ! INTEGERP (icon_top
))
3049 icon_top_no_change
= 1;
3050 icon_top
= Fcdr (Fassq (Qicon_top
, f
->param_alist
));
3051 if (NILP (icon_top
))
3052 XSETINT (icon_top
, 0);
3056 /* MAC_TODO: fullscreen */
3057 if (FRAME_VISIBLE_P (f
) && fullscreen_is_being_set
)
3059 /* If the frame is visible already and the fullscreen parameter is
3060 being set, it is too late to set WM manager hints to specify
3062 Here we first get the width, height and position that applies to
3063 fullscreen. We then move the frame to the appropriate
3064 position. Resize of the frame is taken care of in the code after
3065 this if-statement. */
3066 int new_left
, new_top
;
3068 x_fullscreen_adjust (f
, &width
, &height
, &new_top
, &new_left
);
3069 if (new_top
!= f
->top_pos
|| new_left
!= f
->left_pos
)
3070 x_set_offset (f
, new_left
, new_top
, 1);
3074 /* Don't set these parameters unless they've been explicitly
3075 specified. The window might be mapped or resized while we're in
3076 this function, and we don't want to override that unless the lisp
3077 code has asked for it.
3079 Don't set these parameters unless they actually differ from the
3080 window's current parameters; the window may not actually exist
3085 check_frame_size (f
, &height
, &width
);
3087 XSETFRAME (frame
, f
);
3089 if (width
!= FRAME_COLS (f
)
3090 || height
!= FRAME_LINES (f
)
3091 || f
->new_text_lines
|| f
->new_text_cols
)
3092 Fset_frame_size (frame
, make_number (width
), make_number (height
));
3094 if ((!NILP (left
) || !NILP (top
))
3095 && ! (left_no_change
&& top_no_change
)
3096 && ! (NUMBERP (left
) && XINT (left
) == f
->left_pos
3097 && NUMBERP (top
) && XINT (top
) == f
->top_pos
))
3102 /* Record the signs. */
3103 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3104 if (EQ (left
, Qminus
))
3105 f
->size_hint_flags
|= XNegative
;
3106 else if (INTEGERP (left
))
3108 leftpos
= XINT (left
);
3110 f
->size_hint_flags
|= XNegative
;
3112 else if (CONSP (left
) && EQ (XCAR (left
), Qminus
)
3113 && CONSP (XCDR (left
))
3114 && INTEGERP (XCAR (XCDR (left
))))
3116 leftpos
= - XINT (XCAR (XCDR (left
)));
3117 f
->size_hint_flags
|= XNegative
;
3119 else if (CONSP (left
) && EQ (XCAR (left
), Qplus
)
3120 && CONSP (XCDR (left
))
3121 && INTEGERP (XCAR (XCDR (left
))))
3123 leftpos
= XINT (XCAR (XCDR (left
)));
3126 if (EQ (top
, Qminus
))
3127 f
->size_hint_flags
|= YNegative
;
3128 else if (INTEGERP (top
))
3130 toppos
= XINT (top
);
3132 f
->size_hint_flags
|= YNegative
;
3134 else if (CONSP (top
) && EQ (XCAR (top
), Qminus
)
3135 && CONSP (XCDR (top
))
3136 && INTEGERP (XCAR (XCDR (top
))))
3138 toppos
= - XINT (XCAR (XCDR (top
)));
3139 f
->size_hint_flags
|= YNegative
;
3141 else if (CONSP (top
) && EQ (XCAR (top
), Qplus
)
3142 && CONSP (XCDR (top
))
3143 && INTEGERP (XCAR (XCDR (top
))))
3145 toppos
= XINT (XCAR (XCDR (top
)));
3149 /* Store the numeric value of the position. */
3150 f
->top_pos
= toppos
;
3151 f
->left_pos
= leftpos
;
3153 f
->win_gravity
= NorthWestGravity
;
3155 /* Actually set that position, and convert to absolute. */
3156 x_set_offset (f
, leftpos
, toppos
, -1);
3159 if ((!NILP (icon_left
) || !NILP (icon_top
))
3160 && ! (icon_left_no_change
&& icon_top_no_change
))
3161 x_wm_set_icon_position (f
, XINT (icon_left
), XINT (icon_top
));
3168 /* Insert a description of internally-recorded parameters of frame X
3169 into the parameter alist *ALISTPTR that is to be given to the user.
3170 Only parameters that are specific to the X window system
3171 and whose values are not correctly recorded in the frame's
3172 param_alist need to be considered here. */
3175 x_report_frame_params (f
, alistptr
)
3177 Lisp_Object
*alistptr
;
3182 /* Represent negative positions (off the top or left screen edge)
3183 in a way that Fmodify_frame_parameters will understand correctly. */
3184 XSETINT (tem
, f
->left_pos
);
3185 if (f
->left_pos
>= 0)
3186 store_in_alist (alistptr
, Qleft
, tem
);
3188 store_in_alist (alistptr
, Qleft
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3190 XSETINT (tem
, f
->top_pos
);
3191 if (f
->top_pos
>= 0)
3192 store_in_alist (alistptr
, Qtop
, tem
);
3194 store_in_alist (alistptr
, Qtop
, Fcons (Qplus
, Fcons (tem
, Qnil
)));
3196 store_in_alist (alistptr
, Qborder_width
,
3197 make_number (f
->border_width
));
3198 store_in_alist (alistptr
, Qinternal_border_width
,
3199 make_number (FRAME_INTERNAL_BORDER_WIDTH (f
)));
3200 store_in_alist (alistptr
, Qleft_fringe
,
3201 make_number (FRAME_LEFT_FRINGE_WIDTH (f
)));
3202 store_in_alist (alistptr
, Qright_fringe
,
3203 make_number (FRAME_RIGHT_FRINGE_WIDTH (f
)));
3204 store_in_alist (alistptr
, Qscroll_bar_width
,
3205 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3207 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
3208 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3209 /* nil means "use default width"
3210 for non-toolkit scroll bar.
3211 ruler-mode.el depends on this. */
3213 sprintf (buf
, "%ld", (long) FRAME_X_WINDOW (f
));
3214 store_in_alist (alistptr
, Qwindow_id
,
3215 build_string (buf
));
3216 #ifdef HAVE_X_WINDOWS
3217 #ifdef USE_X_TOOLKIT
3218 /* Tooltip frame may not have this widget. */
3219 if (FRAME_X_OUTPUT (f
)->widget
)
3221 sprintf (buf
, "%ld", (long) FRAME_OUTER_WINDOW (f
));
3222 store_in_alist (alistptr
, Qouter_window_id
,
3223 build_string (buf
));
3225 store_in_alist (alistptr
, Qicon_name
, f
->icon_name
);
3226 FRAME_SAMPLE_VISIBILITY (f
);
3227 store_in_alist (alistptr
, Qvisibility
,
3228 (FRAME_VISIBLE_P (f
) ? Qt
3229 : FRAME_ICONIFIED_P (f
) ? Qicon
: Qnil
));
3230 store_in_alist (alistptr
, Qdisplay
,
3231 XCAR (FRAME_X_DISPLAY_INFO (f
)->name_list_element
));
3234 /* A Mac Window is identified by a struct, not an integer. */
3235 if (FRAME_X_OUTPUT (f
)->parent_desc
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
3238 XSETFASTINT (tem
, FRAME_X_OUTPUT (f
)->parent_desc
);
3239 store_in_alist (alistptr
, Qparent_id
, tem
);
3244 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3245 the previous value of that parameter, NEW_VALUE is the new value. */
3248 x_set_fullscreen (f
, new_value
, old_value
)
3250 Lisp_Object new_value
, old_value
;
3253 if (NILP (new_value
))
3254 f
->want_fullscreen
= FULLSCREEN_NONE
;
3255 else if (EQ (new_value
, Qfullboth
))
3256 f
->want_fullscreen
= FULLSCREEN_BOTH
;
3257 else if (EQ (new_value
, Qfullwidth
))
3258 f
->want_fullscreen
= FULLSCREEN_WIDTH
;
3259 else if (EQ (new_value
, Qfullheight
))
3260 f
->want_fullscreen
= FULLSCREEN_HEIGHT
;
3265 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3266 the previous value of that parameter, NEW_VALUE is the new value. */
3269 x_set_line_spacing (f
, new_value
, old_value
)
3271 Lisp_Object new_value
, old_value
;
3273 if (NILP (new_value
))
3274 f
->extra_line_spacing
= 0;
3275 else if (NATNUMP (new_value
))
3276 f
->extra_line_spacing
= XFASTINT (new_value
);
3278 Fsignal (Qerror
, Fcons (build_string ("Invalid line-spacing"),
3279 Fcons (new_value
, Qnil
)));
3280 if (FRAME_VISIBLE_P (f
))
3285 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3286 the previous value of that parameter, NEW_VALUE is the new value. */
3289 x_set_screen_gamma (f
, new_value
, old_value
)
3291 Lisp_Object new_value
, old_value
;
3293 if (NILP (new_value
))
3295 else if (NUMBERP (new_value
) && XFLOATINT (new_value
) > 0)
3296 /* The value 0.4545 is the normal viewing gamma. */
3297 f
->gamma
= 1.0 / (0.4545 * XFLOATINT (new_value
));
3299 Fsignal (Qerror
, Fcons (build_string ("Invalid screen-gamma"),
3300 Fcons (new_value
, Qnil
)));
3302 clear_face_cache (0);
3307 x_set_font (f
, arg
, oldval
)
3309 Lisp_Object arg
, oldval
;
3312 Lisp_Object fontset_name
;
3314 int old_fontset
= FRAME_FONTSET(f
);
3318 fontset_name
= Fquery_fontset (arg
, Qnil
);
3321 result
= (STRINGP (fontset_name
)
3322 ? x_new_fontset (f
, SDATA (fontset_name
))
3323 : x_new_font (f
, SDATA (arg
)));
3326 if (EQ (result
, Qnil
))
3327 error ("Font `%s' is not defined", SDATA (arg
));
3328 else if (EQ (result
, Qt
))
3329 error ("The characters of the given font have varying widths");
3330 else if (STRINGP (result
))
3332 if (STRINGP (fontset_name
))
3334 /* Fontset names are built from ASCII font names, so the
3335 names may be equal despite there was a change. */
3336 if (old_fontset
== FRAME_FONTSET (f
))
3339 else if (!NILP (Fequal (result
, oldval
)))
3342 store_frame_param (f
, Qfont
, result
);
3343 recompute_basic_faces (f
);
3348 do_pending_window_change (0);
3350 /* Don't call `face-set-after-frame-default' when faces haven't been
3351 initialized yet. This is the case when called from
3352 Fx_create_frame. In that case, the X widget or window doesn't
3353 exist either, and we can end up in x_report_frame_params with a
3354 null widget which gives a segfault. */
3355 if (FRAME_FACE_CACHE (f
))
3357 XSETFRAME (frame
, f
);
3358 call1 (Qface_set_after_frame_default
, frame
);
3364 x_set_fringe_width (f
, new_value
, old_value
)
3366 Lisp_Object new_value
, old_value
;
3368 compute_fringe_widths (f
, 1);
3372 x_set_border_width (f
, arg
, oldval
)
3374 Lisp_Object arg
, oldval
;
3378 if (XINT (arg
) == f
->border_width
)
3382 if (FRAME_X_WINDOW (f
) != 0)
3383 error ("Cannot change the border width of a window");
3384 #endif /* MAC_TODO */
3386 f
->border_width
= XINT (arg
);
3390 x_set_internal_border_width (f
, arg
, oldval
)
3392 Lisp_Object arg
, oldval
;
3394 int old
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3397 FRAME_INTERNAL_BORDER_WIDTH (f
) = XINT (arg
);
3398 if (FRAME_INTERNAL_BORDER_WIDTH (f
) < 0)
3399 FRAME_INTERNAL_BORDER_WIDTH (f
) = 0;
3401 #ifdef USE_X_TOOLKIT
3402 if (FRAME_X_OUTPUT (f
)->edit_widget
)
3403 widget_store_internal_border (FRAME_X_OUTPUT (f
)->edit_widget
);
3406 if (FRAME_INTERNAL_BORDER_WIDTH (f
) == old
)
3409 if (FRAME_X_WINDOW (f
) != 0)
3411 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3412 SET_FRAME_GARBAGED (f
);
3413 do_pending_window_change (0);
3416 SET_FRAME_GARBAGED (f
);
3420 x_set_visibility (f
, value
, oldval
)
3422 Lisp_Object value
, oldval
;
3425 XSETFRAME (frame
, f
);
3428 Fmake_frame_invisible (frame
, Qt
);
3429 else if (EQ (value
, Qicon
))
3430 Ficonify_frame (frame
);
3432 Fmake_frame_visible (frame
);
3436 x_set_autoraise (f
, arg
, oldval
)
3438 Lisp_Object arg
, oldval
;
3440 f
->auto_raise
= !EQ (Qnil
, arg
);
3444 x_set_autolower (f
, arg
, oldval
)
3446 Lisp_Object arg
, oldval
;
3448 f
->auto_lower
= !EQ (Qnil
, arg
);
3452 x_set_unsplittable (f
, arg
, oldval
)
3454 Lisp_Object arg
, oldval
;
3456 f
->no_split
= !NILP (arg
);
3460 x_set_vertical_scroll_bars (f
, arg
, oldval
)
3462 Lisp_Object arg
, oldval
;
3464 if ((EQ (arg
, Qleft
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
3465 || (EQ (arg
, Qright
) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f
))
3466 || (NILP (arg
) && FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3467 || (!NILP (arg
) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f
)))
3469 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
)
3471 ? vertical_scroll_bar_none
3473 ? vertical_scroll_bar_left
3475 ? vertical_scroll_bar_right
3476 : EQ (Qleft
, Vdefault_frame_scroll_bars
)
3477 ? vertical_scroll_bar_left
3478 : EQ (Qright
, Vdefault_frame_scroll_bars
)
3479 ? vertical_scroll_bar_right
3480 : vertical_scroll_bar_none
);
3482 /* We set this parameter before creating the X window for the
3483 frame, so we can get the geometry right from the start.
3484 However, if the window hasn't been created yet, we shouldn't
3485 call x_set_window_size. */
3486 if (FRAME_X_WINDOW (f
))
3487 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3488 do_pending_window_change (0);
3493 x_set_scroll_bar_width (f
, arg
, oldval
)
3495 Lisp_Object arg
, oldval
;
3497 int wid
= FRAME_COLUMN_WIDTH (f
);
3501 x_set_scroll_bar_default_width (f
);
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);
3507 else if (INTEGERP (arg
) && XINT (arg
) > 0
3508 && XFASTINT (arg
) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f
))
3510 if (XFASTINT (arg
) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
3511 XSETINT (arg
, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
+ 1);
3513 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = XFASTINT (arg
);
3514 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (XFASTINT (arg
) + wid
-1) / wid
;
3515 if (FRAME_X_WINDOW (f
))
3516 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
3517 do_pending_window_change (0);
3520 change_frame_size (f
, 0, FRAME_COLS (f
), 0, 0, 0);
3521 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.hpos
= 0;
3522 XWINDOW (FRAME_SELECTED_WINDOW (f
))->cursor
.x
= 0;
3527 /* Return non-nil if frame F wants a bitmap icon. */
3535 tem
= assq_no_quit (Qicon_type
, f
->param_alist
);
3543 /* Subroutines of creating an X frame. */
3545 /* Make sure that Vx_resource_name is set to a reasonable value.
3546 Fix it up, or set it to `emacs' if it is too hopeless. */
3549 validate_x_resource_name ()
3552 /* Number of valid characters in the resource name. */
3554 /* Number of invalid characters in the resource name. */
3559 if (!STRINGP (Vx_resource_class
))
3560 Vx_resource_class
= build_string (EMACS_CLASS
);
3562 if (STRINGP (Vx_resource_name
))
3564 unsigned char *p
= SDATA (Vx_resource_name
);
3567 len
= SBYTES (Vx_resource_name
);
3569 /* Only letters, digits, - and _ are valid in resource names.
3570 Count the valid characters and count the invalid ones. */
3571 for (i
= 0; i
< len
; i
++)
3574 if (! ((c
>= 'a' && c
<= 'z')
3575 || (c
>= 'A' && c
<= 'Z')
3576 || (c
>= '0' && c
<= '9')
3577 || c
== '-' || c
== '_'))
3584 /* Not a string => completely invalid. */
3585 bad_count
= 5, good_count
= 0;
3587 /* If name is valid already, return. */
3591 /* If name is entirely invalid, or nearly so, use `emacs'. */
3593 || (good_count
== 1 && bad_count
> 0))
3595 Vx_resource_name
= build_string ("emacs");
3599 /* Name is partly valid. Copy it and replace the invalid characters
3600 with underscores. */
3602 Vx_resource_name
= new = Fcopy_sequence (Vx_resource_name
);
3604 for (i
= 0; i
< len
; i
++)
3606 int c
= SREF (new, i
);
3607 if (! ((c
>= 'a' && c
<= 'z')
3608 || (c
>= 'A' && c
<= 'Z')
3609 || (c
>= '0' && c
<= '9')
3610 || c
== '-' || c
== '_'))
3616 extern char *x_get_string_resource
P_ ((XrmDatabase
, char *, char *));
3617 extern Display_Info
*check_x_display_info
P_ ((Lisp_Object
));
3620 /* Get specified attribute from resource database RDB.
3621 See Fx_get_resource below for other parameters. */
3624 xrdb_get_resource (rdb
, attribute
, class, component
, subclass
)
3626 Lisp_Object attribute
, class, component
, subclass
;
3628 register char *value
;
3632 CHECK_STRING (attribute
);
3633 CHECK_STRING (class);
3635 if (!NILP (component
))
3636 CHECK_STRING (component
);
3637 if (!NILP (subclass
))
3638 CHECK_STRING (subclass
);
3639 if (NILP (component
) != NILP (subclass
))
3640 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3642 validate_x_resource_name ();
3644 /* Allocate space for the components, the dots which separate them,
3645 and the final '\0'. Make them big enough for the worst case. */
3646 name_key
= (char *) alloca (SBYTES (Vx_resource_name
)
3647 + (STRINGP (component
)
3648 ? SBYTES (component
) : 0)
3649 + SBYTES (attribute
)
3652 class_key
= (char *) alloca (SBYTES (Vx_resource_class
)
3654 + (STRINGP (subclass
)
3655 ? SBYTES (subclass
) : 0)
3658 /* Start with emacs.FRAMENAME for the name (the specific one)
3659 and with `Emacs' for the class key (the general one). */
3660 strcpy (name_key
, SDATA (Vx_resource_name
));
3661 strcpy (class_key
, SDATA (Vx_resource_class
));
3663 strcat (class_key
, ".");
3664 strcat (class_key
, SDATA (class));
3666 if (!NILP (component
))
3668 strcat (class_key
, ".");
3669 strcat (class_key
, SDATA (subclass
));
3671 strcat (name_key
, ".");
3672 strcat (name_key
, SDATA (component
));
3675 strcat (name_key
, ".");
3676 strcat (name_key
, SDATA (attribute
));
3678 value
= x_get_string_resource (rdb
, name_key
, class_key
);
3680 if (value
!= (char *) 0)
3681 return build_string (value
);
3687 DEFUN ("x-get-resource", Fx_get_resource
, Sx_get_resource
, 2, 4, 0,
3688 doc
: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
3689 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
3690 class, where INSTANCE is the name under which Emacs was invoked, or
3691 the name specified by the `-name' or `-rn' command-line arguments.
3693 The optional arguments COMPONENT and SUBCLASS add to the key and the
3694 class, respectively. You must specify both of them or neither.
3695 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
3696 and the class is `Emacs.CLASS.SUBCLASS'. */)
3697 (attribute
, class, component
, subclass
)
3698 Lisp_Object attribute
, class, component
, subclass
;
3700 #ifdef HAVE_X_WINDOWS
3704 return xrdb_get_resource (check_x_display_info (Qnil
)->xrdb
,
3705 attribute
, class, component
, subclass
);
3708 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
3711 display_x_get_resource (dpyinfo
, attribute
, class, component
, subclass
)
3712 Display_Info
*dpyinfo
;
3713 Lisp_Object attribute
, class, component
, subclass
;
3715 return xrdb_get_resource (dpyinfo
->xrdb
,
3716 attribute
, class, component
, subclass
);
3719 /* Used when C code wants a resource value. */
3722 x_get_resource_string (attribute
, class)
3723 char *attribute
, *class;
3727 struct frame
*sf
= SELECTED_FRAME ();
3729 /* Allocate space for the components, the dots which separate them,
3730 and the final '\0'. */
3731 name_key
= (char *) alloca (SBYTES (Vinvocation_name
)
3732 + strlen (attribute
) + 2);
3733 class_key
= (char *) alloca ((sizeof (EMACS_CLASS
) - 1)
3734 + strlen (class) + 2);
3736 sprintf (name_key
, "%s.%s", SDATA (Vinvocation_name
), attribute
);
3737 sprintf (class_key
, "%s.%s", EMACS_CLASS
, class);
3739 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf
)->xrdb
,
3740 name_key
, class_key
);
3744 /* Return the value of parameter PARAM.
3746 First search ALIST, then Vdefault_frame_alist, then the X defaults
3747 database, using ATTRIBUTE as the attribute name and CLASS as its class.
3749 Convert the resource to the type specified by desired_type.
3751 If no default is specified, return Qunbound. If you call
3752 x_get_arg, make sure you deal with Qunbound in a reasonable way,
3753 and don't let it get stored in any Lisp-visible variables! */
3756 x_get_arg (dpyinfo
, alist
, param
, attribute
, class, type
)
3757 Display_Info
*dpyinfo
;
3758 Lisp_Object alist
, param
;
3761 enum resource_types type
;
3763 register Lisp_Object tem
;
3765 tem
= Fassq (param
, alist
);
3767 tem
= Fassq (param
, Vdefault_frame_alist
);
3772 tem
= display_x_get_resource (dpyinfo
,
3773 build_string (attribute
),
3774 build_string (class),
3782 case RES_TYPE_NUMBER
:
3783 return make_number (atoi (SDATA (tem
)));
3785 case RES_TYPE_FLOAT
:
3786 return make_float (atof (SDATA (tem
)));
3788 case RES_TYPE_BOOLEAN
:
3789 tem
= Fdowncase (tem
);
3790 if (!strcmp (SDATA (tem
), "on")
3791 || !strcmp (SDATA (tem
), "true"))
3796 case RES_TYPE_STRING
:
3799 case RES_TYPE_SYMBOL
:
3800 /* As a special case, we map the values `true' and `on'
3801 to Qt, and `false' and `off' to Qnil. */
3804 lower
= Fdowncase (tem
);
3805 if (!strcmp (SDATA (lower
), "on")
3806 || !strcmp (SDATA (lower
), "true"))
3808 else if (!strcmp (SDATA (lower
), "off")
3809 || !strcmp (SDATA (lower
), "false"))
3812 return Fintern (tem
, Qnil
);
3826 x_frame_get_arg (f
, alist
, param
, attribute
, class, type
)
3828 Lisp_Object alist
, param
;
3831 enum resource_types type
;
3833 return x_get_arg (FRAME_X_DISPLAY_INFO (f
),
3834 alist
, param
, attribute
, class, type
);
3837 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
3840 x_frame_get_and_record_arg (f
, alist
, param
, attribute
, class, type
)
3842 Lisp_Object alist
, param
;
3845 enum resource_types type
;
3849 value
= x_get_arg (FRAME_X_DISPLAY_INFO (f
), alist
, param
,
3850 attribute
, class, type
);
3852 store_frame_param (f
, param
, value
);
3858 /* Record in frame F the specified or default value according to ALIST
3859 of the parameter named PROP (a Lisp symbol).
3860 If no value is specified for PROP, look for an X default for XPROP
3861 on the frame named NAME.
3862 If that is not found either, use the value DEFLT. */
3865 x_default_parameter (f
, alist
, prop
, deflt
, xprop
, xclass
, type
)
3872 enum resource_types type
;
3876 tem
= x_frame_get_arg (f
, alist
, prop
, xprop
, xclass
, type
);
3877 if (EQ (tem
, Qunbound
))
3879 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
3886 DEFUN ("x-parse-geometry", Fx_parse_geometry
, Sx_parse_geometry
, 1, 1, 0,
3887 doc
: /* Parse an X-style geometry string STRING.
3888 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
3889 The properties returned may include `top', `left', `height', and `width'.
3890 The value of `left' or `top' may be an integer,
3891 or a list (+ N) meaning N pixels relative to top/left corner,
3892 or a list (- N) meaning -N pixels relative to bottom/right corner. */)
3897 unsigned int width
, height
;
3900 CHECK_STRING (string
);
3902 geometry
= XParseGeometry ((char *) SDATA (string
),
3903 &x
, &y
, &width
, &height
);
3906 if (!!(geometry
& XValue
) != !!(geometry
& YValue
))
3907 error ("Must specify both x and y position, or neither");
3911 if (geometry
& XValue
)
3913 Lisp_Object element
;
3915 if (x
>= 0 && (geometry
& XNegative
))
3916 element
= Fcons (Qleft
, Fcons (Qminus
, Fcons (make_number (-x
), Qnil
)));
3917 else if (x
< 0 && ! (geometry
& XNegative
))
3918 element
= Fcons (Qleft
, Fcons (Qplus
, Fcons (make_number (x
), Qnil
)));
3920 element
= Fcons (Qleft
, make_number (x
));
3921 result
= Fcons (element
, result
);
3924 if (geometry
& YValue
)
3926 Lisp_Object element
;
3928 if (y
>= 0 && (geometry
& YNegative
))
3929 element
= Fcons (Qtop
, Fcons (Qminus
, Fcons (make_number (-y
), Qnil
)));
3930 else if (y
< 0 && ! (geometry
& YNegative
))
3931 element
= Fcons (Qtop
, Fcons (Qplus
, Fcons (make_number (y
), Qnil
)));
3933 element
= Fcons (Qtop
, make_number (y
));
3934 result
= Fcons (element
, result
);
3937 if (geometry
& WidthValue
)
3938 result
= Fcons (Fcons (Qwidth
, make_number (width
)), result
);
3939 if (geometry
& HeightValue
)
3940 result
= Fcons (Fcons (Qheight
, make_number (height
)), result
);
3945 /* Calculate the desired size and position of frame F.
3946 Return the flags saying which aspects were specified.
3948 Also set the win_gravity and size_hint_flags of F.
3950 Adjust height for toolbar if TOOLBAR_P is 1.
3952 This function does not make the coordinates positive. */
3954 #define DEFAULT_ROWS 40
3955 #define DEFAULT_COLS 80
3958 x_figure_window_size (f
, parms
, toolbar_p
)
3963 register Lisp_Object tem0
, tem1
, tem2
;
3964 long window_prompting
= 0;
3965 Display_Info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3967 /* Default values if we fall through.
3968 Actually, if that happens we should get
3969 window manager prompting. */
3970 SET_FRAME_COLS (f
, DEFAULT_COLS
);
3971 FRAME_LINES (f
) = DEFAULT_ROWS
;
3972 /* Window managers expect that if program-specified
3973 positions are not (0,0), they're intentional, not defaults. */
3977 /* Ensure that old new_text_cols and new_text_lines will not override the
3979 /* ++KFS: This was specific to W32, but seems ok for all platforms */
3980 f
->new_text_cols
= f
->new_text_lines
= 0;
3982 tem0
= x_get_arg (dpyinfo
, parms
, Qheight
, 0, 0, RES_TYPE_NUMBER
);
3983 tem1
= x_get_arg (dpyinfo
, parms
, Qwidth
, 0, 0, RES_TYPE_NUMBER
);
3984 tem2
= x_get_arg (dpyinfo
, parms
, Quser_size
, 0, 0, RES_TYPE_NUMBER
);
3985 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
3987 if (!EQ (tem0
, Qunbound
))
3989 CHECK_NUMBER (tem0
);
3990 FRAME_LINES (f
) = XINT (tem0
);
3992 if (!EQ (tem1
, Qunbound
))
3994 CHECK_NUMBER (tem1
);
3995 SET_FRAME_COLS (f
, XINT (tem1
));
3997 if (!NILP (tem2
) && !EQ (tem2
, Qunbound
))
3998 window_prompting
|= USSize
;
4000 window_prompting
|= PSize
;
4003 f
->scroll_bar_actual_width
4004 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
4006 /* This used to be done _before_ calling x_figure_window_size, but
4007 since the height is reset here, this was really a no-op. I
4008 assume that moving it here does what Gerd intended (although he
4009 no longer can remember what that was... ++KFS, 2003-03-25. */
4011 /* Add the tool-bar height to the initial frame height so that the
4012 user gets a text display area of the size he specified with -g or
4013 via .Xdefaults. Later changes of the tool-bar height don't
4014 change the frame size. This is done so that users can create
4015 tall Emacs frames without having to guess how tall the tool-bar
4017 if (toolbar_p
&& FRAME_TOOL_BAR_LINES (f
))
4019 int margin
, relief
, bar_height
;
4021 relief
= (tool_bar_button_relief
>= 0
4022 ? tool_bar_button_relief
4023 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
);
4025 if (INTEGERP (Vtool_bar_button_margin
)
4026 && XINT (Vtool_bar_button_margin
) > 0)
4027 margin
= XFASTINT (Vtool_bar_button_margin
);
4028 else if (CONSP (Vtool_bar_button_margin
)
4029 && INTEGERP (XCDR (Vtool_bar_button_margin
))
4030 && XINT (XCDR (Vtool_bar_button_margin
)) > 0)
4031 margin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4035 bar_height
= DEFAULT_TOOL_BAR_IMAGE_HEIGHT
+ 2 * margin
+ 2 * relief
;
4036 FRAME_LINES (f
) += (bar_height
+ FRAME_LINE_HEIGHT (f
) - 1) / FRAME_LINE_HEIGHT (f
);
4039 compute_fringe_widths (f
, 0);
4041 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, FRAME_COLS (f
));
4042 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4044 tem0
= x_get_arg (dpyinfo
, parms
, Qtop
, 0, 0, RES_TYPE_NUMBER
);
4045 tem1
= x_get_arg (dpyinfo
, parms
, Qleft
, 0, 0, RES_TYPE_NUMBER
);
4046 tem2
= x_get_arg (dpyinfo
, parms
, Quser_position
, 0, 0, RES_TYPE_NUMBER
);
4047 if (! EQ (tem0
, Qunbound
) || ! EQ (tem1
, Qunbound
))
4049 if (EQ (tem0
, Qminus
))
4052 window_prompting
|= YNegative
;
4054 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qminus
)
4055 && CONSP (XCDR (tem0
))
4056 && INTEGERP (XCAR (XCDR (tem0
))))
4058 f
->top_pos
= - XINT (XCAR (XCDR (tem0
)));
4059 window_prompting
|= YNegative
;
4061 else if (CONSP (tem0
) && EQ (XCAR (tem0
), Qplus
)
4062 && CONSP (XCDR (tem0
))
4063 && INTEGERP (XCAR (XCDR (tem0
))))
4065 f
->top_pos
= XINT (XCAR (XCDR (tem0
)));
4067 else if (EQ (tem0
, Qunbound
))
4071 CHECK_NUMBER (tem0
);
4072 f
->top_pos
= XINT (tem0
);
4074 window_prompting
|= YNegative
;
4077 if (EQ (tem1
, Qminus
))
4080 window_prompting
|= XNegative
;
4082 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qminus
)
4083 && CONSP (XCDR (tem1
))
4084 && INTEGERP (XCAR (XCDR (tem1
))))
4086 f
->left_pos
= - XINT (XCAR (XCDR (tem1
)));
4087 window_prompting
|= XNegative
;
4089 else if (CONSP (tem1
) && EQ (XCAR (tem1
), Qplus
)
4090 && CONSP (XCDR (tem1
))
4091 && INTEGERP (XCAR (XCDR (tem1
))))
4093 f
->left_pos
= XINT (XCAR (XCDR (tem1
)));
4095 else if (EQ (tem1
, Qunbound
))
4099 CHECK_NUMBER (tem1
);
4100 f
->left_pos
= XINT (tem1
);
4101 if (f
->left_pos
< 0)
4102 window_prompting
|= XNegative
;
4105 if (!NILP (tem2
) && ! EQ (tem2
, Qunbound
))
4106 window_prompting
|= USPosition
;
4108 window_prompting
|= PPosition
;
4111 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
4116 /* It takes both for some WM:s to place it where we want */
4117 window_prompting
= USPosition
| PPosition
;
4118 x_fullscreen_adjust (f
, &width
, &height
, &top
, &left
);
4119 FRAME_COLS (f
) = width
;
4120 FRAME_LINES (f
) = height
;
4121 FRAME_PIXEL_WIDTH (f
) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
4122 FRAME_PIXEL_HEIGHT (f
) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
4127 if (window_prompting
& XNegative
)
4129 if (window_prompting
& YNegative
)
4130 f
->win_gravity
= SouthEastGravity
;
4132 f
->win_gravity
= NorthEastGravity
;
4136 if (window_prompting
& YNegative
)
4137 f
->win_gravity
= SouthWestGravity
;
4139 f
->win_gravity
= NorthWestGravity
;
4142 f
->size_hint_flags
= window_prompting
;
4144 return window_prompting
;
4149 #endif /* HAVE_WINDOW_SYSTEM */
4153 /***********************************************************************
4155 ***********************************************************************/
4160 Qframep
= intern ("framep");
4161 staticpro (&Qframep
);
4162 Qframe_live_p
= intern ("frame-live-p");
4163 staticpro (&Qframe_live_p
);
4164 Qheight
= intern ("height");
4165 staticpro (&Qheight
);
4166 Qicon
= intern ("icon");
4168 Qminibuffer
= intern ("minibuffer");
4169 staticpro (&Qminibuffer
);
4170 Qmodeline
= intern ("modeline");
4171 staticpro (&Qmodeline
);
4172 Qonly
= intern ("only");
4174 Qwidth
= intern ("width");
4175 staticpro (&Qwidth
);
4176 Qgeometry
= intern ("geometry");
4177 staticpro (&Qgeometry
);
4178 Qicon_left
= intern ("icon-left");
4179 staticpro (&Qicon_left
);
4180 Qicon_top
= intern ("icon-top");
4181 staticpro (&Qicon_top
);
4182 Qleft
= intern ("left");
4184 Qright
= intern ("right");
4185 staticpro (&Qright
);
4186 Quser_position
= intern ("user-position");
4187 staticpro (&Quser_position
);
4188 Quser_size
= intern ("user-size");
4189 staticpro (&Quser_size
);
4190 Qwindow_id
= intern ("window-id");
4191 staticpro (&Qwindow_id
);
4192 #ifdef HAVE_X_WINDOWS
4193 Qouter_window_id
= intern ("outer-window-id");
4194 staticpro (&Qouter_window_id
);
4196 Qparent_id
= intern ("parent-id");
4197 staticpro (&Qparent_id
);
4200 Qw32
= intern ("w32");
4202 Qpc
= intern ("pc");
4204 Qmac
= intern ("mac");
4206 Qvisible
= intern ("visible");
4207 staticpro (&Qvisible
);
4208 Qbuffer_predicate
= intern ("buffer-predicate");
4209 staticpro (&Qbuffer_predicate
);
4210 Qbuffer_list
= intern ("buffer-list");
4211 staticpro (&Qbuffer_list
);
4212 Qdisplay_type
= intern ("display-type");
4213 staticpro (&Qdisplay_type
);
4214 Qbackground_mode
= intern ("background-mode");
4215 staticpro (&Qbackground_mode
);
4216 Qtty_color_mode
= intern ("tty-color-mode");
4217 staticpro (&Qtty_color_mode
);
4218 Qtty
= intern ("tty");
4220 Qtty_type
= intern ("tty-type");
4221 staticpro (&Qtty_type
);
4222 Qwindow_system
= intern ("window-system");
4223 staticpro (&Qwindow_system
);
4225 Qface_set_after_frame_default
= intern ("face-set-after-frame-default");
4226 staticpro (&Qface_set_after_frame_default
);
4228 Qfullwidth
= intern ("fullwidth");
4229 staticpro (&Qfullwidth
);
4230 Qfullheight
= intern ("fullheight");
4231 staticpro (&Qfullheight
);
4232 Qfullboth
= intern ("fullboth");
4233 staticpro (&Qfullboth
);
4234 Qx_resource_name
= intern ("x-resource-name");
4235 staticpro (&Qx_resource_name
);
4237 Qx_frame_parameter
= intern ("x-frame-parameter");
4238 staticpro (&Qx_frame_parameter
);
4240 Qdisplay_id
= intern ("display-id");
4241 staticpro (&Qdisplay_id
);
4242 Qdisplay_live_p
= intern ("display-live-p");
4243 staticpro (&Qdisplay_live_p
);
4248 for (i
= 0; i
< sizeof (frame_parms
) / sizeof (frame_parms
[0]); i
++)
4250 Lisp_Object v
= intern (frame_parms
[i
].name
);
4251 if (frame_parms
[i
].variable
)
4253 *frame_parms
[i
].variable
= v
;
4254 staticpro (frame_parms
[i
].variable
);
4256 Fput (v
, Qx_frame_parameter
, make_number (i
));
4260 #ifdef HAVE_WINDOW_SYSTEM
4261 DEFVAR_LISP ("x-resource-name", &Vx_resource_name
,
4262 doc
: /* The name Emacs uses to look up X resources.
4263 `x-get-resource' uses this as the first component of the instance name
4264 when requesting resource values.
4265 Emacs initially sets `x-resource-name' to the name under which Emacs
4266 was invoked, or to the value specified with the `-name' or `-rn'
4267 switches, if present.
4269 It may be useful to bind this variable locally around a call
4270 to `x-get-resource'. See also the variable `x-resource-class'. */);
4271 Vx_resource_name
= Qnil
;
4273 DEFVAR_LISP ("x-resource-class", &Vx_resource_class
,
4274 doc
: /* The class Emacs uses to look up X resources.
4275 `x-get-resource' uses this as the first component of the instance class
4276 when requesting resource values.
4278 Emacs initially sets `x-resource-class' to "Emacs".
4280 Setting this variable permanently is not a reasonable thing to do,
4281 but binding this variable locally around a call to `x-get-resource'
4282 is a reasonable practice. See also the variable `x-resource-name'. */);
4283 Vx_resource_class
= build_string (EMACS_CLASS
);
4286 DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist
,
4287 doc
: /* Alist of default values for frame creation.
4288 These may be set in your init file, like this:
4289 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
4290 These override values given in window system configuration data,
4291 including X Windows' defaults database.
4292 For values specific to the first Emacs frame, see `initial-frame-alist'.
4293 For values specific to the separate minibuffer frame, see
4294 `minibuffer-frame-alist'.
4295 The `menu-bar-lines' element of the list controls whether new frames
4296 have menu bars; `menu-bar-mode' works by altering this element.
4297 Setting this variable does not affect existing frames, only new ones. */);
4298 Vdefault_frame_alist
= Qnil
;
4300 DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars
,
4301 doc
: /* Default position of scroll bars on this window-system. */);
4302 #ifdef HAVE_WINDOW_SYSTEM
4303 #if defined(HAVE_NTGUI) || defined(HAVE_CARBON)
4304 /* MS-Windows has scroll bars on the right by default. */
4305 Vdefault_frame_scroll_bars
= Qright
;
4307 Vdefault_frame_scroll_bars
= Qleft
;
4310 Vdefault_frame_scroll_bars
= Qnil
;
4313 Qinhibit_default_face_x_resources
4314 = intern ("inhibit-default-face-x-resources");
4315 staticpro (&Qinhibit_default_face_x_resources
);
4317 DEFVAR_LISP ("terminal-frame", &Vterminal_frame
,
4318 doc
: /* The initial frame-object, which represents Emacs's stdout. */);
4320 DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified
,
4321 doc
: /* Non-nil if all of emacs is iconified and frame updates are not needed. */);
4322 Vemacs_iconified
= Qnil
;
4324 DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function
,
4325 doc
: /* If non-nil, function to transform normal value of `mouse-position'.
4326 `mouse-position' calls this function, passing its usual return value as
4327 argument, and returns whatever this function returns.
4328 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
4329 which need to do mouse handling at the Lisp level. */);
4330 Vmouse_position_function
= Qnil
;
4332 DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight
,
4333 doc
: /* If non-nil, clickable text is highlighted when mouse is over it.
4334 If the value is an integer, highlighting is only shown after moving the
4335 mouse, while keyboard input turns off the highlight even when the mouse
4336 is over the clickable text. However, the mouse shape still indicates
4337 when the mouse is over clickable text. */);
4338 Vmouse_highlight
= Qt
;
4340 DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions
,
4341 doc
: /* Functions to be run before deleting a frame.
4342 The functions are run with one arg, the frame to be deleted.
4343 See `delete-frame'. */);
4344 Vdelete_frame_functions
= Qnil
;
4346 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame
,
4347 doc
: /* Minibufferless frames use this frame's minibuffer.
4349 Emacs cannot create minibufferless frames unless this is set to an
4350 appropriate surrogate.
4352 Emacs consults this variable only when creating minibufferless
4353 frames; once the frame is created, it sticks with its assigned
4354 minibuffer, no matter what this variable is set to. This means that
4355 this variable doesn't necessarily say anything meaningful about the
4356 current set of frames, or where the minibuffer is currently being
4359 This variable is local to the current terminal and cannot be buffer-local. */);
4361 staticpro (&Vframe_list
);
4363 defsubr (&Sactive_minibuffer_window
);
4365 defsubr (&Sframe_live_p
);
4366 defsubr (&Swindow_system
);
4367 defsubr (&Smake_terminal_frame
);
4368 defsubr (&Shandle_switch_frame
);
4369 defsubr (&Signore_event
);
4370 defsubr (&Sselect_frame
);
4371 defsubr (&Sselected_frame
);
4372 defsubr (&Swindow_frame
);
4373 defsubr (&Sframe_root_window
);
4374 defsubr (&Sframe_first_window
);
4375 defsubr (&Sframe_selected_window
);
4376 defsubr (&Sset_frame_selected_window
);
4377 defsubr (&Sframe_display
);
4378 defsubr (&Sframe_list
);
4379 defsubr (&Snext_frame
);
4380 defsubr (&Sprevious_frame
);
4381 defsubr (&Sdelete_frame
);
4382 defsubr (&Smouse_position
);
4383 defsubr (&Smouse_pixel_position
);
4384 defsubr (&Sset_mouse_position
);
4385 defsubr (&Sset_mouse_pixel_position
);
4387 defsubr (&Sframe_configuration
);
4388 defsubr (&Srestore_frame_configuration
);
4390 defsubr (&Smake_frame_visible
);
4391 defsubr (&Smake_frame_invisible
);
4392 defsubr (&Siconify_frame
);
4393 defsubr (&Sframe_visible_p
);
4394 defsubr (&Svisible_frame_list
);
4395 defsubr (&Sraise_frame
);
4396 defsubr (&Slower_frame
);
4397 defsubr (&Sredirect_frame_focus
);
4398 defsubr (&Sframe_focus
);
4399 defsubr (&Sframe_parameters
);
4400 defsubr (&Sframe_parameter
);
4401 defsubr (&Smodify_frame_parameters
);
4402 defsubr (&Sframe_char_height
);
4403 defsubr (&Sframe_char_width
);
4404 defsubr (&Sframe_pixel_height
);
4405 defsubr (&Sframe_pixel_width
);
4406 defsubr (&Sset_frame_height
);
4407 defsubr (&Sset_frame_width
);
4408 defsubr (&Sset_frame_size
);
4409 defsubr (&Sset_frame_position
);
4411 #ifdef HAVE_WINDOW_SYSTEM
4412 defsubr (&Sx_get_resource
);
4413 defsubr (&Sx_parse_geometry
);
4418 /* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
4419 (do not change this comment) */