(increment-calendar-month): Doc fix.
[emacs.git] / src / frame.c
blob81b91924d2f0e2bbf29f81acaedc94cfe03154a2
1 /* Generic frame functions.
2 Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003,
3 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 #include <config.h>
24 #include <stdio.h>
25 #include "lisp.h"
26 #include "character.h"
27 #ifdef HAVE_X_WINDOWS
28 #include "xterm.h"
29 #endif
30 #ifdef WINDOWSNT
31 #include "w32term.h"
32 #endif
33 #ifdef MAC_OS
34 #include "macterm.h"
35 #endif
36 #include "buffer.h"
37 /* These help us bind and responding to switch-frame events. */
38 #include "commands.h"
39 #include "keyboard.h"
40 #include "frame.h"
41 #ifdef HAVE_WINDOW_SYSTEM
42 #include "fontset.h"
43 #endif
44 #include "blockinput.h"
45 #include "termchar.h"
46 #include "termhooks.h"
47 #include "dispextern.h"
48 #include "window.h"
49 #ifdef MSDOS
50 #include "msdos.h"
51 #include "dosfns.h"
52 #endif
55 #ifdef HAVE_WINDOW_SYSTEM
57 #ifdef USE_FONT_BACKEND
58 #include "font.h"
59 #endif /* USE_FONT_BACKEND */
61 /* The name we're using in resource queries. Most often "emacs". */
63 Lisp_Object Vx_resource_name;
65 /* The application class we're using in resource queries.
66 Normally "Emacs". */
68 Lisp_Object Vx_resource_class;
70 #endif
72 Lisp_Object Qframep, Qframe_live_p;
73 Lisp_Object Qicon, Qmodeline;
74 Lisp_Object Qonly;
75 Lisp_Object Qx, Qw32, Qmac, Qpc;
76 Lisp_Object Qvisible;
77 Lisp_Object Qdisplay_type;
78 Lisp_Object Qbackground_mode;
79 Lisp_Object Qnoelisp;
81 Lisp_Object Qx_frame_parameter;
82 Lisp_Object Qx_resource_name;
83 Lisp_Object Qterminal;
84 Lisp_Object Qterminal_live_p;
86 /* Frame parameters (set or reported). */
88 Lisp_Object Qauto_raise, Qauto_lower;
89 Lisp_Object Qborder_color, Qborder_width;
90 Lisp_Object Qcursor_color, Qcursor_type;
91 Lisp_Object Qgeometry; /* Not used */
92 Lisp_Object Qheight, Qwidth;
93 Lisp_Object Qleft, Qright;
94 Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
95 Lisp_Object Qinternal_border_width;
96 Lisp_Object Qmouse_color;
97 Lisp_Object Qminibuffer;
98 Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
99 Lisp_Object Qvisibility;
100 Lisp_Object Qscroll_bar_foreground, Qscroll_bar_background;
101 Lisp_Object Qscreen_gamma;
102 Lisp_Object Qline_spacing;
103 Lisp_Object Quser_position, Quser_size;
104 Lisp_Object Qwait_for_wm;
105 Lisp_Object Qwindow_id;
106 #ifdef HAVE_X_WINDOWS
107 Lisp_Object Qouter_window_id;
108 #endif
109 Lisp_Object Qparent_id;
110 Lisp_Object Qtitle, Qname;
111 Lisp_Object Qexplicit_name;
112 Lisp_Object Qunsplittable;
113 Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
114 Lisp_Object Qleft_fringe, Qright_fringe;
115 Lisp_Object Qbuffer_predicate, Qbuffer_list, Qburied_buffer_list;
116 Lisp_Object Qtty_color_mode;
117 Lisp_Object Qtty, Qtty_type;
119 Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth;
120 #ifdef USE_FONT_BACKEND
121 Lisp_Object Qfont_backend;
122 #endif /* USE_FONT_BACKEND */
124 Lisp_Object Qinhibit_face_set_after_frame_default;
125 Lisp_Object Qface_set_after_frame_default;
127 Lisp_Object Vterminal_frame;
128 Lisp_Object Vdefault_frame_alist;
129 Lisp_Object Vdefault_frame_scroll_bars;
130 Lisp_Object Vmouse_position_function;
131 Lisp_Object Vmouse_highlight;
132 static Lisp_Object Vdelete_frame_functions, Qdelete_frame_functions;
134 int focus_follows_mouse;
136 static void
137 set_menu_bar_lines_1 (window, n)
138 Lisp_Object window;
139 int n;
141 struct window *w = XWINDOW (window);
143 XSETFASTINT (w->last_modified, 0);
144 XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
145 XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
147 if (INTEGERP (w->orig_top_line))
148 XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
149 if (INTEGERP (w->orig_total_lines))
150 XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
152 /* Handle just the top child in a vertical split. */
153 if (!NILP (w->vchild))
154 set_menu_bar_lines_1 (w->vchild, n);
156 /* Adjust all children in a horizontal split. */
157 for (window = w->hchild; !NILP (window); window = w->next)
159 w = XWINDOW (window);
160 set_menu_bar_lines_1 (window, n);
164 void
165 set_menu_bar_lines (f, value, oldval)
166 struct frame *f;
167 Lisp_Object value, oldval;
169 int nlines;
170 int olines = FRAME_MENU_BAR_LINES (f);
172 /* Right now, menu bars don't work properly in minibuf-only frames;
173 most of the commands try to apply themselves to the minibuffer
174 frame itself, and get an error because you can't switch buffers
175 in or split the minibuffer window. */
176 if (FRAME_MINIBUF_ONLY_P (f))
177 return;
179 if (INTEGERP (value))
180 nlines = XINT (value);
181 else
182 nlines = 0;
184 if (nlines != olines)
186 windows_or_buffers_changed++;
187 FRAME_WINDOW_SIZES_CHANGED (f) = 1;
188 FRAME_MENU_BAR_LINES (f) = nlines;
189 set_menu_bar_lines_1 (f->root_window, nlines - olines);
190 adjust_glyphs (f);
194 Lisp_Object Vemacs_iconified;
195 Lisp_Object Vframe_list;
197 extern Lisp_Object Vminibuffer_list;
198 extern Lisp_Object get_minibuffer ();
199 extern Lisp_Object Fhandle_switch_frame ();
200 extern Lisp_Object Fredirect_frame_focus ();
201 extern Lisp_Object x_get_focus_frame ();
203 DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
204 doc: /* Return non-nil if OBJECT is a frame.
205 Value is t for a termcap frame (a character-only terminal),
206 `x' for an Emacs frame that is really an X window,
207 `w32' for an Emacs frame that is a window on MS-Windows display,
208 `mac' for an Emacs frame on a Macintosh display,
209 `pc' for a direct-write MS-DOS frame.
210 See also `frame-live-p'. */)
211 (object)
212 Lisp_Object object;
214 if (!FRAMEP (object))
215 return Qnil;
216 switch (XFRAME (object)->output_method)
218 case output_initial: /* The initial frame is like a termcap frame. */
219 case output_termcap:
220 return Qt;
221 case output_x_window:
222 return Qx;
223 case output_w32:
224 return Qw32;
225 case output_msdos_raw:
226 return Qpc;
227 case output_mac:
228 return Qmac;
229 default:
230 abort ();
234 DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
235 doc: /* Return non-nil if OBJECT is a frame which has not been deleted.
236 Value is nil if OBJECT is not a live frame. If object is a live
237 frame, the return value indicates what sort of terminal device it is
238 displayed on. See the documentation of `framep' for possible
239 return values. */)
240 (object)
241 Lisp_Object object;
243 return ((FRAMEP (object)
244 && FRAME_LIVE_P (XFRAME (object)))
245 ? Fframep (object)
246 : Qnil);
249 DEFUN ("window-system", Fwindow_system, Swindow_system, 0, 1, 0,
250 doc: /* The name of the window system that FRAME is displaying through.
251 The value is a symbol---for instance, 'x' for X windows.
252 The value is nil if Emacs is using a text-only terminal.
254 FRAME defaults to the currently selected frame. */)
255 (frame)
256 Lisp_Object frame;
258 Lisp_Object type;
259 if (NILP (frame))
260 frame = selected_frame;
262 type = Fframep (frame);
264 if (NILP (type))
265 wrong_type_argument (Qframep, frame);
267 if (EQ (type, Qt))
268 return Qnil;
269 else
270 return type;
273 struct frame *
274 make_frame (mini_p)
275 int mini_p;
277 Lisp_Object frame;
278 register struct frame *f;
279 register Lisp_Object root_window;
280 register Lisp_Object mini_window;
282 f = allocate_frame ();
283 XSETFRAME (frame, f);
285 f->desired_matrix = 0;
286 f->current_matrix = 0;
287 f->desired_pool = 0;
288 f->current_pool = 0;
289 f->glyphs_initialized_p = 0;
290 f->decode_mode_spec_buffer = 0;
291 f->visible = 0;
292 f->async_visible = 0;
293 f->output_data.nothing = 0;
294 f->iconified = 0;
295 f->async_iconified = 0;
296 f->wants_modeline = 1;
297 f->auto_raise = 0;
298 f->auto_lower = 0;
299 f->no_split = 0;
300 f->garbaged = 1;
301 f->has_minibuffer = mini_p;
302 f->focus_frame = Qnil;
303 f->explicit_name = 0;
304 f->can_have_scroll_bars = 0;
305 f->vertical_scroll_bar_type = vertical_scroll_bar_none;
306 f->param_alist = Qnil;
307 f->scroll_bars = Qnil;
308 f->condemned_scroll_bars = Qnil;
309 f->face_alist = Qnil;
310 f->face_cache = NULL;
311 f->menu_bar_items = Qnil;
312 f->menu_bar_vector = Qnil;
313 f->menu_bar_items_used = 0;
314 f->buffer_predicate = Qnil;
315 f->buffer_list = Qnil;
316 f->buried_buffer_list = Qnil;
317 f->namebuf = 0;
318 f->title = Qnil;
319 f->menu_bar_window = Qnil;
320 f->tool_bar_window = Qnil;
321 f->tool_bar_items = Qnil;
322 f->desired_tool_bar_string = f->current_tool_bar_string = Qnil;
323 f->n_tool_bar_items = 0;
324 f->left_fringe_width = f->right_fringe_width = 0;
325 f->fringe_cols = 0;
326 f->scroll_bar_actual_width = 0;
327 f->border_width = 0;
328 f->internal_border_width = 0;
329 f->column_width = 1; /* !FRAME_WINDOW_P value */
330 f->line_height = 1; /* !FRAME_WINDOW_P value */
331 f->x_pixels_diff = f->y_pixels_diff = 0;
332 #ifdef HAVE_WINDOW_SYSTEM
333 f->want_fullscreen = FULLSCREEN_NONE;
334 #endif
335 f->size_hint_flags = 0;
336 f->win_gravity = 0;
337 #ifdef USE_FONT_BACKEND
338 f->font_driver_list = NULL;
339 f->font_data_list = NULL;
340 #endif /* USE_FONT_BACKEND */
342 root_window = make_window ();
343 if (mini_p)
345 mini_window = make_window ();
346 XWINDOW (root_window)->next = mini_window;
347 XWINDOW (mini_window)->prev = root_window;
348 XWINDOW (mini_window)->mini_p = Qt;
349 XWINDOW (mini_window)->frame = frame;
350 f->minibuffer_window = mini_window;
352 else
354 mini_window = Qnil;
355 XWINDOW (root_window)->next = Qnil;
356 f->minibuffer_window = Qnil;
359 XWINDOW (root_window)->frame = frame;
361 /* 10 is arbitrary,
362 just so that there is "something there."
363 Correct size will be set up later with change_frame_size. */
365 SET_FRAME_COLS (f, 10);
366 FRAME_LINES (f) = 10;
368 XSETFASTINT (XWINDOW (root_window)->total_cols, 10);
369 XSETFASTINT (XWINDOW (root_window)->total_lines, (mini_p ? 9 : 10));
371 if (mini_p)
373 XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
374 XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
375 XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
378 /* Choose a buffer for the frame's root window. */
380 Lisp_Object buf;
382 XWINDOW (root_window)->buffer = Qt;
383 buf = Fcurrent_buffer ();
384 /* If buf is a 'hidden' buffer (i.e. one whose name starts with
385 a space), try to find another one. */
386 if (SREF (Fbuffer_name (buf), 0) == ' ')
387 buf = Fother_buffer (buf, Qnil, Qnil);
389 /* Use set_window_buffer, not Fset_window_buffer, and don't let
390 hooks be run by it. The reason is that the whole frame/window
391 arrangement is not yet fully intialized at this point. Windows
392 don't have the right size, glyph matrices aren't initialized
393 etc. Running Lisp functions at this point surely ends in a
394 SEGV. */
395 set_window_buffer (root_window, buf, 0, 0);
396 f->buffer_list = Fcons (buf, Qnil);
399 if (mini_p)
401 XWINDOW (mini_window)->buffer = Qt;
402 set_window_buffer (mini_window,
403 (NILP (Vminibuffer_list)
404 ? get_minibuffer (0)
405 : Fcar (Vminibuffer_list)),
406 0, 0);
409 f->root_window = root_window;
410 f->selected_window = root_window;
411 /* Make sure this window seems more recently used than
412 a newly-created, never-selected window. */
413 ++window_select_count;
414 XSETFASTINT (XWINDOW (f->selected_window)->use_time, window_select_count);
416 f->default_face_done_p = 0;
418 return f;
421 #ifdef HAVE_WINDOW_SYSTEM
422 /* Make a frame using a separate minibuffer window on another frame.
423 MINI_WINDOW is the minibuffer window to use. nil means use the
424 default (the global minibuffer). */
426 struct frame *
427 make_frame_without_minibuffer (mini_window, kb, display)
428 register Lisp_Object mini_window;
429 KBOARD *kb;
430 Lisp_Object display;
432 register struct frame *f;
433 struct gcpro gcpro1;
435 if (!NILP (mini_window))
436 CHECK_LIVE_WINDOW (mini_window);
438 #ifdef MULTI_KBOARD
439 if (!NILP (mini_window)
440 && FRAME_KBOARD (XFRAME (XWINDOW (mini_window)->frame)) != kb)
441 error ("Frame and minibuffer must be on the same terminal");
442 #endif
444 /* Make a frame containing just a root window. */
445 f = make_frame (0);
447 if (NILP (mini_window))
449 /* Use default-minibuffer-frame if possible. */
450 if (!FRAMEP (kb->Vdefault_minibuffer_frame)
451 || ! FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame)))
453 Lisp_Object frame_dummy;
455 XSETFRAME (frame_dummy, f);
456 GCPRO1 (frame_dummy);
457 /* If there's no minibuffer frame to use, create one. */
458 kb->Vdefault_minibuffer_frame =
459 call1 (intern ("make-initial-minibuffer-frame"), display);
460 UNGCPRO;
463 mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
466 f->minibuffer_window = mini_window;
468 /* Make the chosen minibuffer window display the proper minibuffer,
469 unless it is already showing a minibuffer. */
470 if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
471 Fset_window_buffer (mini_window,
472 (NILP (Vminibuffer_list)
473 ? get_minibuffer (0)
474 : Fcar (Vminibuffer_list)), Qnil);
475 return f;
478 /* Make a frame containing only a minibuffer window. */
480 struct frame *
481 make_minibuffer_frame ()
483 /* First make a frame containing just a root window, no minibuffer. */
485 register struct frame *f = make_frame (0);
486 register Lisp_Object mini_window;
487 register Lisp_Object frame;
489 XSETFRAME (frame, f);
491 f->auto_raise = 0;
492 f->auto_lower = 0;
493 f->no_split = 1;
494 f->wants_modeline = 0;
495 f->has_minibuffer = 1;
497 /* Now label the root window as also being the minibuffer.
498 Avoid infinite looping on the window chain by marking next pointer
499 as nil. */
501 mini_window = f->minibuffer_window = f->root_window;
502 XWINDOW (mini_window)->mini_p = Qt;
503 XWINDOW (mini_window)->next = Qnil;
504 XWINDOW (mini_window)->prev = Qnil;
505 XWINDOW (mini_window)->frame = frame;
507 /* Put the proper buffer in that window. */
509 Fset_window_buffer (mini_window,
510 (NILP (Vminibuffer_list)
511 ? get_minibuffer (0)
512 : Fcar (Vminibuffer_list)), Qnil);
513 return f;
515 #endif /* HAVE_WINDOW_SYSTEM */
517 /* Construct a frame that refers to a terminal. */
519 static int tty_frame_count;
521 struct frame *
522 make_initial_frame (void)
524 struct frame *f;
525 struct terminal *terminal;
526 Lisp_Object frame;
528 eassert (initial_kboard);
530 /* The first call must initialize Vframe_list. */
531 if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
532 Vframe_list = Qnil;
534 terminal = init_initial_terminal ();
536 f = make_frame (1);
537 XSETFRAME (frame, f);
539 Vframe_list = Fcons (frame, Vframe_list);
541 tty_frame_count = 1;
542 f->name = build_string ("F1");
544 f->visible = 1;
545 f->async_visible = 1;
547 f->output_method = terminal->type;
548 f->terminal = terminal;
549 f->terminal->reference_count++;
550 f->output_data.nothing = 0;
552 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
553 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
555 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
556 FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
558 return f;
562 struct frame *
563 make_terminal_frame (struct terminal *terminal)
565 register struct frame *f;
566 Lisp_Object frame;
567 char name[20];
569 if (!terminal->name)
570 error ("Terminal is not live, can't create new frames on it");
572 f = make_frame (1);
574 XSETFRAME (frame, f);
575 Vframe_list = Fcons (frame, Vframe_list);
577 tty_frame_count++;
578 sprintf (name, "F%d", tty_frame_count);
579 f->name = build_string (name);
581 f->visible = 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
582 f->async_visible = 1; /* Don't let visible be cleared later. */
583 #ifdef MSDOS
584 f->output_data.x = &the_only_x_display;
585 if (!inhibit_window_system
586 && (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame))
587 || XFRAME (selected_frame)->output_method == output_msdos_raw))
589 f->output_method = output_msdos_raw;
590 /* This initialization of foreground and background pixels is
591 only important for the initial frame created in temacs. If
592 we don't do that, we get black background and foreground in
593 the dumped Emacs because the_only_x_display is a static
594 variable, hence it is born all-zeroes, and zero is the code
595 for the black color. Other frames all inherit their pixels
596 from what's already in the_only_x_display. */
597 if ((!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame)))
598 && FRAME_BACKGROUND_PIXEL (f) == 0
599 && FRAME_FOREGROUND_PIXEL (f) == 0)
601 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
602 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
605 else
606 f->output_method = output_termcap;
607 #else
609 f->output_method = output_termcap;
610 f->terminal = terminal;
611 f->terminal->reference_count++;
612 create_tty_output (f);
614 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
615 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
617 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
618 FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
620 /* Set the top frame to the newly created frame. */
621 if (FRAMEP (FRAME_TTY (f)->top_frame)
622 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
623 XFRAME (FRAME_TTY (f)->top_frame)->async_visible = 2; /* obscured */
625 FRAME_TTY (f)->top_frame = frame;
628 #ifdef CANNOT_DUMP
629 FRAME_FOREGROUND_PIXEL(f) = FACE_TTY_DEFAULT_FG_COLOR;
630 FRAME_BACKGROUND_PIXEL(f) = FACE_TTY_DEFAULT_BG_COLOR;
631 #endif
632 #endif /* MSDOS */
634 if (!noninteractive)
635 init_frame_faces (f);
637 return f;
640 /* Get a suitable value for frame parameter PARAMETER for a newly
641 created frame, based on (1) the user-supplied frame parameter
642 alist SUPPLIED_PARMS, (2) CURRENT_VALUE, and finally, if all else
643 fails, (3) Vdefault_frame_alist. */
645 static Lisp_Object
646 get_future_frame_param (Lisp_Object parameter,
647 Lisp_Object supplied_parms,
648 char *current_value)
650 Lisp_Object result;
652 result = Fassq (parameter, supplied_parms);
653 if (NILP (result))
654 result = Fassq (parameter, XFRAME (selected_frame)->param_alist);
655 if (NILP (result) && current_value != NULL)
656 result = build_string (current_value);
657 if (NILP (result))
658 result = Fassq (parameter, Vdefault_frame_alist);
659 if (!NILP (result) && !STRINGP (result))
660 result = XCDR (result);
661 if (NILP (result) || !STRINGP (result))
662 result = Qnil;
664 return result;
667 DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
668 1, 1, 0,
669 doc: /* Create an additional terminal frame, possibly on another terminal.
670 This function takes one argument, an alist specifying frame parameters.
672 You can create multiple frames on a single text-only terminal, but
673 only one of them (the selected terminal frame) is actually displayed.
675 In practice, generally you don't need to specify any parameters,
676 except when you want to create a new frame on another terminal.
677 In that case, the `tty' parameter specifies the device file to open,
678 and the `tty-type' parameter specifies the terminal type. Example:
680 (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
682 Note that changing the size of one terminal frame automatically
683 affects all frames on the same terminal device. */)
684 (parms)
685 Lisp_Object parms;
687 struct frame *f;
688 struct terminal *t = NULL;
689 Lisp_Object frame, tem;
690 struct frame *sf = SELECTED_FRAME ();
692 #ifdef MSDOS
693 if (sf->output_method != output_msdos_raw
694 && sf->output_method != output_termcap)
695 abort ();
696 #else /* not MSDOS */
698 #if 0
699 /* This can happen for multi-tty when using both terminal frames and
700 Carbon frames. */
701 if (sf->output_method != output_mac)
702 error ("Not running on a Macintosh screen; cannot make a new Macintosh frame");
703 #else
704 #if 0 /* This should work now! */
705 if (sf->output_method != output_termcap)
706 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
707 #endif
708 #endif
709 #endif /* not MSDOS */
712 Lisp_Object terminal;
714 terminal = Fassq (Qterminal, parms);
715 if (!NILP (terminal))
717 terminal = XCDR (terminal);
718 t = get_terminal (terminal, 1);
722 if (!t)
724 char *name = 0, *type = 0;
725 Lisp_Object tty, tty_type;
727 tty = get_future_frame_param
728 (Qtty, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
729 ? FRAME_TTY (XFRAME (selected_frame))->name
730 : NULL));
731 if (!NILP (tty))
733 name = (char *) alloca (SBYTES (tty) + 1);
734 strncpy (name, SDATA (tty), SBYTES (tty));
735 name[SBYTES (tty)] = 0;
738 tty_type = get_future_frame_param
739 (Qtty_type, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
740 ? FRAME_TTY (XFRAME (selected_frame))->type
741 : NULL));
742 if (!NILP (tty_type))
744 type = (char *) alloca (SBYTES (tty_type) + 1);
745 strncpy (type, SDATA (tty_type), SBYTES (tty_type));
746 type[SBYTES (tty_type)] = 0;
749 t = init_tty (name, type, 0); /* Errors are not fatal. */
752 f = make_terminal_frame (t);
755 int width, height;
756 get_tty_size (fileno (FRAME_TTY (f)->input), &width, &height);
757 change_frame_size (f, height, width, 0, 0, 0);
760 adjust_glyphs (f);
761 calculate_costs (f);
762 XSETFRAME (frame, f);
763 Fmodify_frame_parameters (frame, Vdefault_frame_alist);
764 Fmodify_frame_parameters (frame, parms);
765 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty_type,
766 build_string (t->display_info.tty->type)),
767 Qnil));
768 if (t->display_info.tty->name != NULL)
769 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty,
770 build_string (t->display_info.tty->name)),
771 Qnil));
772 else
773 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty, Qnil), Qnil));
775 /* Make the frame face alist be frame-specific, so that each
776 frame could change its face definitions independently. */
777 f->face_alist = Fcopy_alist (sf->face_alist);
778 /* Simple Fcopy_alist isn't enough, because we need the contents of
779 the vectors which are the CDRs of associations in face_alist to
780 be copied as well. */
781 for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
782 XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
783 return frame;
787 /* Perform the switch to frame FRAME.
789 If FRAME is a switch-frame event `(switch-frame FRAME1)', use
790 FRAME1 as frame.
792 If TRACK is non-zero and the frame that currently has the focus
793 redirects its focus to the selected frame, redirect that focused
794 frame's focus to FRAME instead.
796 FOR_DELETION non-zero means that the selected frame is being
797 deleted, which includes the possibility that the frame's terminal
798 is dead. */
800 Lisp_Object
801 do_switch_frame (frame, track, for_deletion)
802 Lisp_Object frame;
803 int track, for_deletion;
805 struct frame *sf = SELECTED_FRAME ();
807 /* If FRAME is a switch-frame event, extract the frame we should
808 switch to. */
809 if (CONSP (frame)
810 && EQ (XCAR (frame), Qswitch_frame)
811 && CONSP (XCDR (frame)))
812 frame = XCAR (XCDR (frame));
814 /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
815 a switch-frame event to arrive after a frame is no longer live,
816 especially when deleting the initial frame during startup. */
817 CHECK_FRAME (frame);
818 if (! FRAME_LIVE_P (XFRAME (frame)))
819 return Qnil;
821 if (sf == XFRAME (frame))
822 return frame;
824 /* This is too greedy; it causes inappropriate focus redirection
825 that's hard to get rid of. */
826 #if 0
827 /* If a frame's focus has been redirected toward the currently
828 selected frame, we should change the redirection to point to the
829 newly selected frame. This means that if the focus is redirected
830 from a minibufferless frame to a surrogate minibuffer frame, we
831 can use `other-window' to switch between all the frames using
832 that minibuffer frame, and the focus redirection will follow us
833 around. */
834 if (track)
836 Lisp_Object tail;
838 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
840 Lisp_Object focus;
842 if (!FRAMEP (XCAR (tail)))
843 abort ();
845 focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
847 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
848 Fredirect_frame_focus (XCAR (tail), frame);
851 #else /* ! 0 */
852 /* Instead, apply it only to the frame we're pointing to. */
853 #ifdef HAVE_WINDOW_SYSTEM
854 if (track && FRAME_WINDOW_P (XFRAME (frame)))
856 Lisp_Object focus, xfocus;
858 xfocus = x_get_focus_frame (XFRAME (frame));
859 if (FRAMEP (xfocus))
861 focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
862 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
863 Fredirect_frame_focus (xfocus, frame);
866 #endif /* HAVE_X_WINDOWS */
867 #endif /* ! 0 */
869 if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
870 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
872 if (FRAME_TERMCAP_P (XFRAME (selected_frame))
873 && FRAME_TERMCAP_P (XFRAME (frame))
874 && FRAME_TTY (XFRAME (selected_frame)) == FRAME_TTY (XFRAME (frame)))
876 XFRAME (selected_frame)->async_visible = 2; /* obscured */
877 XFRAME (frame)->async_visible = 1;
878 FRAME_TTY (XFRAME (frame))->top_frame = frame;
881 selected_frame = frame;
882 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
883 last_nonminibuf_frame = XFRAME (selected_frame);
885 Fselect_window (XFRAME (frame)->selected_window, Qnil);
887 #ifndef WINDOWSNT
888 /* Make sure to switch the tty color mode to that of the newly
889 selected frame. */
890 sf = SELECTED_FRAME ();
891 if (FRAME_TERMCAP_P (sf))
893 Lisp_Object color_mode_spec, color_mode;
895 color_mode_spec = assq_no_quit (Qtty_color_mode, sf->param_alist);
896 if (CONSP (color_mode_spec))
897 color_mode = XCDR (color_mode_spec);
898 else
899 color_mode = make_number (0);
900 set_tty_color_mode (sf, color_mode);
902 #endif /* !WINDOWSNT */
904 /* We want to make sure that the next event generates a frame-switch
905 event to the appropriate frame. This seems kludgy to me, but
906 before you take it out, make sure that evaluating something like
907 (select-window (frame-root-window (new-frame))) doesn't end up
908 with your typing being interpreted in the new frame instead of
909 the one you're actually typing in. */
910 internal_last_event_frame = Qnil;
912 return frame;
915 DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 1, "e",
916 doc: /* Select the frame FRAME.
917 Subsequent editing commands apply to its selected window.
918 The selection of FRAME lasts until the next time the user does
919 something to select a different frame, or until the next time this
920 function is called. If you are using a window system, the previously
921 selected frame may be restored as the selected frame after return to
922 the command loop, because it still may have the window system's input
923 focus. On a text-only terminal, the next redisplay will display FRAME.
925 This function returns FRAME, or nil if FRAME has been deleted. */)
926 (frame)
927 Lisp_Object frame;
929 return do_switch_frame (frame, 1, 0);
933 DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
934 doc: /* Handle a switch-frame event EVENT.
935 Switch-frame events are usually bound to this function.
936 A switch-frame event tells Emacs that the window manager has requested
937 that the user's events be directed to the frame mentioned in the event.
938 This function selects the selected window of the frame of EVENT.
940 If EVENT is frame object, handle it as if it were a switch-frame event
941 to that frame. */)
942 (event)
943 Lisp_Object event;
945 /* Preserve prefix arg that the command loop just cleared. */
946 current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
947 call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
948 return do_switch_frame (event, 0, 0);
951 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
952 doc: /* Return the frame that is now selected. */)
955 return selected_frame;
958 DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
959 doc: /* Return the frame object that window WINDOW is on. */)
960 (window)
961 Lisp_Object window;
963 CHECK_LIVE_WINDOW (window);
964 return XWINDOW (window)->frame;
967 DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
968 doc: /* Returns the topmost, leftmost window of FRAME.
969 If omitted, FRAME defaults to the currently selected frame. */)
970 (frame)
971 Lisp_Object frame;
973 Lisp_Object w;
975 if (NILP (frame))
976 w = SELECTED_FRAME ()->root_window;
977 else
979 CHECK_LIVE_FRAME (frame);
980 w = XFRAME (frame)->root_window;
982 while (NILP (XWINDOW (w)->buffer))
984 if (! NILP (XWINDOW (w)->hchild))
985 w = XWINDOW (w)->hchild;
986 else if (! NILP (XWINDOW (w)->vchild))
987 w = XWINDOW (w)->vchild;
988 else
989 abort ();
991 return w;
994 DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
995 Sactive_minibuffer_window, 0, 0, 0,
996 doc: /* Return the currently active minibuffer window, or nil if none. */)
999 return minibuf_level ? minibuf_window : Qnil;
1002 DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
1003 doc: /* Returns the root-window of FRAME.
1004 If omitted, FRAME defaults to the currently selected frame. */)
1005 (frame)
1006 Lisp_Object frame;
1008 Lisp_Object window;
1010 if (NILP (frame))
1011 window = SELECTED_FRAME ()->root_window;
1012 else
1014 CHECK_LIVE_FRAME (frame);
1015 window = XFRAME (frame)->root_window;
1018 return window;
1021 DEFUN ("frame-selected-window", Fframe_selected_window,
1022 Sframe_selected_window, 0, 1, 0,
1023 doc: /* Return the selected window of frame object FRAME.
1024 If omitted, FRAME defaults to the currently selected frame. */)
1025 (frame)
1026 Lisp_Object frame;
1028 Lisp_Object window;
1030 if (NILP (frame))
1031 window = SELECTED_FRAME ()->selected_window;
1032 else
1034 CHECK_LIVE_FRAME (frame);
1035 window = XFRAME (frame)->selected_window;
1038 return window;
1041 DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
1042 Sset_frame_selected_window, 2, 2, 0,
1043 doc: /* Set the selected window of frame object FRAME to WINDOW.
1044 Return WINDOW.
1045 If FRAME is nil, the selected frame is used.
1046 If FRAME is the selected frame, this makes WINDOW the selected window. */)
1047 (frame, window)
1048 Lisp_Object frame, window;
1050 if (NILP (frame))
1051 frame = selected_frame;
1053 CHECK_LIVE_FRAME (frame);
1054 CHECK_LIVE_WINDOW (window);
1056 if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
1057 error ("In `set-frame-selected-window', WINDOW is not on FRAME");
1059 if (EQ (frame, selected_frame))
1060 return Fselect_window (window, Qnil);
1062 return XFRAME (frame)->selected_window = window;
1066 DEFUN ("frame-list", Fframe_list, Sframe_list,
1067 0, 0, 0,
1068 doc: /* Return a list of all frames. */)
1071 Lisp_Object frames;
1072 frames = Fcopy_sequence (Vframe_list);
1073 #ifdef HAVE_WINDOW_SYSTEM
1074 if (FRAMEP (tip_frame))
1075 frames = Fdelq (tip_frame, frames);
1076 #endif
1077 return frames;
1080 /* Return the next frame in the frame list after FRAME.
1081 If MINIBUF is nil, exclude minibuffer-only frames.
1082 If MINIBUF is a window, include only its own frame
1083 and any frame now using that window as the minibuffer.
1084 If MINIBUF is `visible', include all visible frames.
1085 If MINIBUF is 0, include all visible and iconified frames.
1086 Otherwise, include all frames. */
1088 static Lisp_Object
1089 next_frame (frame, minibuf)
1090 Lisp_Object frame;
1091 Lisp_Object minibuf;
1093 Lisp_Object tail;
1094 int passed = 0;
1096 /* There must always be at least one frame in Vframe_list. */
1097 if (! CONSP (Vframe_list))
1098 abort ();
1100 /* If this frame is dead, it won't be in Vframe_list, and we'll loop
1101 forever. Forestall that. */
1102 CHECK_LIVE_FRAME (frame);
1104 while (1)
1105 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
1107 Lisp_Object f;
1109 f = XCAR (tail);
1111 if (passed
1112 && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
1113 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
1114 || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
1115 && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame)))))
1117 /* Decide whether this frame is eligible to be returned. */
1119 /* If we've looped all the way around without finding any
1120 eligible frames, return the original frame. */
1121 if (EQ (f, frame))
1122 return f;
1124 /* Let minibuf decide if this frame is acceptable. */
1125 if (NILP (minibuf))
1127 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
1128 return f;
1130 else if (EQ (minibuf, Qvisible))
1132 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1133 if (FRAME_VISIBLE_P (XFRAME (f)))
1134 return f;
1136 else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
1138 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1139 if (FRAME_VISIBLE_P (XFRAME (f))
1140 || FRAME_ICONIFIED_P (XFRAME (f)))
1141 return f;
1143 else if (WINDOWP (minibuf))
1145 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
1146 || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
1147 || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
1148 FRAME_FOCUS_FRAME (XFRAME (f))))
1149 return f;
1151 else
1152 return f;
1155 if (EQ (frame, f))
1156 passed++;
1160 /* Return the previous frame in the frame list before FRAME.
1161 If MINIBUF is nil, exclude minibuffer-only frames.
1162 If MINIBUF is a window, include only its own frame
1163 and any frame now using that window as the minibuffer.
1164 If MINIBUF is `visible', include all visible frames.
1165 If MINIBUF is 0, include all visible and iconified frames.
1166 Otherwise, include all frames. */
1168 static Lisp_Object
1169 prev_frame (frame, minibuf)
1170 Lisp_Object frame;
1171 Lisp_Object minibuf;
1173 Lisp_Object tail;
1174 Lisp_Object prev;
1176 /* There must always be at least one frame in Vframe_list. */
1177 if (! CONSP (Vframe_list))
1178 abort ();
1180 prev = Qnil;
1181 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
1183 Lisp_Object f;
1185 f = XCAR (tail);
1186 if (!FRAMEP (f))
1187 abort ();
1189 if (EQ (frame, f) && !NILP (prev))
1190 return prev;
1192 if ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
1193 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
1194 || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
1195 && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame))))
1197 /* Decide whether this frame is eligible to be returned,
1198 according to minibuf. */
1199 if (NILP (minibuf))
1201 if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
1202 prev = f;
1204 else if (WINDOWP (minibuf))
1206 if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
1207 || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
1208 || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
1209 FRAME_FOCUS_FRAME (XFRAME (f))))
1210 prev = f;
1212 else if (EQ (minibuf, Qvisible))
1214 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1215 if (FRAME_VISIBLE_P (XFRAME (f)))
1216 prev = f;
1218 else if (XFASTINT (minibuf) == 0)
1220 FRAME_SAMPLE_VISIBILITY (XFRAME (f));
1221 if (FRAME_VISIBLE_P (XFRAME (f))
1222 || FRAME_ICONIFIED_P (XFRAME (f)))
1223 prev = f;
1225 else
1226 prev = f;
1230 /* We've scanned the entire list. */
1231 if (NILP (prev))
1232 /* We went through the whole frame list without finding a single
1233 acceptable frame. Return the original frame. */
1234 return frame;
1235 else
1236 /* There were no acceptable frames in the list before FRAME; otherwise,
1237 we would have returned directly from the loop. Since PREV is the last
1238 acceptable frame in the list, return it. */
1239 return prev;
1243 DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
1244 doc: /* Return the next frame in the frame list after FRAME.
1245 It considers only frames on the same terminal as FRAME.
1246 By default, skip minibuffer-only frames.
1247 If omitted, FRAME defaults to the selected frame.
1248 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1249 If MINIFRAME is a window, include only its own frame
1250 and any frame now using that window as the minibuffer.
1251 If MINIFRAME is `visible', include all visible frames.
1252 If MINIFRAME is 0, include all visible and iconified frames.
1253 Otherwise, include all frames. */)
1254 (frame, miniframe)
1255 Lisp_Object frame, miniframe;
1257 if (NILP (frame))
1258 frame = selected_frame;
1260 CHECK_LIVE_FRAME (frame);
1261 return next_frame (frame, miniframe);
1264 DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame, 0, 2, 0,
1265 doc: /* Return the previous frame in the frame list before FRAME.
1266 It considers only frames on the same terminal as FRAME.
1267 By default, skip minibuffer-only frames.
1268 If omitted, FRAME defaults to the selected frame.
1269 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1270 If MINIFRAME is a window, include only its own frame
1271 and any frame now using that window as the minibuffer.
1272 If MINIFRAME is `visible', include all visible frames.
1273 If MINIFRAME is 0, include all visible and iconified frames.
1274 Otherwise, include all frames. */)
1275 (frame, miniframe)
1276 Lisp_Object frame, miniframe;
1278 if (NILP (frame))
1279 frame = selected_frame;
1280 CHECK_LIVE_FRAME (frame);
1281 return prev_frame (frame, miniframe);
1284 /* Return 1 if it is ok to delete frame F;
1285 0 if all frames aside from F are invisible.
1286 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1289 other_visible_frames (f)
1290 FRAME_PTR f;
1292 /* We know the selected frame is visible,
1293 so if F is some other frame, it can't be the sole visible one. */
1294 if (f == SELECTED_FRAME ())
1296 Lisp_Object frames;
1297 int count = 0;
1299 for (frames = Vframe_list;
1300 CONSP (frames);
1301 frames = XCDR (frames))
1303 Lisp_Object this;
1305 this = XCAR (frames);
1306 /* Verify that the frame's window still exists
1307 and we can still talk to it. And note any recent change
1308 in visibility. */
1309 #ifdef HAVE_WINDOW_SYSTEM
1310 if (FRAME_WINDOW_P (XFRAME (this)))
1312 x_sync (XFRAME (this));
1313 FRAME_SAMPLE_VISIBILITY (XFRAME (this));
1315 #endif
1317 if (FRAME_VISIBLE_P (XFRAME (this))
1318 || FRAME_ICONIFIED_P (XFRAME (this))
1319 /* Allow deleting the terminal frame when at least
1320 one X frame exists! */
1321 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
1322 count++;
1324 return count > 1;
1326 return 1;
1329 /* Error handler for `delete-frame-functions'. */
1330 static Lisp_Object
1331 delete_frame_handler (Lisp_Object arg)
1333 add_to_log ("Error during `delete-frame': %s", arg, Qnil);
1334 return Qnil;
1337 extern Lisp_Object Qrun_hook_with_args;
1339 DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
1340 doc: /* Delete FRAME, permanently eliminating it from use.
1341 If omitted, FRAME defaults to the selected frame.
1342 A frame may not be deleted if its minibuffer is used by other frames.
1343 Normally, you may not delete a frame if all other frames are invisible,
1344 but if the second optional argument FORCE is non-nil, you may do so.
1346 This function runs `delete-frame-functions' before actually deleting the
1347 frame, unless the frame is a tooltip.
1348 The functions are run with one arg, the frame to be deleted.
1349 But FORCE inhibits this too. */)
1350 /* FORCE is non-nil when handling a disconnected terminal. */
1351 (frame, force)
1352 Lisp_Object frame, force;
1354 struct frame *f;
1355 struct frame *sf = SELECTED_FRAME ();
1356 struct kboard *kb;
1358 int minibuffer_selected;
1360 if (EQ (frame, Qnil))
1362 f = sf;
1363 XSETFRAME (frame, f);
1365 else
1367 CHECK_FRAME (frame);
1368 f = XFRAME (frame);
1371 if (! FRAME_LIVE_P (f))
1372 return Qnil;
1374 if (NILP (force) && !other_visible_frames (f))
1375 error ("Attempt to delete the sole visible or iconified frame");
1377 #if 0
1378 /* This is a nice idea, but x_connection_closed needs to be able
1379 to delete the last frame, if it is gone. */
1380 if (NILP (XCDR (Vframe_list)))
1381 error ("Attempt to delete the only frame");
1382 #endif
1384 /* Does this frame have a minibuffer, and is it the surrogate
1385 minibuffer for any other frame? */
1386 if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
1388 Lisp_Object frames;
1390 for (frames = Vframe_list;
1391 CONSP (frames);
1392 frames = XCDR (frames))
1394 Lisp_Object this;
1395 this = XCAR (frames);
1397 if (! EQ (this, frame)
1398 && EQ (frame,
1399 WINDOW_FRAME (XWINDOW
1400 (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
1402 /* If we MUST delete this frame, delete the other first. */
1403 if (!NILP (force))
1404 Fdelete_frame (this, force);
1405 else
1406 error ("Attempt to delete a surrogate minibuffer frame");
1411 /* Run `delete-frame-functions'
1412 unless FORCE is `noelisp' or frame is a tooltip.
1413 FORCE is set to `noelisp' when handling a disconnect from the terminal,
1414 so we don't dare call Lisp code. */
1415 if (NILP (Vrun_hooks) || !NILP (Fframe_parameter (frame, intern ("tooltip"))))
1417 if (EQ (force, Qnoelisp))
1418 pending_funcalls
1419 = Fcons (list3 (Qrun_hook_with_args, Qdelete_frame_functions, frame),
1420 pending_funcalls);
1421 else
1422 safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
1424 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1425 if (! FRAME_LIVE_P (f))
1426 return Qnil;
1428 /* At this point, we are committed to deleting the frame.
1429 There is no more chance for errors to prevent it. */
1431 minibuffer_selected = EQ (minibuf_window, selected_window);
1433 /* Don't let the frame remain selected. */
1434 if (f == sf)
1436 Lisp_Object tail, frame1;
1438 /* Look for another visible frame on the same terminal. */
1439 frame1 = next_frame (frame, Qvisible);
1441 /* If there is none, find *some* other frame. */
1442 if (NILP (frame1) || EQ (frame1, frame))
1444 FOR_EACH_FRAME (tail, frame1)
1446 if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
1447 break;
1451 do_switch_frame (frame1, 0, 1);
1452 sf = SELECTED_FRAME ();
1455 /* Don't allow minibuf_window to remain on a deleted frame. */
1456 if (EQ (f->minibuffer_window, minibuf_window))
1458 Fset_window_buffer (sf->minibuffer_window,
1459 XWINDOW (minibuf_window)->buffer, Qnil);
1460 minibuf_window = sf->minibuffer_window;
1462 /* If the dying minibuffer window was selected,
1463 select the new one. */
1464 if (minibuffer_selected)
1465 Fselect_window (minibuf_window, Qnil);
1468 /* Don't let echo_area_window to remain on a deleted frame. */
1469 if (EQ (f->minibuffer_window, echo_area_window))
1470 echo_area_window = sf->minibuffer_window;
1472 /* Clear any X selections for this frame. */
1473 #ifdef HAVE_X_WINDOWS
1474 if (FRAME_X_P (f))
1475 x_clear_frame_selections (f);
1476 #endif
1477 #ifdef MAC_OS
1478 if (FRAME_MAC_P (f))
1479 x_clear_frame_selections (f);
1480 #endif
1482 /* Free glyphs.
1483 This function must be called before the window tree of the
1484 frame is deleted because windows contain dynamically allocated
1485 memory. */
1486 free_glyphs (f);
1488 #ifdef USE_FONT_BACKEND
1489 /* Give chance to each font driver to free a frame specific data. */
1490 font_update_drivers (f, Qnil);
1491 #endif /* USE_FONT_BACKEND */
1493 /* Mark all the windows that used to be on FRAME as deleted, and then
1494 remove the reference to them. */
1495 delete_all_subwindows (XWINDOW (f->root_window));
1496 f->root_window = Qnil;
1498 Vframe_list = Fdelq (frame, Vframe_list);
1499 FRAME_SET_VISIBLE (f, 0);
1501 if (f->namebuf)
1502 xfree (f->namebuf);
1503 if (f->decode_mode_spec_buffer)
1504 xfree (f->decode_mode_spec_buffer);
1505 if (FRAME_INSERT_COST (f))
1506 xfree (FRAME_INSERT_COST (f));
1507 if (FRAME_DELETEN_COST (f))
1508 xfree (FRAME_DELETEN_COST (f));
1509 if (FRAME_INSERTN_COST (f))
1510 xfree (FRAME_INSERTN_COST (f));
1511 if (FRAME_DELETE_COST (f))
1512 xfree (FRAME_DELETE_COST (f));
1513 if (FRAME_MESSAGE_BUF (f))
1514 xfree (FRAME_MESSAGE_BUF (f));
1516 /* Since some events are handled at the interrupt level, we may get
1517 an event for f at any time; if we zero out the frame's terminal
1518 now, then we may trip up the event-handling code. Instead, we'll
1519 promise that the terminal of the frame must be valid until we
1520 have called the window-system-dependent frame destruction
1521 routine. */
1523 if (FRAME_TERMINAL (f)->delete_frame_hook)
1524 (*FRAME_TERMINAL (f)->delete_frame_hook) (f);
1527 struct terminal *terminal = FRAME_TERMINAL (f);
1528 f->output_data.nothing = 0;
1529 f->terminal = 0; /* Now the frame is dead. */
1531 /* If needed, delete the terminal that this frame was on.
1532 (This must be done after the frame is killed.) */
1533 terminal->reference_count--;
1534 if (terminal->reference_count == 0)
1536 Lisp_Object tmp;
1537 XSETTERMINAL (tmp, terminal);
1539 kb = NULL;
1540 Fdelete_terminal (tmp, NILP (force) ? Qt : force);
1542 #ifdef MULTI_KBOARD
1543 else
1544 kb = terminal->kboard;
1545 #endif
1548 /* If we've deleted the last_nonminibuf_frame, then try to find
1549 another one. */
1550 if (f == last_nonminibuf_frame)
1552 Lisp_Object frames;
1554 last_nonminibuf_frame = 0;
1556 for (frames = Vframe_list;
1557 CONSP (frames);
1558 frames = XCDR (frames))
1560 f = XFRAME (XCAR (frames));
1561 if (!FRAME_MINIBUF_ONLY_P (f))
1563 last_nonminibuf_frame = f;
1564 break;
1569 /* If there's no other frame on the same kboard, get out of
1570 single-kboard state if we're in it for this kboard. */
1571 if (kb != NULL)
1573 Lisp_Object frames;
1574 /* Some frame we found on the same kboard, or nil if there are none. */
1575 Lisp_Object frame_on_same_kboard;
1577 frame_on_same_kboard = Qnil;
1579 for (frames = Vframe_list;
1580 CONSP (frames);
1581 frames = XCDR (frames))
1583 Lisp_Object this;
1584 struct frame *f1;
1586 this = XCAR (frames);
1587 if (!FRAMEP (this))
1588 abort ();
1589 f1 = XFRAME (this);
1591 if (kb == FRAME_KBOARD (f1))
1592 frame_on_same_kboard = this;
1595 if (NILP (frame_on_same_kboard))
1596 not_single_kboard_state (kb);
1600 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1601 find another one. Prefer minibuffer-only frames, but also notice
1602 frames with other windows. */
1603 if (kb != NULL && EQ (frame, kb->Vdefault_minibuffer_frame))
1605 Lisp_Object frames;
1607 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1608 Lisp_Object frame_with_minibuf;
1609 /* Some frame we found on the same kboard, or nil if there are none. */
1610 Lisp_Object frame_on_same_kboard;
1612 frame_on_same_kboard = Qnil;
1613 frame_with_minibuf = Qnil;
1615 for (frames = Vframe_list;
1616 CONSP (frames);
1617 frames = XCDR (frames))
1619 Lisp_Object this;
1620 struct frame *f1;
1622 this = XCAR (frames);
1623 if (!FRAMEP (this))
1624 abort ();
1625 f1 = XFRAME (this);
1627 /* Consider only frames on the same kboard
1628 and only those with minibuffers. */
1629 if (kb == FRAME_KBOARD (f1)
1630 && FRAME_HAS_MINIBUF_P (f1))
1632 frame_with_minibuf = this;
1633 if (FRAME_MINIBUF_ONLY_P (f1))
1634 break;
1637 if (kb == FRAME_KBOARD (f1))
1638 frame_on_same_kboard = this;
1641 if (!NILP (frame_on_same_kboard))
1643 /* We know that there must be some frame with a minibuffer out
1644 there. If this were not true, all of the frames present
1645 would have to be minibufferless, which implies that at some
1646 point their minibuffer frames must have been deleted, but
1647 that is prohibited at the top; you can't delete surrogate
1648 minibuffer frames. */
1649 if (NILP (frame_with_minibuf))
1650 abort ();
1652 kb->Vdefault_minibuffer_frame = frame_with_minibuf;
1654 else
1655 /* No frames left on this kboard--say no minibuffer either. */
1656 kb->Vdefault_minibuffer_frame = Qnil;
1659 /* Cause frame titles to update--necessary if we now have just one frame. */
1660 update_mode_lines = 1;
1662 return Qnil;
1665 /* Return mouse position in character cell units. */
1667 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
1668 doc: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1669 The position is given in character cells, where (0, 0) is the
1670 upper-left corner of the frame, X is the horizontal offset, and Y is
1671 the vertical offset.
1672 If Emacs is running on a mouseless terminal or hasn't been programmed
1673 to read the mouse position, it returns the selected frame for FRAME
1674 and nil for X and Y.
1675 If `mouse-position-function' is non-nil, `mouse-position' calls it,
1676 passing the normal return value to that function as an argument,
1677 and returns whatever that function returns. */)
1680 FRAME_PTR f;
1681 Lisp_Object lispy_dummy;
1682 enum scroll_bar_part party_dummy;
1683 Lisp_Object x, y, retval;
1684 int col, row;
1685 unsigned long long_dummy;
1686 struct gcpro gcpro1;
1688 f = SELECTED_FRAME ();
1689 x = y = Qnil;
1691 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1692 /* It's okay for the hook to refrain from storing anything. */
1693 if (FRAME_TERMINAL (f)->mouse_position_hook)
1694 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1695 &lispy_dummy, &party_dummy,
1696 &x, &y,
1697 &long_dummy);
1698 if (! NILP (x))
1700 col = XINT (x);
1701 row = XINT (y);
1702 pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
1703 XSETINT (x, col);
1704 XSETINT (y, row);
1706 #endif
1707 XSETFRAME (lispy_dummy, f);
1708 retval = Fcons (lispy_dummy, Fcons (x, y));
1709 GCPRO1 (retval);
1710 if (!NILP (Vmouse_position_function))
1711 retval = call1 (Vmouse_position_function, retval);
1712 RETURN_UNGCPRO (retval);
1715 DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
1716 Smouse_pixel_position, 0, 0, 0,
1717 doc: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1718 The position is given in pixel units, where (0, 0) is the
1719 upper-left corner of the frame, X is the horizontal offset, and Y is
1720 the vertical offset.
1721 If Emacs is running on a mouseless terminal or hasn't been programmed
1722 to read the mouse position, it returns the selected frame for FRAME
1723 and nil for X and Y. */)
1726 FRAME_PTR f;
1727 Lisp_Object lispy_dummy;
1728 enum scroll_bar_part party_dummy;
1729 Lisp_Object x, y;
1730 unsigned long long_dummy;
1732 f = SELECTED_FRAME ();
1733 x = y = Qnil;
1735 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
1736 /* It's okay for the hook to refrain from storing anything. */
1737 if (FRAME_TERMINAL (f)->mouse_position_hook)
1738 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1739 &lispy_dummy, &party_dummy,
1740 &x, &y,
1741 &long_dummy);
1742 #endif
1743 XSETFRAME (lispy_dummy, f);
1744 return Fcons (lispy_dummy, Fcons (x, y));
1747 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
1748 doc: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1749 Coordinates are relative to the frame, not a window,
1750 so the coordinates of the top left character in the frame
1751 may be nonzero due to left-hand scroll bars or the menu bar.
1753 The position is given in character cells, where (0, 0) is the
1754 upper-left corner of the frame, X is the horizontal offset, and Y is
1755 the vertical offset.
1757 This function is a no-op for an X frame that is not visible.
1758 If you have just created a frame, you must wait for it to become visible
1759 before calling this function on it, like this.
1760 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1761 (frame, x, y)
1762 Lisp_Object frame, x, y;
1764 CHECK_LIVE_FRAME (frame);
1765 CHECK_NUMBER (x);
1766 CHECK_NUMBER (y);
1768 /* I think this should be done with a hook. */
1769 #ifdef HAVE_WINDOW_SYSTEM
1770 if (FRAME_WINDOW_P (XFRAME (frame)))
1771 /* Warping the mouse will cause enternotify and focus events. */
1772 x_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
1773 #else
1774 #if defined (MSDOS) && defined (HAVE_MOUSE)
1775 if (FRAME_MSDOS_P (XFRAME (frame)))
1777 Fselect_frame (frame);
1778 mouse_moveto (XINT (x), XINT (y));
1780 #else
1781 #ifdef HAVE_GPM
1783 Fselect_frame (frame);
1784 term_mouse_moveto (XINT (x), XINT (y));
1786 #endif
1787 #endif
1788 #endif
1790 return Qnil;
1793 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
1794 Sset_mouse_pixel_position, 3, 3, 0,
1795 doc: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
1796 The position is given in pixels, where (0, 0) is the upper-left corner
1797 of the frame, X is the horizontal offset, and Y is the vertical offset.
1799 Note, this is a no-op for an X frame that is not visible.
1800 If you have just created a frame, you must wait for it to become visible
1801 before calling this function on it, like this.
1802 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1803 (frame, x, y)
1804 Lisp_Object frame, x, y;
1806 CHECK_LIVE_FRAME (frame);
1807 CHECK_NUMBER (x);
1808 CHECK_NUMBER (y);
1810 /* I think this should be done with a hook. */
1811 #ifdef HAVE_WINDOW_SYSTEM
1812 if (FRAME_WINDOW_P (XFRAME (frame)))
1813 /* Warping the mouse will cause enternotify and focus events. */
1814 x_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
1815 #else
1816 #if defined (MSDOS) && defined (HAVE_MOUSE)
1817 if (FRAME_MSDOS_P (XFRAME (frame)))
1819 Fselect_frame (frame);
1820 mouse_moveto (XINT (x), XINT (y));
1822 #else
1823 #ifdef HAVE_GPM
1825 Fselect_frame (frame);
1826 term_mouse_moveto (XINT (x), XINT (y));
1828 #endif
1829 #endif
1830 #endif
1832 return Qnil;
1835 static void make_frame_visible_1 P_ ((Lisp_Object));
1837 DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
1838 0, 1, "",
1839 doc: /* Make the frame FRAME visible (assuming it is an X window).
1840 If omitted, FRAME defaults to the currently selected frame. */)
1841 (frame)
1842 Lisp_Object frame;
1844 if (NILP (frame))
1845 frame = selected_frame;
1847 CHECK_LIVE_FRAME (frame);
1849 /* I think this should be done with a hook. */
1850 #ifdef HAVE_WINDOW_SYSTEM
1851 if (FRAME_WINDOW_P (XFRAME (frame)))
1853 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
1854 x_make_frame_visible (XFRAME (frame));
1856 #endif
1858 make_frame_visible_1 (XFRAME (frame)->root_window);
1860 /* Make menu bar update for the Buffers and Frames menus. */
1861 windows_or_buffers_changed++;
1863 return frame;
1866 /* Update the display_time slot of the buffers shown in WINDOW
1867 and all its descendents. */
1869 static void
1870 make_frame_visible_1 (window)
1871 Lisp_Object window;
1873 struct window *w;
1875 for (;!NILP (window); window = w->next)
1877 w = XWINDOW (window);
1879 if (!NILP (w->buffer))
1880 XBUFFER (w->buffer)->display_time = Fcurrent_time ();
1882 if (!NILP (w->vchild))
1883 make_frame_visible_1 (w->vchild);
1884 if (!NILP (w->hchild))
1885 make_frame_visible_1 (w->hchild);
1889 DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
1890 0, 2, "",
1891 doc: /* Make the frame FRAME invisible (assuming it is an X window).
1892 If omitted, FRAME defaults to the currently selected frame.
1893 Normally you may not make FRAME invisible if all other frames are invisible,
1894 but if the second optional argument FORCE is non-nil, you may do so. */)
1895 (frame, force)
1896 Lisp_Object frame, force;
1898 if (NILP (frame))
1899 frame = selected_frame;
1901 CHECK_LIVE_FRAME (frame);
1903 if (NILP (force) && !other_visible_frames (XFRAME (frame)))
1904 error ("Attempt to make invisible the sole visible or iconified frame");
1906 #if 0 /* This isn't logically necessary, and it can do GC. */
1907 /* Don't let the frame remain selected. */
1908 if (EQ (frame, selected_frame))
1909 do_switch_frame (next_frame (frame, Qt), 0, 0)
1910 #endif
1912 /* Don't allow minibuf_window to remain on a deleted frame. */
1913 if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
1915 struct frame *sf = XFRAME (selected_frame);
1916 Fset_window_buffer (sf->minibuffer_window,
1917 XWINDOW (minibuf_window)->buffer, Qnil);
1918 minibuf_window = sf->minibuffer_window;
1921 /* I think this should be done with a hook. */
1922 #ifdef HAVE_WINDOW_SYSTEM
1923 if (FRAME_WINDOW_P (XFRAME (frame)))
1924 x_make_frame_invisible (XFRAME (frame));
1925 #endif
1927 /* Make menu bar update for the Buffers and Frames menus. */
1928 windows_or_buffers_changed++;
1930 return Qnil;
1933 DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
1934 0, 1, "",
1935 doc: /* Make the frame FRAME into an icon.
1936 If omitted, FRAME defaults to the currently selected frame. */)
1937 (frame)
1938 Lisp_Object frame;
1940 if (NILP (frame))
1941 frame = selected_frame;
1943 CHECK_LIVE_FRAME (frame);
1945 #if 0 /* This isn't logically necessary, and it can do GC. */
1946 /* Don't let the frame remain selected. */
1947 if (EQ (frame, selected_frame))
1948 Fhandle_switch_frame (next_frame (frame, Qt));
1949 #endif
1951 /* Don't allow minibuf_window to remain on a deleted frame. */
1952 if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
1954 struct frame *sf = XFRAME (selected_frame);
1955 Fset_window_buffer (sf->minibuffer_window,
1956 XWINDOW (minibuf_window)->buffer, Qnil);
1957 minibuf_window = sf->minibuffer_window;
1960 /* I think this should be done with a hook. */
1961 #ifdef HAVE_WINDOW_SYSTEM
1962 if (FRAME_WINDOW_P (XFRAME (frame)))
1963 x_iconify_frame (XFRAME (frame));
1964 #endif
1966 /* Make menu bar update for the Buffers and Frames menus. */
1967 windows_or_buffers_changed++;
1969 return Qnil;
1972 DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
1973 1, 1, 0,
1974 doc: /* Return t if FRAME is now \"visible\" (actually in use for display).
1975 A frame that is not \"visible\" is not updated and, if it works through
1976 a window system, it may not show at all.
1977 Return the symbol `icon' if frame is visible only as an icon.
1979 On a text-only terminal, all frames are considered visible, whether
1980 they are currently being displayed or not, and this function returns t
1981 for all frames. */)
1982 (frame)
1983 Lisp_Object frame;
1985 CHECK_LIVE_FRAME (frame);
1987 FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
1989 if (FRAME_VISIBLE_P (XFRAME (frame)))
1990 return Qt;
1991 if (FRAME_ICONIFIED_P (XFRAME (frame)))
1992 return Qicon;
1993 return Qnil;
1996 DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
1997 0, 0, 0,
1998 doc: /* Return a list of all frames now \"visible\" (being updated). */)
2001 Lisp_Object tail, frame;
2002 struct frame *f;
2003 Lisp_Object value;
2005 value = Qnil;
2006 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
2008 frame = XCAR (tail);
2009 if (!FRAMEP (frame))
2010 continue;
2011 f = XFRAME (frame);
2012 if (FRAME_VISIBLE_P (f))
2013 value = Fcons (frame, value);
2015 return value;
2019 DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
2020 doc: /* Bring FRAME to the front, so it occludes any frames it overlaps.
2021 If FRAME is invisible or iconified, make it visible.
2022 If you don't specify a frame, the selected frame is used.
2023 If Emacs is displaying on an ordinary terminal or some other device which
2024 doesn't support multiple overlapping frames, this function does nothing. */)
2025 (frame)
2026 Lisp_Object frame;
2028 struct frame *f;
2029 if (NILP (frame))
2030 frame = selected_frame;
2032 CHECK_LIVE_FRAME (frame);
2034 f = XFRAME (frame);
2036 /* Do like the documentation says. */
2037 Fmake_frame_visible (frame);
2039 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2040 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 1);
2042 return Qnil;
2045 /* Should we have a corresponding function called Flower_Power? */
2046 DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
2047 doc: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2048 If you don't specify a frame, the selected frame is used.
2049 If Emacs is displaying on an ordinary terminal or some other device which
2050 doesn't support multiple overlapping frames, this function does nothing. */)
2051 (frame)
2052 Lisp_Object frame;
2054 struct frame *f;
2056 if (NILP (frame))
2057 frame = selected_frame;
2059 CHECK_LIVE_FRAME (frame);
2061 f = XFRAME (frame);
2063 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2064 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
2066 return Qnil;
2070 DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
2071 1, 2, 0,
2072 doc: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2073 In other words, switch-frame events caused by events in FRAME will
2074 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2075 FOCUS-FRAME after reading an event typed at FRAME.
2077 If FOCUS-FRAME is omitted or nil, any existing redirection is
2078 cancelled, and the frame again receives its own keystrokes.
2080 Focus redirection is useful for temporarily redirecting keystrokes to
2081 a surrogate minibuffer frame when a frame doesn't have its own
2082 minibuffer window.
2084 A frame's focus redirection can be changed by `select-frame'. If frame
2085 FOO is selected, and then a different frame BAR is selected, any
2086 frames redirecting their focus to FOO are shifted to redirect their
2087 focus to BAR. This allows focus redirection to work properly when the
2088 user switches from one frame to another using `select-window'.
2090 This means that a frame whose focus is redirected to itself is treated
2091 differently from a frame whose focus is redirected to nil; the former
2092 is affected by `select-frame', while the latter is not.
2094 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2095 (frame, focus_frame)
2096 Lisp_Object frame, focus_frame;
2098 struct frame *f;
2100 /* Note that we don't check for a live frame here. It's reasonable
2101 to redirect the focus of a frame you're about to delete, if you
2102 know what other frame should receive those keystrokes. */
2103 CHECK_FRAME (frame);
2105 if (! NILP (focus_frame))
2106 CHECK_LIVE_FRAME (focus_frame);
2108 f = XFRAME (frame);
2110 f->focus_frame = focus_frame;
2112 if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
2113 (*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
2115 return Qnil;
2119 DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
2120 doc: /* Return the frame to which FRAME's keystrokes are currently being sent.
2121 This returns nil if FRAME's focus is not redirected.
2122 See `redirect-frame-focus'. */)
2123 (frame)
2124 Lisp_Object frame;
2126 CHECK_LIVE_FRAME (frame);
2128 return FRAME_FOCUS_FRAME (XFRAME (frame));
2133 /* Return the value of frame parameter PROP in frame FRAME. */
2135 Lisp_Object
2136 get_frame_param (frame, prop)
2137 register struct frame *frame;
2138 Lisp_Object prop;
2140 register Lisp_Object tem;
2142 tem = Fassq (prop, frame->param_alist);
2143 if (EQ (tem, Qnil))
2144 return tem;
2145 return Fcdr (tem);
2148 /* Return the buffer-predicate of the selected frame. */
2150 Lisp_Object
2151 frame_buffer_predicate (frame)
2152 Lisp_Object frame;
2154 return XFRAME (frame)->buffer_predicate;
2157 /* Return the buffer-list of the selected frame. */
2159 Lisp_Object
2160 frame_buffer_list (frame)
2161 Lisp_Object frame;
2163 return XFRAME (frame)->buffer_list;
2166 /* Set the buffer-list of the selected frame. */
2168 void
2169 set_frame_buffer_list (frame, list)
2170 Lisp_Object frame, list;
2172 XFRAME (frame)->buffer_list = list;
2175 /* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
2177 void
2178 frames_discard_buffer (buffer)
2179 Lisp_Object buffer;
2181 Lisp_Object frame, tail;
2183 FOR_EACH_FRAME (tail, frame)
2185 XFRAME (frame)->buffer_list
2186 = Fdelq (buffer, XFRAME (frame)->buffer_list);
2187 XFRAME (frame)->buried_buffer_list
2188 = Fdelq (buffer, XFRAME (frame)->buried_buffer_list);
2192 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2193 If the alist already has an element for PROP, we change it. */
2195 void
2196 store_in_alist (alistptr, prop, val)
2197 Lisp_Object *alistptr, val;
2198 Lisp_Object prop;
2200 register Lisp_Object tem;
2202 tem = Fassq (prop, *alistptr);
2203 if (EQ (tem, Qnil))
2204 *alistptr = Fcons (Fcons (prop, val), *alistptr);
2205 else
2206 Fsetcdr (tem, val);
2209 static int
2210 frame_name_fnn_p (str, len)
2211 char *str;
2212 EMACS_INT len;
2214 if (len > 1 && str[0] == 'F')
2216 char *end_ptr;
2218 strtol (str + 1, &end_ptr, 10);
2220 if (end_ptr == str + len)
2221 return 1;
2223 return 0;
2226 /* Set the name of the terminal frame. Also used by MSDOS frames.
2227 Modeled after x_set_name which is used for WINDOW frames. */
2229 static void
2230 set_term_frame_name (f, name)
2231 struct frame *f;
2232 Lisp_Object name;
2234 f->explicit_name = ! NILP (name);
2236 /* If NAME is nil, set the name to F<num>. */
2237 if (NILP (name))
2239 char namebuf[20];
2241 /* Check for no change needed in this very common case
2242 before we do any consing. */
2243 if (frame_name_fnn_p (SDATA (f->name),
2244 SBYTES (f->name)))
2245 return;
2247 tty_frame_count++;
2248 sprintf (namebuf, "F%d", tty_frame_count);
2249 name = build_string (namebuf);
2251 else
2253 CHECK_STRING (name);
2255 /* Don't change the name if it's already NAME. */
2256 if (! NILP (Fstring_equal (name, f->name)))
2257 return;
2259 /* Don't allow the user to set the frame name to F<num>, so it
2260 doesn't clash with the names we generate for terminal frames. */
2261 if (frame_name_fnn_p (SDATA (name), SBYTES (name)))
2262 error ("Frame names of the form F<num> are usurped by Emacs");
2265 f->name = name;
2266 update_mode_lines = 1;
2269 void
2270 store_frame_param (f, prop, val)
2271 struct frame *f;
2272 Lisp_Object prop, val;
2274 register Lisp_Object old_alist_elt;
2276 /* The buffer-list parameters are stored in a special place and not
2277 in the alist. */
2278 if (EQ (prop, Qbuffer_list))
2280 f->buffer_list = val;
2281 return;
2283 if (EQ (prop, Qburied_buffer_list))
2285 f->buried_buffer_list = val;
2286 return;
2289 /* If PROP is a symbol which is supposed to have frame-local values,
2290 and it is set up based on this frame, switch to the global
2291 binding. That way, we can create or alter the frame-local binding
2292 without messing up the symbol's status. */
2293 if (SYMBOLP (prop))
2295 Lisp_Object valcontents;
2296 valcontents = SYMBOL_VALUE (prop);
2297 if ((BUFFER_LOCAL_VALUEP (valcontents))
2298 && XBUFFER_LOCAL_VALUE (valcontents)->check_frame
2299 && XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame
2300 && XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame) == f)
2301 swap_in_global_binding (prop);
2304 #ifndef WINDOWSNT
2305 /* The tty color mode needs to be set before the frame's parameter
2306 alist is updated with the new value, because set_tty_color_mode
2307 wants to look at the old mode. */
2308 if (FRAME_TERMCAP_P (f) && EQ (prop, Qtty_color_mode))
2309 set_tty_color_mode (f, val);
2310 #endif
2312 /* Update the frame parameter alist. */
2313 old_alist_elt = Fassq (prop, f->param_alist);
2314 if (EQ (old_alist_elt, Qnil))
2315 f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
2316 else
2317 Fsetcdr (old_alist_elt, val);
2319 /* Update some other special parameters in their special places
2320 in addition to the alist. */
2322 if (EQ (prop, Qbuffer_predicate))
2323 f->buffer_predicate = val;
2325 if (! FRAME_WINDOW_P (f))
2327 if (EQ (prop, Qmenu_bar_lines))
2328 set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
2329 else if (EQ (prop, Qname))
2330 set_term_frame_name (f, val);
2333 if (EQ (prop, Qminibuffer) && WINDOWP (val))
2335 if (! MINI_WINDOW_P (XWINDOW (val)))
2336 error ("Surrogate minibuffer windows must be minibuffer windows");
2338 if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
2339 && !EQ (val, f->minibuffer_window))
2340 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2342 /* Install the chosen minibuffer window, with proper buffer. */
2343 f->minibuffer_window = val;
2347 DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
2348 doc: /* Return the parameters-alist of frame FRAME.
2349 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2350 The meaningful PARMs depend on the kind of frame.
2351 If FRAME is omitted, return information on the currently selected frame. */)
2352 (frame)
2353 Lisp_Object frame;
2355 Lisp_Object alist;
2356 FRAME_PTR f;
2357 int height, width;
2358 struct gcpro gcpro1;
2360 if (NILP (frame))
2361 frame = selected_frame;
2363 CHECK_FRAME (frame);
2364 f = XFRAME (frame);
2366 if (!FRAME_LIVE_P (f))
2367 return Qnil;
2369 alist = Fcopy_alist (f->param_alist);
2370 GCPRO1 (alist);
2372 if (!FRAME_WINDOW_P (f))
2374 int fg = FRAME_FOREGROUND_PIXEL (f);
2375 int bg = FRAME_BACKGROUND_PIXEL (f);
2376 Lisp_Object elt;
2378 /* If the frame's parameter alist says the colors are
2379 unspecified and reversed, take the frame's background pixel
2380 for foreground and vice versa. */
2381 elt = Fassq (Qforeground_color, alist);
2382 if (CONSP (elt) && STRINGP (XCDR (elt)))
2384 if (strncmp (SDATA (XCDR (elt)),
2385 unspecified_bg,
2386 SCHARS (XCDR (elt))) == 0)
2387 store_in_alist (&alist, Qforeground_color, tty_color_name (f, bg));
2388 else if (strncmp (SDATA (XCDR (elt)),
2389 unspecified_fg,
2390 SCHARS (XCDR (elt))) == 0)
2391 store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
2393 else
2394 store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
2395 elt = Fassq (Qbackground_color, alist);
2396 if (CONSP (elt) && STRINGP (XCDR (elt)))
2398 if (strncmp (SDATA (XCDR (elt)),
2399 unspecified_fg,
2400 SCHARS (XCDR (elt))) == 0)
2401 store_in_alist (&alist, Qbackground_color, tty_color_name (f, fg));
2402 else if (strncmp (SDATA (XCDR (elt)),
2403 unspecified_bg,
2404 SCHARS (XCDR (elt))) == 0)
2405 store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
2407 else
2408 store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
2409 store_in_alist (&alist, intern ("font"),
2410 build_string (FRAME_MSDOS_P (f)
2411 ? "ms-dos"
2412 : FRAME_W32_P (f) ? "w32term"
2413 :"tty"));
2415 store_in_alist (&alist, Qname, f->name);
2416 height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
2417 store_in_alist (&alist, Qheight, make_number (height));
2418 width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
2419 store_in_alist (&alist, Qwidth, make_number (width));
2420 store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
2421 store_in_alist (&alist, Qminibuffer,
2422 (! FRAME_HAS_MINIBUF_P (f) ? Qnil
2423 : FRAME_MINIBUF_ONLY_P (f) ? Qonly
2424 : FRAME_MINIBUF_WINDOW (f)));
2425 store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
2426 store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
2427 store_in_alist (&alist, Qburied_buffer_list, XFRAME (frame)->buried_buffer_list);
2429 /* I think this should be done with a hook. */
2430 #ifdef HAVE_WINDOW_SYSTEM
2431 if (FRAME_WINDOW_P (f))
2432 x_report_frame_params (f, &alist);
2433 else
2434 #endif
2436 /* This ought to be correct in f->param_alist for an X frame. */
2437 Lisp_Object lines;
2438 XSETFASTINT (lines, FRAME_MENU_BAR_LINES (f));
2439 store_in_alist (&alist, Qmenu_bar_lines, lines);
2442 UNGCPRO;
2443 return alist;
2447 DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
2448 doc: /* Return FRAME's value for parameter PARAMETER.
2449 If FRAME is nil, describe the currently selected frame. */)
2450 (frame, parameter)
2451 Lisp_Object frame, parameter;
2453 struct frame *f;
2454 Lisp_Object value;
2456 if (NILP (frame))
2457 frame = selected_frame;
2458 else
2459 CHECK_FRAME (frame);
2460 CHECK_SYMBOL (parameter);
2462 f = XFRAME (frame);
2463 value = Qnil;
2465 if (FRAME_LIVE_P (f))
2467 /* Avoid consing in frequent cases. */
2468 if (EQ (parameter, Qname))
2469 value = f->name;
2470 #ifdef HAVE_X_WINDOWS
2471 else if (EQ (parameter, Qdisplay) && FRAME_X_P (f))
2472 value = XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element);
2473 #endif /* HAVE_X_WINDOWS */
2474 else if (EQ (parameter, Qbackground_color)
2475 || EQ (parameter, Qforeground_color))
2477 value = Fassq (parameter, f->param_alist);
2478 if (CONSP (value))
2480 value = XCDR (value);
2481 /* Fframe_parameters puts the actual fg/bg color names,
2482 even if f->param_alist says otherwise. This is
2483 important when param_alist's notion of colors is
2484 "unspecified". We need to do the same here. */
2485 if (STRINGP (value) && !FRAME_WINDOW_P (f))
2487 const char *color_name;
2488 EMACS_INT csz;
2490 if (EQ (parameter, Qbackground_color))
2492 color_name = SDATA (value);
2493 csz = SCHARS (value);
2494 if (strncmp (color_name, unspecified_bg, csz) == 0)
2495 value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
2496 else if (strncmp (color_name, unspecified_fg, csz) == 0)
2497 value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
2499 else if (EQ (parameter, Qforeground_color))
2501 color_name = SDATA (value);
2502 csz = SCHARS (value);
2503 if (strncmp (color_name, unspecified_fg, csz) == 0)
2504 value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
2505 else if (strncmp (color_name, unspecified_bg, csz) == 0)
2506 value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
2510 else
2511 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2513 else if (EQ (parameter, Qdisplay_type)
2514 || EQ (parameter, Qbackground_mode))
2515 value = Fcdr (Fassq (parameter, f->param_alist));
2516 else
2517 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2520 return value;
2524 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
2525 Smodify_frame_parameters, 2, 2, 0,
2526 doc: /* Modify the parameters of frame FRAME according to ALIST.
2527 If FRAME is nil, it defaults to the selected frame.
2528 ALIST is an alist of parameters to change and their new values.
2529 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2530 The meaningful PARMs depend on the kind of frame.
2531 Undefined PARMs are ignored, but stored in the frame's parameter list
2532 so that `frame-parameters' will return them.
2534 The value of frame parameter FOO can also be accessed
2535 as a frame-local binding for the variable FOO, if you have
2536 enabled such bindings for that variable with `make-variable-frame-local'. */)
2537 (frame, alist)
2538 Lisp_Object frame, alist;
2540 FRAME_PTR f;
2541 register Lisp_Object tail, prop, val;
2543 if (EQ (frame, Qnil))
2544 frame = selected_frame;
2545 CHECK_LIVE_FRAME (frame);
2546 f = XFRAME (frame);
2548 /* I think this should be done with a hook. */
2549 #ifdef HAVE_WINDOW_SYSTEM
2550 if (FRAME_WINDOW_P (f))
2551 x_set_frame_parameters (f, alist);
2552 else
2553 #endif
2554 #ifdef MSDOS
2555 if (FRAME_MSDOS_P (f))
2556 IT_set_frame_parameters (f, alist);
2557 else
2558 #endif
2561 int length = XINT (Flength (alist));
2562 int i;
2563 Lisp_Object *parms
2564 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2565 Lisp_Object *values
2566 = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
2568 /* Extract parm names and values into those vectors. */
2570 i = 0;
2571 for (tail = alist; CONSP (tail); tail = XCDR (tail))
2573 Lisp_Object elt;
2575 elt = XCAR (tail);
2576 parms[i] = Fcar (elt);
2577 values[i] = Fcdr (elt);
2578 i++;
2581 /* Now process them in reverse of specified order. */
2582 for (i--; i >= 0; i--)
2584 prop = parms[i];
2585 val = values[i];
2586 store_frame_param (f, prop, val);
2588 /* Changing the background color might change the background
2589 mode, so that we have to load new defface specs.
2590 Call frame-set-background-mode to do that. */
2591 if (EQ (prop, Qbackground_color))
2592 call1 (Qframe_set_background_mode, frame);
2595 return Qnil;
2598 DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
2599 0, 1, 0,
2600 doc: /* Height in pixels of a line in the font in frame FRAME.
2601 If FRAME is omitted, the selected frame is used.
2602 For a terminal frame, the value is always 1. */)
2603 (frame)
2604 Lisp_Object frame;
2606 struct frame *f;
2608 if (NILP (frame))
2609 frame = selected_frame;
2610 CHECK_FRAME (frame);
2611 f = XFRAME (frame);
2613 #ifdef HAVE_WINDOW_SYSTEM
2614 if (FRAME_WINDOW_P (f))
2615 return make_number (x_char_height (f));
2616 else
2617 #endif
2618 return make_number (1);
2622 DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
2623 0, 1, 0,
2624 doc: /* Width in pixels of characters in the font in frame FRAME.
2625 If FRAME is omitted, the selected frame is used.
2626 On a graphical screen, the width is the standard width of the default font.
2627 For a terminal screen, the value is always 1. */)
2628 (frame)
2629 Lisp_Object frame;
2631 struct frame *f;
2633 if (NILP (frame))
2634 frame = selected_frame;
2635 CHECK_FRAME (frame);
2636 f = XFRAME (frame);
2638 #ifdef HAVE_WINDOW_SYSTEM
2639 if (FRAME_WINDOW_P (f))
2640 return make_number (x_char_width (f));
2641 else
2642 #endif
2643 return make_number (1);
2646 DEFUN ("frame-pixel-height", Fframe_pixel_height,
2647 Sframe_pixel_height, 0, 1, 0,
2648 doc: /* Return a FRAME's height in pixels.
2649 This counts only the height available for text lines,
2650 not menu bars on window-system Emacs frames.
2651 For a terminal frame, the result really gives the height in characters.
2652 If FRAME is omitted, the selected frame is used. */)
2653 (frame)
2654 Lisp_Object frame;
2656 struct frame *f;
2658 if (NILP (frame))
2659 frame = selected_frame;
2660 CHECK_FRAME (frame);
2661 f = XFRAME (frame);
2663 #ifdef HAVE_WINDOW_SYSTEM
2664 if (FRAME_WINDOW_P (f))
2665 return make_number (x_pixel_height (f));
2666 else
2667 #endif
2668 return make_number (FRAME_LINES (f));
2671 DEFUN ("frame-pixel-width", Fframe_pixel_width,
2672 Sframe_pixel_width, 0, 1, 0,
2673 doc: /* Return FRAME's width in pixels.
2674 For a terminal frame, the result really gives the width in characters.
2675 If FRAME is omitted, the selected frame is used. */)
2676 (frame)
2677 Lisp_Object frame;
2679 struct frame *f;
2681 if (NILP (frame))
2682 frame = selected_frame;
2683 CHECK_FRAME (frame);
2684 f = XFRAME (frame);
2686 #ifdef HAVE_WINDOW_SYSTEM
2687 if (FRAME_WINDOW_P (f))
2688 return make_number (x_pixel_width (f));
2689 else
2690 #endif
2691 return make_number (FRAME_COLS (f));
2694 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
2695 doc: /* Specify that the frame FRAME has LINES lines.
2696 Optional third arg non-nil means that redisplay should use LINES lines
2697 but that the idea of the actual height of the frame should not be changed. */)
2698 (frame, lines, pretend)
2699 Lisp_Object frame, lines, pretend;
2701 register struct frame *f;
2703 CHECK_NUMBER (lines);
2704 if (NILP (frame))
2705 frame = selected_frame;
2706 CHECK_LIVE_FRAME (frame);
2707 f = XFRAME (frame);
2709 /* I think this should be done with a hook. */
2710 #ifdef HAVE_WINDOW_SYSTEM
2711 if (FRAME_WINDOW_P (f))
2713 if (XINT (lines) != FRAME_LINES (f))
2714 x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
2715 do_pending_window_change (0);
2717 else
2718 #endif
2719 change_frame_size (f, XINT (lines), 0, !NILP (pretend), 0, 0);
2720 return Qnil;
2723 DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
2724 doc: /* Specify that the frame FRAME has COLS columns.
2725 Optional third arg non-nil means that redisplay should use COLS columns
2726 but that the idea of the actual width of the frame should not be changed. */)
2727 (frame, cols, pretend)
2728 Lisp_Object frame, cols, pretend;
2730 register struct frame *f;
2731 CHECK_NUMBER (cols);
2732 if (NILP (frame))
2733 frame = selected_frame;
2734 CHECK_LIVE_FRAME (frame);
2735 f = XFRAME (frame);
2737 /* I think this should be done with a hook. */
2738 #ifdef HAVE_WINDOW_SYSTEM
2739 if (FRAME_WINDOW_P (f))
2741 if (XINT (cols) != FRAME_COLS (f))
2742 x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
2743 do_pending_window_change (0);
2745 else
2746 #endif
2747 change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0, 0);
2748 return Qnil;
2751 DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
2752 doc: /* Sets size of FRAME to COLS by ROWS, measured in characters. */)
2753 (frame, cols, rows)
2754 Lisp_Object frame, cols, rows;
2756 register struct frame *f;
2758 CHECK_LIVE_FRAME (frame);
2759 CHECK_NUMBER (cols);
2760 CHECK_NUMBER (rows);
2761 f = XFRAME (frame);
2763 /* I think this should be done with a hook. */
2764 #ifdef HAVE_WINDOW_SYSTEM
2765 if (FRAME_WINDOW_P (f))
2767 if (XINT (rows) != FRAME_LINES (f)
2768 || XINT (cols) != FRAME_COLS (f)
2769 || f->new_text_lines || f->new_text_cols)
2770 x_set_window_size (f, 1, XINT (cols), XINT (rows));
2771 do_pending_window_change (0);
2773 else
2774 #endif
2775 change_frame_size (f, XINT (rows), XINT (cols), 0, 0, 0);
2777 return Qnil;
2780 DEFUN ("set-frame-position", Fset_frame_position,
2781 Sset_frame_position, 3, 3, 0,
2782 doc: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2783 This is actually the position of the upper left corner of the frame.
2784 Negative values for XOFFSET or YOFFSET are interpreted relative to
2785 the rightmost or bottommost possible position (that stays within the screen). */)
2786 (frame, xoffset, yoffset)
2787 Lisp_Object frame, xoffset, yoffset;
2789 register struct frame *f;
2791 CHECK_LIVE_FRAME (frame);
2792 CHECK_NUMBER (xoffset);
2793 CHECK_NUMBER (yoffset);
2794 f = XFRAME (frame);
2796 /* I think this should be done with a hook. */
2797 #ifdef HAVE_WINDOW_SYSTEM
2798 if (FRAME_WINDOW_P (f))
2799 x_set_offset (f, XINT (xoffset), XINT (yoffset), 1);
2800 #endif
2802 return Qt;
2806 /***********************************************************************
2807 Frame Parameters
2808 ***********************************************************************/
2810 /* Connect the frame-parameter names for X frames
2811 to the ways of passing the parameter values to the window system.
2813 The name of a parameter, as a Lisp symbol,
2814 has an `x-frame-parameter' property which is an integer in Lisp
2815 that is an index in this table. */
2817 struct frame_parm_table {
2818 char *name;
2819 Lisp_Object *variable;
2822 static struct frame_parm_table frame_parms[] =
2824 {"auto-raise", &Qauto_raise},
2825 {"auto-lower", &Qauto_lower},
2826 {"background-color", 0},
2827 {"border-color", &Qborder_color},
2828 {"border-width", &Qborder_width},
2829 {"cursor-color", &Qcursor_color},
2830 {"cursor-type", &Qcursor_type},
2831 {"font", 0},
2832 {"foreground-color", 0},
2833 {"icon-name", &Qicon_name},
2834 {"icon-type", &Qicon_type},
2835 {"internal-border-width", &Qinternal_border_width},
2836 {"menu-bar-lines", &Qmenu_bar_lines},
2837 {"mouse-color", &Qmouse_color},
2838 {"name", &Qname},
2839 {"scroll-bar-width", &Qscroll_bar_width},
2840 {"title", &Qtitle},
2841 {"unsplittable", &Qunsplittable},
2842 {"vertical-scroll-bars", &Qvertical_scroll_bars},
2843 {"visibility", &Qvisibility},
2844 {"tool-bar-lines", &Qtool_bar_lines},
2845 {"scroll-bar-foreground", &Qscroll_bar_foreground},
2846 {"scroll-bar-background", &Qscroll_bar_background},
2847 {"screen-gamma", &Qscreen_gamma},
2848 {"line-spacing", &Qline_spacing},
2849 {"left-fringe", &Qleft_fringe},
2850 {"right-fringe", &Qright_fringe},
2851 {"wait-for-wm", &Qwait_for_wm},
2852 {"fullscreen", &Qfullscreen},
2853 #ifdef USE_FONT_BACKEND
2854 {"font-backend", &Qfont_backend}
2855 #endif /* USE_FONT_BACKEND */
2858 #ifdef HAVE_WINDOW_SYSTEM
2860 extern Lisp_Object Qbox;
2861 extern Lisp_Object Qtop;
2863 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
2864 wanted positions of the WM window (not Emacs window).
2865 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
2866 window (FRAME_X_WINDOW).
2869 void
2870 x_fullscreen_adjust (f, width, height, top_pos, left_pos)
2871 struct frame *f;
2872 int *width;
2873 int *height;
2874 int *top_pos;
2875 int *left_pos;
2877 int newwidth = FRAME_COLS (f);
2878 int newheight = FRAME_LINES (f);
2880 *top_pos = f->top_pos;
2881 *left_pos = f->left_pos;
2883 if (f->want_fullscreen & FULLSCREEN_HEIGHT)
2885 int ph;
2887 ph = FRAME_X_DISPLAY_INFO (f)->height;
2888 newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
2889 ph = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, newheight) - f->y_pixels_diff;
2890 newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
2891 *top_pos = 0;
2894 if (f->want_fullscreen & FULLSCREEN_WIDTH)
2896 int pw;
2898 pw = FRAME_X_DISPLAY_INFO (f)->width;
2899 newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
2900 pw = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, newwidth) - f->x_pixels_diff;
2901 newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
2902 *left_pos = 0;
2905 *width = newwidth;
2906 *height = newheight;
2910 /* Change the parameters of frame F as specified by ALIST.
2911 If a parameter is not specially recognized, do nothing special;
2912 otherwise call the `x_set_...' function for that parameter.
2913 Except for certain geometry properties, always call store_frame_param
2914 to store the new value in the parameter alist. */
2916 void
2917 x_set_frame_parameters (f, alist)
2918 FRAME_PTR f;
2919 Lisp_Object alist;
2921 Lisp_Object tail;
2923 /* If both of these parameters are present, it's more efficient to
2924 set them both at once. So we wait until we've looked at the
2925 entire list before we set them. */
2926 int width, height;
2928 /* Same here. */
2929 Lisp_Object left, top;
2931 /* Same with these. */
2932 Lisp_Object icon_left, icon_top;
2934 /* Record in these vectors all the parms specified. */
2935 Lisp_Object *parms;
2936 Lisp_Object *values;
2937 int i, p;
2938 int left_no_change = 0, top_no_change = 0;
2939 int icon_left_no_change = 0, icon_top_no_change = 0;
2940 int fullscreen_is_being_set = 0;
2942 struct gcpro gcpro1, gcpro2;
2944 i = 0;
2945 for (tail = alist; CONSP (tail); tail = Fcdr (tail))
2946 i++;
2948 parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
2949 values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
2951 /* Extract parm names and values into those vectors. */
2953 i = 0;
2954 for (tail = alist; CONSP (tail); tail = XCDR (tail))
2956 Lisp_Object elt;
2958 elt = XCAR (tail);
2959 parms[i] = Fcar (elt);
2960 values[i] = Fcdr (elt);
2961 i++;
2963 /* TAIL and ALIST are not used again below here. */
2964 alist = tail = Qnil;
2966 GCPRO2 (*parms, *values);
2967 gcpro1.nvars = i;
2968 gcpro2.nvars = i;
2970 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
2971 because their values appear in VALUES and strings are not valid. */
2972 top = left = Qunbound;
2973 icon_left = icon_top = Qunbound;
2975 /* Provide default values for HEIGHT and WIDTH. */
2976 width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
2977 height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
2979 /* Process foreground_color and background_color before anything else.
2980 They are independent of other properties, but other properties (e.g.,
2981 cursor_color) are dependent upon them. */
2982 /* Process default font as well, since fringe widths depends on it. */
2983 /* Also, process fullscreen, width and height depend upon that */
2984 for (p = 0; p < i; p++)
2986 Lisp_Object prop, val;
2988 prop = parms[p];
2989 val = values[p];
2990 if (EQ (prop, Qforeground_color)
2991 || EQ (prop, Qbackground_color)
2992 || EQ (prop, Qfont)
2993 || EQ (prop, Qfullscreen))
2995 register Lisp_Object param_index, old_value;
2996 int count = SPECPDL_INDEX ();
2998 old_value = get_frame_param (f, prop);
2999 fullscreen_is_being_set |= EQ (prop, Qfullscreen);
3001 if (NILP (Fequal (val, old_value)))
3003 /* For :font attributes, the frame_parm_handler
3004 x_set_font calls `face-set-after-frame-default'.
3005 Unless we bind inhibit-face-set-after-frame-default
3006 here, this would reset the :font attribute that we
3007 just applied to the default value for new faces. */
3008 specbind (Qinhibit_face_set_after_frame_default, Qt);
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);
3018 unbind_to (count, Qnil);
3023 /* Now process them in reverse of specified order. */
3024 for (i--; i >= 0; i--)
3026 Lisp_Object prop, val;
3028 prop = parms[i];
3029 val = values[i];
3031 if (EQ (prop, Qwidth) && NATNUMP (val))
3032 width = XFASTINT (val);
3033 else if (EQ (prop, Qheight) && NATNUMP (val))
3034 height = XFASTINT (val);
3035 else if (EQ (prop, Qtop))
3036 top = val;
3037 else if (EQ (prop, Qleft))
3038 left = val;
3039 else if (EQ (prop, Qicon_top))
3040 icon_top = val;
3041 else if (EQ (prop, Qicon_left))
3042 icon_left = val;
3043 else if (EQ (prop, Qforeground_color)
3044 || EQ (prop, Qbackground_color)
3045 || EQ (prop, Qfont)
3046 || EQ (prop, Qfullscreen))
3047 /* Processed above. */
3048 continue;
3049 else
3051 register Lisp_Object param_index, old_value;
3053 old_value = get_frame_param (f, prop);
3055 store_frame_param (f, prop, val);
3057 param_index = Fget (prop, Qx_frame_parameter);
3058 if (NATNUMP (param_index)
3059 && (XFASTINT (param_index)
3060 < sizeof (frame_parms)/sizeof (frame_parms[0]))
3061 && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
3062 (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
3066 /* Don't die if just one of these was set. */
3067 if (EQ (left, Qunbound))
3069 left_no_change = 1;
3070 if (f->left_pos < 0)
3071 left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
3072 else
3073 XSETINT (left, f->left_pos);
3075 if (EQ (top, Qunbound))
3077 top_no_change = 1;
3078 if (f->top_pos < 0)
3079 top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
3080 else
3081 XSETINT (top, f->top_pos);
3084 /* If one of the icon positions was not set, preserve or default it. */
3085 if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
3087 icon_left_no_change = 1;
3088 icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
3089 if (NILP (icon_left))
3090 XSETINT (icon_left, 0);
3092 if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
3094 icon_top_no_change = 1;
3095 icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
3096 if (NILP (icon_top))
3097 XSETINT (icon_top, 0);
3100 if (FRAME_VISIBLE_P (f) && fullscreen_is_being_set)
3102 /* If the frame is visible already and the fullscreen parameter is
3103 being set, it is too late to set WM manager hints to specify
3104 size and position.
3105 Here we first get the width, height and position that applies to
3106 fullscreen. We then move the frame to the appropriate
3107 position. Resize of the frame is taken care of in the code after
3108 this if-statement. */
3109 int new_left, new_top;
3111 x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
3112 if (new_top != f->top_pos || new_left != f->left_pos)
3113 x_set_offset (f, new_left, new_top, 1);
3116 /* Don't set these parameters unless they've been explicitly
3117 specified. The window might be mapped or resized while we're in
3118 this function, and we don't want to override that unless the lisp
3119 code has asked for it.
3121 Don't set these parameters unless they actually differ from the
3122 window's current parameters; the window may not actually exist
3123 yet. */
3125 Lisp_Object frame;
3127 check_frame_size (f, &height, &width);
3129 XSETFRAME (frame, f);
3131 if (width != FRAME_COLS (f)
3132 || height != FRAME_LINES (f)
3133 || f->new_text_lines || f->new_text_cols)
3134 Fset_frame_size (frame, make_number (width), make_number (height));
3136 if ((!NILP (left) || !NILP (top))
3137 && ! (left_no_change && top_no_change)
3138 && ! (NUMBERP (left) && XINT (left) == f->left_pos
3139 && NUMBERP (top) && XINT (top) == f->top_pos))
3141 int leftpos = 0;
3142 int toppos = 0;
3144 /* Record the signs. */
3145 f->size_hint_flags &= ~ (XNegative | YNegative);
3146 if (EQ (left, Qminus))
3147 f->size_hint_flags |= XNegative;
3148 else if (INTEGERP (left))
3150 leftpos = XINT (left);
3151 if (leftpos < 0)
3152 f->size_hint_flags |= XNegative;
3154 else if (CONSP (left) && EQ (XCAR (left), Qminus)
3155 && CONSP (XCDR (left))
3156 && INTEGERP (XCAR (XCDR (left))))
3158 leftpos = - XINT (XCAR (XCDR (left)));
3159 f->size_hint_flags |= XNegative;
3161 else if (CONSP (left) && EQ (XCAR (left), Qplus)
3162 && CONSP (XCDR (left))
3163 && INTEGERP (XCAR (XCDR (left))))
3165 leftpos = XINT (XCAR (XCDR (left)));
3168 if (EQ (top, Qminus))
3169 f->size_hint_flags |= YNegative;
3170 else if (INTEGERP (top))
3172 toppos = XINT (top);
3173 if (toppos < 0)
3174 f->size_hint_flags |= YNegative;
3176 else if (CONSP (top) && EQ (XCAR (top), Qminus)
3177 && CONSP (XCDR (top))
3178 && INTEGERP (XCAR (XCDR (top))))
3180 toppos = - XINT (XCAR (XCDR (top)));
3181 f->size_hint_flags |= YNegative;
3183 else if (CONSP (top) && EQ (XCAR (top), Qplus)
3184 && CONSP (XCDR (top))
3185 && INTEGERP (XCAR (XCDR (top))))
3187 toppos = XINT (XCAR (XCDR (top)));
3191 /* Store the numeric value of the position. */
3192 f->top_pos = toppos;
3193 f->left_pos = leftpos;
3195 f->win_gravity = NorthWestGravity;
3197 /* Actually set that position, and convert to absolute. */
3198 x_set_offset (f, leftpos, toppos, -1);
3201 if ((!NILP (icon_left) || !NILP (icon_top))
3202 && ! (icon_left_no_change && icon_top_no_change))
3203 x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
3206 UNGCPRO;
3210 /* Insert a description of internally-recorded parameters of frame X
3211 into the parameter alist *ALISTPTR that is to be given to the user.
3212 Only parameters that are specific to the X window system
3213 and whose values are not correctly recorded in the frame's
3214 param_alist need to be considered here. */
3216 void
3217 x_report_frame_params (f, alistptr)
3218 struct frame *f;
3219 Lisp_Object *alistptr;
3221 char buf[16];
3222 Lisp_Object tem;
3224 /* Represent negative positions (off the top or left screen edge)
3225 in a way that Fmodify_frame_parameters will understand correctly. */
3226 XSETINT (tem, f->left_pos);
3227 if (f->left_pos >= 0)
3228 store_in_alist (alistptr, Qleft, tem);
3229 else
3230 store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
3232 XSETINT (tem, f->top_pos);
3233 if (f->top_pos >= 0)
3234 store_in_alist (alistptr, Qtop, tem);
3235 else
3236 store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
3238 store_in_alist (alistptr, Qborder_width,
3239 make_number (f->border_width));
3240 store_in_alist (alistptr, Qinternal_border_width,
3241 make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
3242 store_in_alist (alistptr, Qleft_fringe,
3243 make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
3244 store_in_alist (alistptr, Qright_fringe,
3245 make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
3246 store_in_alist (alistptr, Qscroll_bar_width,
3247 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
3248 ? make_number (0)
3249 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
3250 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3251 /* nil means "use default width"
3252 for non-toolkit scroll bar.
3253 ruler-mode.el depends on this. */
3254 : Qnil));
3255 sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
3256 store_in_alist (alistptr, Qwindow_id,
3257 build_string (buf));
3258 #ifdef HAVE_X_WINDOWS
3259 #ifdef USE_X_TOOLKIT
3260 /* Tooltip frame may not have this widget. */
3261 if (FRAME_X_OUTPUT (f)->widget)
3262 #endif
3263 sprintf (buf, "%ld", (long) FRAME_OUTER_WINDOW (f));
3264 store_in_alist (alistptr, Qouter_window_id,
3265 build_string (buf));
3266 #endif
3267 store_in_alist (alistptr, Qicon_name, f->icon_name);
3268 FRAME_SAMPLE_VISIBILITY (f);
3269 store_in_alist (alistptr, Qvisibility,
3270 (FRAME_VISIBLE_P (f) ? Qt
3271 : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
3272 store_in_alist (alistptr, Qdisplay,
3273 XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element));
3275 if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO (f)->root_window)
3276 tem = Qnil;
3277 else
3278 XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
3279 store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
3280 store_in_alist (alistptr, Qparent_id, tem);
3284 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3285 the previous value of that parameter, NEW_VALUE is the new value. */
3287 void
3288 x_set_fullscreen (f, new_value, old_value)
3289 struct frame *f;
3290 Lisp_Object new_value, old_value;
3292 if (NILP (new_value))
3293 f->want_fullscreen = FULLSCREEN_NONE;
3294 else if (EQ (new_value, Qfullboth))
3295 f->want_fullscreen = FULLSCREEN_BOTH;
3296 else if (EQ (new_value, Qfullwidth))
3297 f->want_fullscreen = FULLSCREEN_WIDTH;
3298 else if (EQ (new_value, Qfullheight))
3299 f->want_fullscreen = FULLSCREEN_HEIGHT;
3301 if (FRAME_TERMINAL (f)->fullscreen_hook != NULL)
3302 FRAME_TERMINAL (f)->fullscreen_hook (f);
3306 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3307 the previous value of that parameter, NEW_VALUE is the new value. */
3309 void
3310 x_set_line_spacing (f, new_value, old_value)
3311 struct frame *f;
3312 Lisp_Object new_value, old_value;
3314 if (NILP (new_value))
3315 f->extra_line_spacing = 0;
3316 else if (NATNUMP (new_value))
3317 f->extra_line_spacing = XFASTINT (new_value);
3318 else
3319 signal_error ("Invalid line-spacing", new_value);
3320 if (FRAME_VISIBLE_P (f))
3321 redraw_frame (f);
3325 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3326 the previous value of that parameter, NEW_VALUE is the new value. */
3328 void
3329 x_set_screen_gamma (f, new_value, old_value)
3330 struct frame *f;
3331 Lisp_Object new_value, old_value;
3333 Lisp_Object bgcolor;
3335 if (NILP (new_value))
3336 f->gamma = 0;
3337 else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
3338 /* The value 0.4545 is the normal viewing gamma. */
3339 f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
3340 else
3341 signal_error ("Invalid screen-gamma", new_value);
3343 /* Apply the new gamma value to the frame background. */
3344 bgcolor = Fassq (Qbackground_color, f->param_alist);
3345 if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
3347 Lisp_Object index = Fget (Qbackground_color, Qx_frame_parameter);
3348 if (NATNUMP (index)
3349 && (XFASTINT (index)
3350 < sizeof (frame_parms)/sizeof (frame_parms[0]))
3351 && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
3352 (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
3353 (f, bgcolor, Qnil);
3356 Fclear_face_cache (Qnil);
3360 void
3361 x_set_font (f, arg, oldval)
3362 struct frame *f;
3363 Lisp_Object arg, oldval;
3365 Lisp_Object result;
3366 Lisp_Object fontset_name;
3367 Lisp_Object frame;
3368 int old_fontset = FRAME_FONTSET(f);
3370 #ifdef USE_FONT_BACKEND
3371 if (enable_font_backend)
3373 int fontset = -1;
3374 Lisp_Object font_object;
3376 /* ARG is a fontset name, a font name, or a font object.
3377 In the last case, this function never fail. */
3378 if (STRINGP (arg))
3380 fontset = fs_query_fontset (arg, 0);
3381 if (fontset < 0)
3382 font_object = font_open_by_name (f, SDATA (arg));
3383 else if (fontset > 0)
3385 Lisp_Object ascii_font = fontset_ascii (fontset);
3387 font_object = font_open_by_name (f, SDATA (ascii_font));
3390 else
3391 font_object = arg;
3393 if (fontset < 0 && ! NILP (font_object))
3394 fontset = new_fontset_from_font (font_object);
3396 if (fontset == 0)
3397 /* Refuse the default fontset. */
3398 result = Qt;
3399 else if (NILP (font_object))
3400 result = Qnil;
3401 else
3402 result = x_new_fontset2 (f, fontset, font_object);
3404 else
3406 #endif /* USE_FONT_BACKEND */
3407 CHECK_STRING (arg);
3409 fontset_name = Fquery_fontset (arg, Qnil);
3411 BLOCK_INPUT;
3412 result = (STRINGP (fontset_name)
3413 ? x_new_fontset (f, fontset_name)
3414 : x_new_fontset (f, arg));
3415 UNBLOCK_INPUT;
3416 #ifdef USE_FONT_BACKEND
3418 #endif
3420 if (EQ (result, Qnil))
3421 error ("Font `%s' is not defined", SDATA (arg));
3422 else if (EQ (result, Qt))
3423 error ("The default fontset can't be used for a frame font");
3424 else if (STRINGP (result))
3426 set_default_ascii_font (result);
3427 if (STRINGP (fontset_name))
3429 /* Fontset names are built from ASCII font names, so the
3430 names may be equal despite there was a change. */
3431 if (old_fontset == FRAME_FONTSET (f))
3432 return;
3434 store_frame_param (f, Qfont, result);
3436 if (!NILP (Fequal (result, oldval)))
3437 return;
3439 /* Recalculate toolbar height. */
3440 f->n_tool_bar_rows = 0;
3441 /* Ensure we redraw it. */
3442 clear_current_matrices (f);
3444 recompute_basic_faces (f);
3446 else
3447 abort ();
3449 do_pending_window_change (0);
3451 /* Don't call `face-set-after-frame-default' when faces haven't been
3452 initialized yet. This is the case when called from
3453 Fx_create_frame. In that case, the X widget or window doesn't
3454 exist either, and we can end up in x_report_frame_params with a
3455 null widget which gives a segfault. */
3456 if (FRAME_FACE_CACHE (f))
3458 XSETFRAME (frame, f);
3459 call1 (Qface_set_after_frame_default, frame);
3464 #ifdef USE_FONT_BACKEND
3465 void
3466 x_set_font_backend (f, new_value, old_value)
3467 struct frame *f;
3468 Lisp_Object new_value, old_value;
3470 if (! NILP (new_value)
3471 && !CONSP (new_value))
3473 char *p0, *p1;
3475 CHECK_STRING (new_value);
3476 p0 = p1 = SDATA (new_value);
3477 new_value = Qnil;
3478 while (*p0)
3480 while (*p1 && *p1 != ',') p1++;
3481 if (p0 < p1)
3482 new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
3483 new_value);
3484 if (*p1)
3485 p1++;
3486 p0 = p1;
3488 new_value = Fnreverse (new_value);
3491 if (! NILP (old_value) && ! NILP (Fequal (old_value, new_value)))
3492 return;
3494 if (FRAME_FONT_OBJECT (f))
3495 free_all_realized_faces (Qnil);
3497 new_value = font_update_drivers (f, NILP (new_value) ? Qt : new_value);
3498 if (NILP (new_value))
3500 if (NILP (old_value))
3501 error ("No font backend available");
3502 font_update_drivers (f, old_value);
3503 error ("None of specified font backends are available");
3505 store_frame_param (f, Qfont_backend, new_value);
3507 if (FRAME_FONT_OBJECT (f))
3509 Lisp_Object frame;
3511 XSETFRAME (frame, f);
3512 x_set_font (f, Fframe_parameter (frame, Qfont), Qnil);
3513 ++face_change_count;
3514 ++windows_or_buffers_changed;
3517 #endif /* USE_FONT_BACKEND */
3520 void
3521 x_set_fringe_width (f, new_value, old_value)
3522 struct frame *f;
3523 Lisp_Object new_value, old_value;
3525 compute_fringe_widths (f, 1);
3528 void
3529 x_set_border_width (f, arg, oldval)
3530 struct frame *f;
3531 Lisp_Object arg, oldval;
3533 CHECK_NUMBER (arg);
3535 if (XINT (arg) == f->border_width)
3536 return;
3538 if (FRAME_X_WINDOW (f) != 0)
3539 error ("Cannot change the border width of a frame");
3541 f->border_width = XINT (arg);
3544 void
3545 x_set_internal_border_width (f, arg, oldval)
3546 struct frame *f;
3547 Lisp_Object arg, oldval;
3549 int old = FRAME_INTERNAL_BORDER_WIDTH (f);
3551 CHECK_NUMBER (arg);
3552 FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
3553 if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
3554 FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
3556 #ifdef USE_X_TOOLKIT
3557 if (FRAME_X_OUTPUT (f)->edit_widget)
3558 widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
3559 #endif
3561 if (FRAME_INTERNAL_BORDER_WIDTH (f) == old)
3562 return;
3564 if (FRAME_X_WINDOW (f) != 0)
3566 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3567 SET_FRAME_GARBAGED (f);
3568 do_pending_window_change (0);
3570 else
3571 SET_FRAME_GARBAGED (f);
3574 void
3575 x_set_visibility (f, value, oldval)
3576 struct frame *f;
3577 Lisp_Object value, oldval;
3579 Lisp_Object frame;
3580 XSETFRAME (frame, f);
3582 if (NILP (value))
3583 Fmake_frame_invisible (frame, Qt);
3584 else if (EQ (value, Qicon))
3585 Ficonify_frame (frame);
3586 else
3587 Fmake_frame_visible (frame);
3590 void
3591 x_set_autoraise (f, arg, oldval)
3592 struct frame *f;
3593 Lisp_Object arg, oldval;
3595 f->auto_raise = !EQ (Qnil, arg);
3598 void
3599 x_set_autolower (f, arg, oldval)
3600 struct frame *f;
3601 Lisp_Object arg, oldval;
3603 f->auto_lower = !EQ (Qnil, arg);
3606 void
3607 x_set_unsplittable (f, arg, oldval)
3608 struct frame *f;
3609 Lisp_Object arg, oldval;
3611 f->no_split = !NILP (arg);
3614 void
3615 x_set_vertical_scroll_bars (f, arg, oldval)
3616 struct frame *f;
3617 Lisp_Object arg, oldval;
3619 if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
3620 || (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
3621 || (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
3622 || (!NILP (arg) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
3624 FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
3625 = (NILP (arg)
3626 ? vertical_scroll_bar_none
3627 : EQ (Qleft, arg)
3628 ? vertical_scroll_bar_left
3629 : EQ (Qright, arg)
3630 ? vertical_scroll_bar_right
3631 : EQ (Qleft, Vdefault_frame_scroll_bars)
3632 ? vertical_scroll_bar_left
3633 : EQ (Qright, Vdefault_frame_scroll_bars)
3634 ? vertical_scroll_bar_right
3635 : vertical_scroll_bar_none);
3637 /* We set this parameter before creating the X window for the
3638 frame, so we can get the geometry right from the start.
3639 However, if the window hasn't been created yet, we shouldn't
3640 call x_set_window_size. */
3641 if (FRAME_X_WINDOW (f))
3642 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3643 do_pending_window_change (0);
3647 void
3648 x_set_scroll_bar_width (f, arg, oldval)
3649 struct frame *f;
3650 Lisp_Object arg, oldval;
3652 int wid = FRAME_COLUMN_WIDTH (f);
3654 if (NILP (arg))
3656 x_set_scroll_bar_default_width (f);
3658 if (FRAME_X_WINDOW (f))
3659 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3660 do_pending_window_change (0);
3662 else if (INTEGERP (arg) && XINT (arg) > 0
3663 && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3665 if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
3666 XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1);
3668 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
3669 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
3670 if (FRAME_X_WINDOW (f))
3671 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
3672 do_pending_window_change (0);
3675 change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
3676 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
3677 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
3682 /* Return non-nil if frame F wants a bitmap icon. */
3684 Lisp_Object
3685 x_icon_type (f)
3686 FRAME_PTR f;
3688 Lisp_Object tem;
3690 tem = assq_no_quit (Qicon_type, f->param_alist);
3691 if (CONSP (tem))
3692 return XCDR (tem);
3693 else
3694 return Qnil;
3698 /* Subroutines of creating an X frame. */
3700 /* Make sure that Vx_resource_name is set to a reasonable value.
3701 Fix it up, or set it to `emacs' if it is too hopeless. */
3703 void
3704 validate_x_resource_name ()
3706 int len = 0;
3707 /* Number of valid characters in the resource name. */
3708 int good_count = 0;
3709 /* Number of invalid characters in the resource name. */
3710 int bad_count = 0;
3711 Lisp_Object new;
3712 int i;
3714 if (!STRINGP (Vx_resource_class))
3715 Vx_resource_class = build_string (EMACS_CLASS);
3717 if (STRINGP (Vx_resource_name))
3719 unsigned char *p = SDATA (Vx_resource_name);
3720 int i;
3722 len = SBYTES (Vx_resource_name);
3724 /* Only letters, digits, - and _ are valid in resource names.
3725 Count the valid characters and count the invalid ones. */
3726 for (i = 0; i < len; i++)
3728 int c = p[i];
3729 if (! ((c >= 'a' && c <= 'z')
3730 || (c >= 'A' && c <= 'Z')
3731 || (c >= '0' && c <= '9')
3732 || c == '-' || c == '_'))
3733 bad_count++;
3734 else
3735 good_count++;
3738 else
3739 /* Not a string => completely invalid. */
3740 bad_count = 5, good_count = 0;
3742 /* If name is valid already, return. */
3743 if (bad_count == 0)
3744 return;
3746 /* If name is entirely invalid, or nearly so, use `emacs'. */
3747 if (good_count == 0
3748 || (good_count == 1 && bad_count > 0))
3750 Vx_resource_name = build_string ("emacs");
3751 return;
3754 /* Name is partly valid. Copy it and replace the invalid characters
3755 with underscores. */
3757 Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
3759 for (i = 0; i < len; i++)
3761 int c = SREF (new, i);
3762 if (! ((c >= 'a' && c <= 'z')
3763 || (c >= 'A' && c <= 'Z')
3764 || (c >= '0' && c <= '9')
3765 || c == '-' || c == '_'))
3766 SSET (new, i, '_');
3771 extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
3772 extern Display_Info *check_x_display_info P_ ((Lisp_Object));
3775 /* Get specified attribute from resource database RDB.
3776 See Fx_get_resource below for other parameters. */
3778 static Lisp_Object
3779 xrdb_get_resource (rdb, attribute, class, component, subclass)
3780 XrmDatabase rdb;
3781 Lisp_Object attribute, class, component, subclass;
3783 register char *value;
3784 char *name_key;
3785 char *class_key;
3787 CHECK_STRING (attribute);
3788 CHECK_STRING (class);
3790 if (!NILP (component))
3791 CHECK_STRING (component);
3792 if (!NILP (subclass))
3793 CHECK_STRING (subclass);
3794 if (NILP (component) != NILP (subclass))
3795 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
3797 validate_x_resource_name ();
3799 /* Allocate space for the components, the dots which separate them,
3800 and the final '\0'. Make them big enough for the worst case. */
3801 name_key = (char *) alloca (SBYTES (Vx_resource_name)
3802 + (STRINGP (component)
3803 ? SBYTES (component) : 0)
3804 + SBYTES (attribute)
3805 + 3);
3807 class_key = (char *) alloca (SBYTES (Vx_resource_class)
3808 + SBYTES (class)
3809 + (STRINGP (subclass)
3810 ? SBYTES (subclass) : 0)
3811 + 3);
3813 /* Start with emacs.FRAMENAME for the name (the specific one)
3814 and with `Emacs' for the class key (the general one). */
3815 strcpy (name_key, SDATA (Vx_resource_name));
3816 strcpy (class_key, SDATA (Vx_resource_class));
3818 strcat (class_key, ".");
3819 strcat (class_key, SDATA (class));
3821 if (!NILP (component))
3823 strcat (class_key, ".");
3824 strcat (class_key, SDATA (subclass));
3826 strcat (name_key, ".");
3827 strcat (name_key, SDATA (component));
3830 strcat (name_key, ".");
3831 strcat (name_key, SDATA (attribute));
3833 value = x_get_string_resource (rdb, name_key, class_key);
3835 if (value != (char *) 0)
3836 return build_string (value);
3837 else
3838 return Qnil;
3842 DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
3843 doc: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
3844 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
3845 class, where INSTANCE is the name under which Emacs was invoked, or
3846 the name specified by the `-name' or `-rn' command-line arguments.
3848 The optional arguments COMPONENT and SUBCLASS add to the key and the
3849 class, respectively. You must specify both of them or neither.
3850 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
3851 and the class is `Emacs.CLASS.SUBCLASS'. */)
3852 (attribute, class, component, subclass)
3853 Lisp_Object attribute, class, component, subclass;
3855 #ifdef HAVE_X_WINDOWS
3856 check_x ();
3857 #endif
3859 return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
3860 attribute, class, component, subclass);
3863 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
3865 Lisp_Object
3866 display_x_get_resource (dpyinfo, attribute, class, component, subclass)
3867 Display_Info *dpyinfo;
3868 Lisp_Object attribute, class, component, subclass;
3870 return xrdb_get_resource (dpyinfo->xrdb,
3871 attribute, class, component, subclass);
3874 /* Used when C code wants a resource value. */
3876 char *
3877 x_get_resource_string (attribute, class)
3878 char *attribute, *class;
3880 char *name_key;
3881 char *class_key;
3882 struct frame *sf = SELECTED_FRAME ();
3884 /* Allocate space for the components, the dots which separate them,
3885 and the final '\0'. */
3886 name_key = (char *) alloca (SBYTES (Vinvocation_name)
3887 + strlen (attribute) + 2);
3888 class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
3889 + strlen (class) + 2);
3891 sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
3892 sprintf (class_key, "%s.%s", EMACS_CLASS, class);
3894 return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
3895 name_key, class_key);
3899 /* Return the value of parameter PARAM.
3901 First search ALIST, then Vdefault_frame_alist, then the X defaults
3902 database, using ATTRIBUTE as the attribute name and CLASS as its class.
3904 Convert the resource to the type specified by desired_type.
3906 If no default is specified, return Qunbound. If you call
3907 x_get_arg, make sure you deal with Qunbound in a reasonable way,
3908 and don't let it get stored in any Lisp-visible variables! */
3910 Lisp_Object
3911 x_get_arg (dpyinfo, alist, param, attribute, class, type)
3912 Display_Info *dpyinfo;
3913 Lisp_Object alist, param;
3914 char *attribute;
3915 char *class;
3916 enum resource_types type;
3918 register Lisp_Object tem;
3920 tem = Fassq (param, alist);
3922 if (!NILP (tem))
3924 /* If we find this parm in ALIST, clear it out
3925 so that it won't be "left over" at the end. */
3926 #ifndef WINDOWSNT /* w32fns.c has not yet been changed to cope with this. */
3927 Lisp_Object tail;
3928 XSETCAR (tem, Qnil);
3929 /* In case the parameter appears more than once in the alist,
3930 clear it out. */
3931 for (tail = alist; CONSP (tail); tail = XCDR (tail))
3932 if (CONSP (XCAR (tail))
3933 && EQ (XCAR (XCAR (tail)), param))
3934 XSETCAR (XCAR (tail), Qnil);
3935 #endif
3937 else
3938 tem = Fassq (param, Vdefault_frame_alist);
3940 /* If it wasn't specified in ALIST or the Lisp-level defaults,
3941 look in the X resources. */
3942 if (EQ (tem, Qnil))
3944 if (attribute)
3946 tem = display_x_get_resource (dpyinfo,
3947 build_string (attribute),
3948 build_string (class),
3949 Qnil, Qnil);
3951 if (NILP (tem))
3952 return Qunbound;
3954 switch (type)
3956 case RES_TYPE_NUMBER:
3957 return make_number (atoi (SDATA (tem)));
3959 case RES_TYPE_FLOAT:
3960 return make_float (atof (SDATA (tem)));
3962 case RES_TYPE_BOOLEAN:
3963 tem = Fdowncase (tem);
3964 if (!strcmp (SDATA (tem), "on")
3965 || !strcmp (SDATA (tem), "true"))
3966 return Qt;
3967 else
3968 return Qnil;
3970 case RES_TYPE_STRING:
3971 return tem;
3973 case RES_TYPE_SYMBOL:
3974 /* As a special case, we map the values `true' and `on'
3975 to Qt, and `false' and `off' to Qnil. */
3977 Lisp_Object lower;
3978 lower = Fdowncase (tem);
3979 if (!strcmp (SDATA (lower), "on")
3980 || !strcmp (SDATA (lower), "true"))
3981 return Qt;
3982 else if (!strcmp (SDATA (lower), "off")
3983 || !strcmp (SDATA (lower), "false"))
3984 return Qnil;
3985 else
3986 return Fintern (tem, Qnil);
3989 default:
3990 abort ();
3993 else
3994 return Qunbound;
3996 return Fcdr (tem);
3999 Lisp_Object
4000 x_frame_get_arg (f, alist, param, attribute, class, type)
4001 struct frame *f;
4002 Lisp_Object alist, param;
4003 char *attribute;
4004 char *class;
4005 enum resource_types type;
4007 return x_get_arg (FRAME_X_DISPLAY_INFO (f),
4008 alist, param, attribute, class, type);
4011 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
4013 Lisp_Object
4014 x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
4015 struct frame *f;
4016 Lisp_Object alist, param;
4017 char *attribute;
4018 char *class;
4019 enum resource_types type;
4021 Lisp_Object value;
4023 value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
4024 attribute, class, type);
4025 if (! NILP (value) && ! EQ (value, Qunbound))
4026 store_frame_param (f, param, value);
4028 return value;
4032 /* Record in frame F the specified or default value according to ALIST
4033 of the parameter named PROP (a Lisp symbol).
4034 If no value is specified for PROP, look for an X default for XPROP
4035 on the frame named NAME.
4036 If that is not found either, use the value DEFLT. */
4038 Lisp_Object
4039 x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
4040 struct frame *f;
4041 Lisp_Object alist;
4042 Lisp_Object prop;
4043 Lisp_Object deflt;
4044 char *xprop;
4045 char *xclass;
4046 enum resource_types type;
4048 Lisp_Object tem;
4050 tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
4051 if (EQ (tem, Qunbound))
4052 tem = deflt;
4053 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
4054 return tem;
4060 DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
4061 doc: /* Parse an X-style geometry string STRING.
4062 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
4063 The properties returned may include `top', `left', `height', and `width'.
4064 The value of `left' or `top' may be an integer,
4065 or a list (+ N) meaning N pixels relative to top/left corner,
4066 or a list (- N) meaning -N pixels relative to bottom/right corner. */)
4067 (string)
4068 Lisp_Object string;
4070 int geometry, x, y;
4071 unsigned int width, height;
4072 Lisp_Object result;
4074 CHECK_STRING (string);
4076 geometry = XParseGeometry ((char *) SDATA (string),
4077 &x, &y, &width, &height);
4079 #if 0
4080 if (!!(geometry & XValue) != !!(geometry & YValue))
4081 error ("Must specify both x and y position, or neither");
4082 #endif
4084 result = Qnil;
4085 if (geometry & XValue)
4087 Lisp_Object element;
4089 if (x >= 0 && (geometry & XNegative))
4090 element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
4091 else if (x < 0 && ! (geometry & XNegative))
4092 element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
4093 else
4094 element = Fcons (Qleft, make_number (x));
4095 result = Fcons (element, result);
4098 if (geometry & YValue)
4100 Lisp_Object element;
4102 if (y >= 0 && (geometry & YNegative))
4103 element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
4104 else if (y < 0 && ! (geometry & YNegative))
4105 element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
4106 else
4107 element = Fcons (Qtop, make_number (y));
4108 result = Fcons (element, result);
4111 if (geometry & WidthValue)
4112 result = Fcons (Fcons (Qwidth, make_number (width)), result);
4113 if (geometry & HeightValue)
4114 result = Fcons (Fcons (Qheight, make_number (height)), result);
4116 return result;
4119 /* Calculate the desired size and position of frame F.
4120 Return the flags saying which aspects were specified.
4122 Also set the win_gravity and size_hint_flags of F.
4124 Adjust height for toolbar if TOOLBAR_P is 1.
4126 This function does not make the coordinates positive. */
4128 #define DEFAULT_ROWS 40
4129 #define DEFAULT_COLS 80
4132 x_figure_window_size (f, parms, toolbar_p)
4133 struct frame *f;
4134 Lisp_Object parms;
4135 int toolbar_p;
4137 register Lisp_Object tem0, tem1, tem2;
4138 long window_prompting = 0;
4139 Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
4141 /* Default values if we fall through.
4142 Actually, if that happens we should get
4143 window manager prompting. */
4144 SET_FRAME_COLS (f, DEFAULT_COLS);
4145 FRAME_LINES (f) = DEFAULT_ROWS;
4146 /* Window managers expect that if program-specified
4147 positions are not (0,0), they're intentional, not defaults. */
4148 f->top_pos = 0;
4149 f->left_pos = 0;
4151 /* Ensure that old new_text_cols and new_text_lines will not override the
4152 values set here. */
4153 /* ++KFS: This was specific to W32, but seems ok for all platforms */
4154 f->new_text_cols = f->new_text_lines = 0;
4156 tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
4157 tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
4158 tem2 = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
4159 if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
4161 if (!EQ (tem0, Qunbound))
4163 CHECK_NUMBER (tem0);
4164 FRAME_LINES (f) = XINT (tem0);
4166 if (!EQ (tem1, Qunbound))
4168 CHECK_NUMBER (tem1);
4169 SET_FRAME_COLS (f, XINT (tem1));
4171 if (!NILP (tem2) && !EQ (tem2, Qunbound))
4172 window_prompting |= USSize;
4173 else
4174 window_prompting |= PSize;
4177 f->scroll_bar_actual_width
4178 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
4180 /* This used to be done _before_ calling x_figure_window_size, but
4181 since the height is reset here, this was really a no-op. I
4182 assume that moving it here does what Gerd intended (although he
4183 no longer can remember what that was... ++KFS, 2003-03-25. */
4185 /* Add the tool-bar height to the initial frame height so that the
4186 user gets a text display area of the size he specified with -g or
4187 via .Xdefaults. Later changes of the tool-bar height don't
4188 change the frame size. This is done so that users can create
4189 tall Emacs frames without having to guess how tall the tool-bar
4190 will get. */
4191 if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
4193 int margin, relief, bar_height;
4195 relief = (tool_bar_button_relief >= 0
4196 ? tool_bar_button_relief
4197 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
4199 if (INTEGERP (Vtool_bar_button_margin)
4200 && XINT (Vtool_bar_button_margin) > 0)
4201 margin = XFASTINT (Vtool_bar_button_margin);
4202 else if (CONSP (Vtool_bar_button_margin)
4203 && INTEGERP (XCDR (Vtool_bar_button_margin))
4204 && XINT (XCDR (Vtool_bar_button_margin)) > 0)
4205 margin = XFASTINT (XCDR (Vtool_bar_button_margin));
4206 else
4207 margin = 0;
4209 bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
4210 FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
4213 compute_fringe_widths (f, 0);
4215 FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
4216 FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
4218 tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
4219 tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
4220 tem2 = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
4221 if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
4223 if (EQ (tem0, Qminus))
4225 f->top_pos = 0;
4226 window_prompting |= YNegative;
4228 else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
4229 && CONSP (XCDR (tem0))
4230 && INTEGERP (XCAR (XCDR (tem0))))
4232 f->top_pos = - XINT (XCAR (XCDR (tem0)));
4233 window_prompting |= YNegative;
4235 else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
4236 && CONSP (XCDR (tem0))
4237 && INTEGERP (XCAR (XCDR (tem0))))
4239 f->top_pos = XINT (XCAR (XCDR (tem0)));
4241 else if (EQ (tem0, Qunbound))
4242 f->top_pos = 0;
4243 else
4245 CHECK_NUMBER (tem0);
4246 f->top_pos = XINT (tem0);
4247 if (f->top_pos < 0)
4248 window_prompting |= YNegative;
4251 if (EQ (tem1, Qminus))
4253 f->left_pos = 0;
4254 window_prompting |= XNegative;
4256 else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
4257 && CONSP (XCDR (tem1))
4258 && INTEGERP (XCAR (XCDR (tem1))))
4260 f->left_pos = - XINT (XCAR (XCDR (tem1)));
4261 window_prompting |= XNegative;
4263 else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
4264 && CONSP (XCDR (tem1))
4265 && INTEGERP (XCAR (XCDR (tem1))))
4267 f->left_pos = XINT (XCAR (XCDR (tem1)));
4269 else if (EQ (tem1, Qunbound))
4270 f->left_pos = 0;
4271 else
4273 CHECK_NUMBER (tem1);
4274 f->left_pos = XINT (tem1);
4275 if (f->left_pos < 0)
4276 window_prompting |= XNegative;
4279 if (!NILP (tem2) && ! EQ (tem2, Qunbound))
4280 window_prompting |= USPosition;
4281 else
4282 window_prompting |= PPosition;
4285 if (f->want_fullscreen != FULLSCREEN_NONE)
4287 int left, top;
4288 int width, height;
4290 /* It takes both for some WM:s to place it where we want */
4291 window_prompting |= USPosition | PPosition;
4292 x_fullscreen_adjust (f, &width, &height, &top, &left);
4293 FRAME_COLS (f) = width;
4294 FRAME_LINES (f) = height;
4295 FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
4296 FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
4297 f->left_pos = left;
4298 f->top_pos = top;
4301 if (window_prompting & XNegative)
4303 if (window_prompting & YNegative)
4304 f->win_gravity = SouthEastGravity;
4305 else
4306 f->win_gravity = NorthEastGravity;
4308 else
4310 if (window_prompting & YNegative)
4311 f->win_gravity = SouthWestGravity;
4312 else
4313 f->win_gravity = NorthWestGravity;
4316 f->size_hint_flags = window_prompting;
4318 return window_prompting;
4323 #endif /* HAVE_WINDOW_SYSTEM */
4327 /***********************************************************************
4328 Initialization
4329 ***********************************************************************/
4331 void
4332 syms_of_frame ()
4334 Qframep = intern ("framep");
4335 staticpro (&Qframep);
4336 Qframe_live_p = intern ("frame-live-p");
4337 staticpro (&Qframe_live_p);
4338 Qexplicit_name = intern ("explicit-name");
4339 staticpro (&Qexplicit_name);
4340 Qheight = intern ("height");
4341 staticpro (&Qheight);
4342 Qicon = intern ("icon");
4343 staticpro (&Qicon);
4344 Qminibuffer = intern ("minibuffer");
4345 staticpro (&Qminibuffer);
4346 Qmodeline = intern ("modeline");
4347 staticpro (&Qmodeline);
4348 Qonly = intern ("only");
4349 staticpro (&Qonly);
4350 Qwidth = intern ("width");
4351 staticpro (&Qwidth);
4352 Qgeometry = intern ("geometry");
4353 staticpro (&Qgeometry);
4354 Qicon_left = intern ("icon-left");
4355 staticpro (&Qicon_left);
4356 Qicon_top = intern ("icon-top");
4357 staticpro (&Qicon_top);
4358 Qleft = intern ("left");
4359 staticpro (&Qleft);
4360 Qright = intern ("right");
4361 staticpro (&Qright);
4362 Quser_position = intern ("user-position");
4363 staticpro (&Quser_position);
4364 Quser_size = intern ("user-size");
4365 staticpro (&Quser_size);
4366 Qwindow_id = intern ("window-id");
4367 staticpro (&Qwindow_id);
4368 #ifdef HAVE_X_WINDOWS
4369 Qouter_window_id = intern ("outer-window-id");
4370 staticpro (&Qouter_window_id);
4371 #endif
4372 Qparent_id = intern ("parent-id");
4373 staticpro (&Qparent_id);
4374 Qx = intern ("x");
4375 staticpro (&Qx);
4376 Qw32 = intern ("w32");
4377 staticpro (&Qw32);
4378 Qpc = intern ("pc");
4379 staticpro (&Qpc);
4380 Qmac = intern ("mac");
4381 staticpro (&Qmac);
4382 Qvisible = intern ("visible");
4383 staticpro (&Qvisible);
4384 Qbuffer_predicate = intern ("buffer-predicate");
4385 staticpro (&Qbuffer_predicate);
4386 Qbuffer_list = intern ("buffer-list");
4387 staticpro (&Qbuffer_list);
4388 Qburied_buffer_list = intern ("buried-buffer-list");
4389 staticpro (&Qburied_buffer_list);
4390 Qdisplay_type = intern ("display-type");
4391 staticpro (&Qdisplay_type);
4392 Qbackground_mode = intern ("background-mode");
4393 staticpro (&Qbackground_mode);
4394 Qnoelisp = intern ("noelisp");
4395 staticpro (&Qnoelisp);
4396 Qtty_color_mode = intern ("tty-color-mode");
4397 staticpro (&Qtty_color_mode);
4398 Qtty = intern ("tty");
4399 staticpro (&Qtty);
4400 Qtty_type = intern ("tty-type");
4401 staticpro (&Qtty_type);
4403 Qface_set_after_frame_default = intern ("face-set-after-frame-default");
4404 staticpro (&Qface_set_after_frame_default);
4406 Qinhibit_face_set_after_frame_default
4407 = intern ("inhibit-face-set-after-frame-default");
4408 staticpro (&Qinhibit_face_set_after_frame_default);
4410 Qfullwidth = intern ("fullwidth");
4411 staticpro (&Qfullwidth);
4412 Qfullheight = intern ("fullheight");
4413 staticpro (&Qfullheight);
4414 Qfullboth = intern ("fullboth");
4415 staticpro (&Qfullboth);
4416 Qx_resource_name = intern ("x-resource-name");
4417 staticpro (&Qx_resource_name);
4419 Qx_frame_parameter = intern ("x-frame-parameter");
4420 staticpro (&Qx_frame_parameter);
4422 Qterminal = intern ("terminal");
4423 staticpro (&Qterminal);
4424 Qterminal_live_p = intern ("terminal-live-p");
4425 staticpro (&Qterminal_live_p);
4428 int i;
4430 for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
4432 Lisp_Object v = intern (frame_parms[i].name);
4433 if (frame_parms[i].variable)
4435 *frame_parms[i].variable = v;
4436 staticpro (frame_parms[i].variable);
4438 Fput (v, Qx_frame_parameter, make_number (i));
4442 #ifdef HAVE_WINDOW_SYSTEM
4443 DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
4444 doc: /* The name Emacs uses to look up X resources.
4445 `x-get-resource' uses this as the first component of the instance name
4446 when requesting resource values.
4447 Emacs initially sets `x-resource-name' to the name under which Emacs
4448 was invoked, or to the value specified with the `-name' or `-rn'
4449 switches, if present.
4451 It may be useful to bind this variable locally around a call
4452 to `x-get-resource'. See also the variable `x-resource-class'. */);
4453 Vx_resource_name = Qnil;
4455 DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
4456 doc: /* The class Emacs uses to look up X resources.
4457 `x-get-resource' uses this as the first component of the instance class
4458 when requesting resource values.
4460 Emacs initially sets `x-resource-class' to "Emacs".
4462 Setting this variable permanently is not a reasonable thing to do,
4463 but binding this variable locally around a call to `x-get-resource'
4464 is a reasonable practice. See also the variable `x-resource-name'. */);
4465 Vx_resource_class = build_string (EMACS_CLASS);
4466 #endif
4468 DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
4469 doc: /* Alist of default values for frame creation.
4470 These may be set in your init file, like this:
4471 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
4472 These override values given in window system configuration data,
4473 including X Windows' defaults database.
4474 For values specific to the first Emacs frame, see `initial-frame-alist'.
4475 For window-system specific values, see `window-system-default-frame-alist'.
4476 For values specific to the separate minibuffer frame, see
4477 `minibuffer-frame-alist'.
4478 The `menu-bar-lines' element of the list controls whether new frames
4479 have menu bars; `menu-bar-mode' works by altering this element.
4480 Setting this variable does not affect existing frames, only new ones. */);
4481 Vdefault_frame_alist = Qnil;
4483 DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars,
4484 doc: /* Default position of scroll bars on this window-system. */);
4485 #ifdef HAVE_WINDOW_SYSTEM
4486 #if defined(HAVE_NTGUI) || defined(MAC_OS)
4487 /* MS-Windows has scroll bars on the right by default. */
4488 Vdefault_frame_scroll_bars = Qright;
4489 #else
4490 Vdefault_frame_scroll_bars = Qleft;
4491 #endif
4492 #else
4493 Vdefault_frame_scroll_bars = Qnil;
4494 #endif
4496 DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
4497 doc: /* The initial frame-object, which represents Emacs's stdout. */);
4499 DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
4500 doc: /* Non-nil if all of Emacs is iconified and frame updates are not needed. */);
4501 Vemacs_iconified = Qnil;
4503 DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
4504 doc: /* If non-nil, function to transform normal value of `mouse-position'.
4505 `mouse-position' calls this function, passing its usual return value as
4506 argument, and returns whatever this function returns.
4507 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
4508 which need to do mouse handling at the Lisp level. */);
4509 Vmouse_position_function = Qnil;
4511 DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
4512 doc: /* If non-nil, clickable text is highlighted when mouse is over it.
4513 If the value is an integer, highlighting is only shown after moving the
4514 mouse, while keyboard input turns off the highlight even when the mouse
4515 is over the clickable text. However, the mouse shape still indicates
4516 when the mouse is over clickable text. */);
4517 Vmouse_highlight = Qt;
4519 DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
4520 doc: /* Functions to be run before deleting a frame.
4521 The functions are run with one arg, the frame to be deleted.
4522 See `delete-frame'.
4524 Note that functions in this list may be called just before the frame is
4525 actually deleted, or some time later (or even both when an earlier function
4526 in `delete-frame-functions' (indirectly) calls `delete-frame'
4527 recursively). */);
4528 Vdelete_frame_functions = Qnil;
4529 Qdelete_frame_functions = intern ("delete-frame-functions");
4530 staticpro (&Qdelete_frame_functions);
4532 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
4533 doc: /* Minibufferless frames use this frame's minibuffer.
4535 Emacs cannot create minibufferless frames unless this is set to an
4536 appropriate surrogate.
4538 Emacs consults this variable only when creating minibufferless
4539 frames; once the frame is created, it sticks with its assigned
4540 minibuffer, no matter what this variable is set to. This means that
4541 this variable doesn't necessarily say anything meaningful about the
4542 current set of frames, or where the minibuffer is currently being
4543 displayed.
4545 This variable is local to the current terminal and cannot be buffer-local. */);
4547 DEFVAR_BOOL ("focus-follows-mouse", &focus_follows_mouse,
4548 doc: /* Non-nil if window system changes focus when you move the mouse.
4549 You should set this variable to tell Emacs how your window manager
4550 handles focus, since there is no way in general for Emacs to find out
4551 automatically. */);
4552 #ifdef HAVE_WINDOW_SYSTEM
4553 #if defined(HAVE_NTGUI) || defined(MAC_OS)
4554 focus_follows_mouse = 0;
4555 #else
4556 focus_follows_mouse = 1;
4557 #endif
4558 #else
4559 focus_follows_mouse = 0;
4560 #endif
4562 staticpro (&Vframe_list);
4564 defsubr (&Sactive_minibuffer_window);
4565 defsubr (&Sframep);
4566 defsubr (&Sframe_live_p);
4567 defsubr (&Swindow_system);
4568 defsubr (&Smake_terminal_frame);
4569 defsubr (&Shandle_switch_frame);
4570 defsubr (&Sselect_frame);
4571 defsubr (&Sselected_frame);
4572 defsubr (&Swindow_frame);
4573 defsubr (&Sframe_root_window);
4574 defsubr (&Sframe_first_window);
4575 defsubr (&Sframe_selected_window);
4576 defsubr (&Sset_frame_selected_window);
4577 defsubr (&Sframe_list);
4578 defsubr (&Snext_frame);
4579 defsubr (&Sprevious_frame);
4580 defsubr (&Sdelete_frame);
4581 defsubr (&Smouse_position);
4582 defsubr (&Smouse_pixel_position);
4583 defsubr (&Sset_mouse_position);
4584 defsubr (&Sset_mouse_pixel_position);
4585 #if 0
4586 defsubr (&Sframe_configuration);
4587 defsubr (&Srestore_frame_configuration);
4588 #endif
4589 defsubr (&Smake_frame_visible);
4590 defsubr (&Smake_frame_invisible);
4591 defsubr (&Siconify_frame);
4592 defsubr (&Sframe_visible_p);
4593 defsubr (&Svisible_frame_list);
4594 defsubr (&Sraise_frame);
4595 defsubr (&Slower_frame);
4596 defsubr (&Sredirect_frame_focus);
4597 defsubr (&Sframe_focus);
4598 defsubr (&Sframe_parameters);
4599 defsubr (&Sframe_parameter);
4600 defsubr (&Smodify_frame_parameters);
4601 defsubr (&Sframe_char_height);
4602 defsubr (&Sframe_char_width);
4603 defsubr (&Sframe_pixel_height);
4604 defsubr (&Sframe_pixel_width);
4605 defsubr (&Sset_frame_height);
4606 defsubr (&Sset_frame_width);
4607 defsubr (&Sset_frame_size);
4608 defsubr (&Sset_frame_position);
4610 #ifdef HAVE_WINDOW_SYSTEM
4611 defsubr (&Sx_get_resource);
4612 defsubr (&Sx_parse_geometry);
4613 #endif
4617 /* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
4618 (do not change this comment) */