Address some compilation warnings.
[emacs.git] / src / frame.c
blobe3ad82f5f808b2e15f7516e229b4ad685403ca6c
1 /* Generic frame functions.
3 Copyright (C) 1993-1995, 1997, 1999-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
22 #include <stdio.h>
23 #include <errno.h>
24 #include <limits.h>
26 #include <c-ctype.h>
28 #include "lisp.h"
29 #include "character.h"
31 #ifdef HAVE_WINDOW_SYSTEM
32 #include TERM_HEADER
33 #endif /* HAVE_WINDOW_SYSTEM */
35 #include "buffer.h"
36 /* These help us bind and responding to switch-frame events. */
37 #include "commands.h"
38 #include "keyboard.h"
39 #include "frame.h"
40 #include "blockinput.h"
41 #include "termchar.h"
42 #include "termhooks.h"
43 #include "dispextern.h"
44 #include "window.h"
45 #include "font.h"
46 #ifdef HAVE_WINDOW_SYSTEM
47 #include "fontset.h"
48 #endif
49 #include "cm.h"
50 #ifdef MSDOS
51 #include "msdos.h"
52 #include "dosfns.h"
53 #endif
54 #ifdef USE_X_TOOLKIT
55 #include "widget.h"
56 #endif
58 /* The currently selected frame. */
60 Lisp_Object selected_frame;
62 /* A frame which is not just a mini-buffer, or NULL if there are no such
63 frames. This is usually the most recent such frame that was selected. */
65 static struct frame *last_nonminibuf_frame;
67 /* False means there are no visible garbaged frames. */
68 bool frame_garbaged;
70 /* The default tool bar height for future frames. */
71 #if defined USE_GTK || defined HAVE_NS
72 enum { frame_default_tool_bar_height = 0 };
73 #else
74 int frame_default_tool_bar_height;
75 #endif
77 #ifdef HAVE_WINDOW_SYSTEM
78 static void x_report_frame_params (struct frame *, Lisp_Object *);
79 #endif
81 /* These setters are used only in this file, so they can be private. */
82 static void
83 fset_buffer_predicate (struct frame *f, Lisp_Object val)
85 f->buffer_predicate = val;
87 static void
88 fset_minibuffer_window (struct frame *f, Lisp_Object val)
90 f->minibuffer_window = val;
93 struct frame *
94 decode_live_frame (register Lisp_Object frame)
96 if (NILP (frame))
97 frame = selected_frame;
98 CHECK_LIVE_FRAME (frame);
99 return XFRAME (frame);
102 struct frame *
103 decode_any_frame (register Lisp_Object frame)
105 if (NILP (frame))
106 frame = selected_frame;
107 CHECK_FRAME (frame);
108 return XFRAME (frame);
111 #ifdef HAVE_WINDOW_SYSTEM
113 bool
114 window_system_available (struct frame *f)
116 return f ? FRAME_WINDOW_P (f) || FRAME_MSDOS_P (f) : x_display_list != NULL;
119 #endif /* HAVE_WINDOW_SYSTEM */
121 struct frame *
122 decode_window_system_frame (Lisp_Object frame)
124 struct frame *f = decode_live_frame (frame);
126 if (!window_system_available (f))
127 error ("Window system frame should be used");
128 return f;
131 void
132 check_window_system (struct frame *f)
134 if (!window_system_available (f))
135 error (f ? "Window system frame should be used"
136 : "Window system is not in use or not initialized");
139 /* Return the value of frame parameter PROP in frame FRAME. */
141 Lisp_Object
142 get_frame_param (register struct frame *frame, Lisp_Object prop)
144 register Lisp_Object tem;
146 tem = Fassq (prop, frame->param_alist);
147 if (EQ (tem, Qnil))
148 return tem;
149 return Fcdr (tem);
153 void
154 frame_size_history_add (struct frame *f, Lisp_Object fun_symbol,
155 int width, int height, Lisp_Object rest)
157 Lisp_Object frame;
159 XSETFRAME (frame, f);
160 if (CONSP (frame_size_history)
161 && INTEGERP (XCAR (frame_size_history))
162 && 0 < XINT (XCAR (frame_size_history)))
163 frame_size_history =
164 Fcons (make_number (XINT (XCAR (frame_size_history)) - 1),
165 Fcons (list4
166 (frame, fun_symbol,
167 ((width > 0)
168 ? list4 (make_number (FRAME_TEXT_WIDTH (f)),
169 make_number (FRAME_TEXT_HEIGHT (f)),
170 make_number (width),
171 make_number (height))
172 : Qnil),
173 rest),
174 XCDR (frame_size_history)));
178 /* Return 1 if `frame-inhibit-implied-resize' is non-nil or fullscreen
179 state of frame F would be affected by a vertical (horizontal if
180 HORIZONTAL is true) resize. PARAMETER is the symbol of the frame
181 parameter that is changed. */
182 bool
183 frame_inhibit_resize (struct frame *f, bool horizontal, Lisp_Object parameter)
185 Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
186 bool inhibit
187 = ((f->after_make_frame
188 && (EQ (frame_inhibit_implied_resize, Qt)
189 || (CONSP (frame_inhibit_implied_resize)
190 && !NILP (Fmemq (parameter, frame_inhibit_implied_resize)))))
191 || (horizontal
192 && !EQ (fullscreen, Qnil) && !EQ (fullscreen, Qfullheight))
193 || (!horizontal
194 && !EQ (fullscreen, Qnil) && !EQ (fullscreen, Qfullwidth))
195 || FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
197 if (inhibit && !FRAME_TERMCAP_P (f) && !FRAME_MSDOS_P (f))
198 frame_size_history_add
199 (f, Qframe_inhibit_resize, 0, 0,
200 list5 (horizontal ? Qt : Qnil, parameter,
201 f->after_make_frame ? Qt : Qnil,
202 frame_inhibit_implied_resize,
203 fullscreen));
205 return inhibit;
208 static void
209 set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
211 int nlines;
212 int olines = FRAME_MENU_BAR_LINES (f);
214 /* Right now, menu bars don't work properly in minibuf-only frames;
215 most of the commands try to apply themselves to the minibuffer
216 frame itself, and get an error because you can't switch buffers
217 in or split the minibuffer window. */
218 if (FRAME_MINIBUF_ONLY_P (f))
219 return;
221 if (TYPE_RANGED_INTEGERP (int, value))
222 nlines = XINT (value);
223 else
224 nlines = 0;
226 if (nlines != olines)
228 windows_or_buffers_changed = 14;
229 FRAME_MENU_BAR_LINES (f) = nlines;
230 FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
231 change_frame_size (f, FRAME_COLS (f),
232 FRAME_LINES (f) + olines - nlines,
233 0, 1, 0, 0);
237 Lisp_Object Vframe_list;
240 DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
241 doc: /* Return non-nil if OBJECT is a frame.
242 Value is:
243 t for a termcap frame (a character-only terminal),
244 'x' for an Emacs frame that is really an X window,
245 'w32' for an Emacs frame that is a window on MS-Windows display,
246 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
247 'pc' for a direct-write MS-DOS frame.
248 See also `frame-live-p'. */)
249 (Lisp_Object object)
251 if (!FRAMEP (object))
252 return Qnil;
253 switch (XFRAME (object)->output_method)
255 case output_initial: /* The initial frame is like a termcap frame. */
256 case output_termcap:
257 return Qt;
258 case output_x_window:
259 return Qx;
260 case output_w32:
261 return Qw32;
262 case output_msdos_raw:
263 return Qpc;
264 case output_ns:
265 return Qns;
266 default:
267 emacs_abort ();
271 DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
272 doc: /* Return non-nil if OBJECT is a frame which has not been deleted.
273 Value is nil if OBJECT is not a live frame. If object is a live
274 frame, the return value indicates what sort of terminal device it is
275 displayed on. See the documentation of `framep' for possible
276 return values. */)
277 (Lisp_Object object)
279 return ((FRAMEP (object)
280 && FRAME_LIVE_P (XFRAME (object)))
281 ? Fframep (object)
282 : Qnil);
285 DEFUN ("window-system", Fwindow_system, Swindow_system, 0, 1, 0,
286 doc: /* The name of the window system that FRAME is displaying through.
287 The value is a symbol:
288 nil for a termcap frame (a character-only terminal),
289 'x' for an Emacs frame that is really an X window,
290 'w32' for an Emacs frame that is a window on MS-Windows display,
291 'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
292 'pc' for a direct-write MS-DOS frame.
294 FRAME defaults to the currently selected frame.
296 Use of this function as a predicate is deprecated. Instead,
297 use `display-graphic-p' or any of the other `display-*-p'
298 predicates which report frame's specific UI-related capabilities. */)
299 (Lisp_Object frame)
301 Lisp_Object type;
302 if (NILP (frame))
303 frame = selected_frame;
305 type = Fframep (frame);
307 if (NILP (type))
308 wrong_type_argument (Qframep, frame);
310 if (EQ (type, Qt))
311 return Qnil;
312 else
313 return type;
316 /* Placeholder used by temacs -nw before window.el is loaded. */
317 DEFUN ("frame-windows-min-size", Fframe_windows_min_size,
318 Sframe_windows_min_size, 4, 4, 0,
319 doc: /* */
320 attributes: const)
321 (Lisp_Object frame, Lisp_Object horizontal,
322 Lisp_Object ignore, Lisp_Object pixelwise)
324 return make_number (0);
327 static int
328 frame_windows_min_size (Lisp_Object frame, Lisp_Object horizontal,
329 Lisp_Object ignore, Lisp_Object pixelwise)
331 return XINT (call4 (Qframe_windows_min_size, frame, horizontal,
332 ignore, pixelwise));
336 /* Make sure windows sizes of frame F are OK. new_width and new_height
337 are in pixels. A value of -1 means no change is requested for that
338 size (but the frame may still have to be resized to accommodate
339 windows with their minimum sizes). This can either issue a request
340 to resize the frame externally (via x_set_window_size), to resize the
341 frame internally (via resize_frame_windows) or do nothing at all.
343 The argument INHIBIT can assume the following values:
345 0 means to unconditionally call x_set_window_size even if sizes
346 apparently do not change. Fx_create_frame uses this to pass the
347 initial size to the window manager.
349 1 means to call x_set_window_size if the outer frame size really
350 changes. Fset_frame_size, Fset_frame_height, ... use this.
352 2 means to call x_set_window_size provided frame_inhibit_resize
353 allows it. The menu and tool bar code use this ("3" won't work
354 here in general because menu and tool bar are often not counted in
355 the frame's text height).
357 3 means call x_set_window_size if window minimum sizes must be
358 preserved or frame_inhibit_resize allows it. x_set_left_fringe,
359 x_set_scroll_bar_width, x_new_font ... use (or should use) this.
361 4 means call x_set_window_size only if window minimum sizes must be
362 preserved. x_set_right_divider_width, x_set_border_width and the
363 code responsible for wrapping the tool bar use this.
365 5 means to never call x_set_window_size. change_frame_size uses
366 this.
368 Note that even when x_set_window_size is not called, individual
369 windows may have to be resized (via `window--sanitize-window-sizes')
370 in order to support minimum size constraints.
372 PRETEND is as for change_frame_size. PARAMETER, if non-nil, is the
373 symbol of the parameter changed (like `menu-bar-lines', `font', ...).
374 This is passed on to frame_inhibit_resize to let the latter decide on
375 a case-by-case basis whether the frame may be resized externally. */
376 void
377 adjust_frame_size (struct frame *f, int new_width, int new_height, int inhibit,
378 bool pretend, Lisp_Object parameter)
380 int unit_width = FRAME_COLUMN_WIDTH (f);
381 int unit_height = FRAME_LINE_HEIGHT (f);
382 int old_pixel_width = FRAME_PIXEL_WIDTH (f);
383 int old_pixel_height = FRAME_PIXEL_HEIGHT (f);
384 int old_cols = FRAME_COLS (f);
385 int old_lines = FRAME_LINES (f);
386 int new_pixel_width, new_pixel_height;
387 /* The following two values are calculated from the old frame pixel
388 sizes and any "new" settings for tool bar, menu bar and internal
389 borders. We do it this way to detect whether we have to call
390 x_set_window_size as consequence of the new settings. */
391 int windows_width = FRAME_WINDOWS_WIDTH (f);
392 int windows_height = FRAME_WINDOWS_HEIGHT (f);
393 int min_windows_width, min_windows_height;
394 /* These are a bit tedious, maybe we should use a macro. */
395 struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
396 int old_windows_width = WINDOW_PIXEL_WIDTH (r);
397 int old_windows_height
398 = (WINDOW_PIXEL_HEIGHT (r)
399 + (FRAME_HAS_MINIBUF_P (f)
400 ? WINDOW_PIXEL_HEIGHT (XWINDOW (FRAME_MINIBUF_WINDOW (f)))
401 : 0));
402 int new_windows_width, new_windows_height;
403 int old_text_width = FRAME_TEXT_WIDTH (f);
404 int old_text_height = FRAME_TEXT_HEIGHT (f);
405 /* If a size is < 0 use the old value. */
406 int new_text_width = (new_width >= 0) ? new_width : old_text_width;
407 int new_text_height = (new_height >= 0) ? new_height : old_text_height;
408 int new_cols, new_lines;
409 bool inhibit_horizontal, inhibit_vertical;
410 Lisp_Object frame;
412 XSETFRAME (frame, f);
414 frame_size_history_add
415 (f, Qadjust_frame_size_1, new_text_width, new_text_height,
416 list2 (parameter, make_number (inhibit)));
418 /* The following two values are calculated from the old window body
419 sizes and any "new" settings for scroll bars, dividers, fringes and
420 margins (though the latter should have been processed already). */
421 min_windows_width
422 = frame_windows_min_size (frame, Qt, (inhibit == 5) ? Qt : Qnil, Qt);
423 min_windows_height
424 = frame_windows_min_size (frame, Qnil, (inhibit == 5) ? Qt : Qnil, Qt);
426 if (inhibit >= 2 && inhibit <= 4)
427 /* When INHIBIT is in [2..4] inhibit if the "old" window sizes stay
428 within the limits and either frame_inhibit_resize tells us to do
429 so or INHIBIT equals 4. */
431 inhibit_horizontal = ((windows_width >= min_windows_width
432 && (inhibit == 4
433 || frame_inhibit_resize (f, true, parameter)))
434 ? true : false);
435 inhibit_vertical = ((windows_height >= min_windows_height
436 && (inhibit == 4
437 || frame_inhibit_resize (f, false, parameter)))
438 ? true : false);
440 else
441 /* Otherwise inhibit if INHIBIT equals 5. */
442 inhibit_horizontal = inhibit_vertical = inhibit == 5;
444 new_pixel_width = ((inhibit_horizontal && (inhibit < 5))
445 ? old_pixel_width
446 : max (FRAME_TEXT_TO_PIXEL_WIDTH (f, new_text_width),
447 min_windows_width
448 + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)));
449 new_windows_width = new_pixel_width - 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
450 new_text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, new_pixel_width);
451 new_cols = new_text_width / unit_width;
453 new_pixel_height = ((inhibit_vertical && (inhibit < 5))
454 ? old_pixel_height
455 : max (FRAME_TEXT_TO_PIXEL_HEIGHT (f, new_text_height),
456 min_windows_height
457 + FRAME_TOP_MARGIN_HEIGHT (f)
458 + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)));
459 new_windows_height = (new_pixel_height
460 - FRAME_TOP_MARGIN_HEIGHT (f)
461 - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
462 new_text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, new_pixel_height);
463 new_lines = new_text_height / unit_height;
465 #ifdef HAVE_WINDOW_SYSTEM
466 if (FRAME_WINDOW_P (f)
467 && f->can_x_set_window_size
468 && ((!inhibit_horizontal
469 && (new_pixel_width != old_pixel_width
470 || inhibit == 0 || inhibit == 2))
471 || (!inhibit_vertical
472 && (new_pixel_height != old_pixel_height
473 || inhibit == 0 || inhibit == 2))))
474 /* We are either allowed to change the frame size or the minimum
475 sizes request such a change. Do not care for fixing minimum
476 sizes here, we do that eventually when we're called from
477 change_frame_size. */
479 /* Make sure we respect fullheight and fullwidth. */
480 if (inhibit_horizontal)
481 new_text_width = old_text_width;
482 else if (inhibit_vertical)
483 new_text_height = old_text_height;
485 frame_size_history_add
486 (f, Qadjust_frame_size_2, new_text_width, new_text_height,
487 list2 (inhibit_horizontal ? Qt : Qnil,
488 inhibit_vertical ? Qt : Qnil));
490 x_set_window_size (f, 0, new_text_width, new_text_height, 1);
491 f->resized_p = true;
493 return;
495 #endif
497 if (new_text_width == old_text_width
498 && new_text_height == old_text_height
499 && new_windows_width == old_windows_width
500 && new_windows_height == old_windows_height
501 && new_pixel_width == old_pixel_width
502 && new_pixel_height == old_pixel_height
503 && new_cols == old_cols
504 && new_lines == old_lines)
505 /* No change. Sanitize window sizes and return. */
507 sanitize_window_sizes (frame, Qt);
508 sanitize_window_sizes (frame, Qnil);
510 return;
513 block_input ();
515 #ifdef MSDOS
516 /* We only can set screen dimensions to certain values supported
517 by our video hardware. Try to find the smallest size greater
518 or equal to the requested dimensions. */
519 dos_set_window_size (&new_lines, &new_cols);
520 #endif
522 if (new_windows_width != old_windows_width)
524 resize_frame_windows (f, new_windows_width, 1, 1);
526 /* MSDOS frames cannot PRETEND, as they change frame size by
527 manipulating video hardware. */
528 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
529 FrameCols (FRAME_TTY (f)) = new_cols;
531 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (USE_GTK) && ! defined (HAVE_NS)
532 if (WINDOWP (f->tool_bar_window))
534 XWINDOW (f->tool_bar_window)->pixel_width = new_windows_width;
535 XWINDOW (f->tool_bar_window)->total_cols
536 = new_windows_width / unit_width;
538 #endif
540 else if (new_cols != old_cols)
541 call2 (Qwindow_pixel_to_total, frame, Qt);
543 if (new_windows_height != old_windows_height
544 /* When the top margin has changed we have to recalculate the top
545 edges of all windows. No such calculation is necessary for the
546 left edges. */
547 || WINDOW_TOP_PIXEL_EDGE (r) != FRAME_TOP_MARGIN_HEIGHT (f))
549 resize_frame_windows (f, new_windows_height, 0, 1);
551 /* MSDOS frames cannot PRETEND, as they change frame size by
552 manipulating video hardware. */
553 if ((FRAME_TERMCAP_P (f) && !pretend) || FRAME_MSDOS_P (f))
554 FrameRows (FRAME_TTY (f)) = new_lines + FRAME_TOP_MARGIN (f);
556 else if (new_lines != old_lines)
557 call2 (Qwindow_pixel_to_total, frame, Qnil);
559 frame_size_history_add
560 (f, Qadjust_frame_size_3, new_text_width, new_text_height,
561 list4 (make_number (old_pixel_width), make_number (old_pixel_height),
562 make_number (new_pixel_width), make_number (new_pixel_height)));
564 /* Assign new sizes. */
565 FRAME_TEXT_WIDTH (f) = new_text_width;
566 FRAME_TEXT_HEIGHT (f) = new_text_height;
567 FRAME_PIXEL_WIDTH (f) = new_pixel_width;
568 FRAME_PIXEL_HEIGHT (f) = new_pixel_height;
569 SET_FRAME_COLS (f, new_cols);
570 SET_FRAME_LINES (f, new_lines);
573 struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
574 int text_area_x, text_area_y, text_area_width, text_area_height;
576 window_box (w, TEXT_AREA, &text_area_x, &text_area_y, &text_area_width,
577 &text_area_height);
578 if (w->cursor.x >= text_area_x + text_area_width)
579 w->cursor.hpos = w->cursor.x = 0;
580 if (w->cursor.y >= text_area_y + text_area_height)
581 w->cursor.vpos = w->cursor.y = 0;
584 /* Sanitize window sizes. */
585 sanitize_window_sizes (frame, Qt);
586 sanitize_window_sizes (frame, Qnil);
588 adjust_frame_glyphs (f);
589 calculate_costs (f);
590 SET_FRAME_GARBAGED (f);
592 /* A frame was "resized" if one of its pixelsizes changed, even if its
593 X window wasn't resized at all. */
594 f->resized_p = (new_pixel_width != old_pixel_width
595 || new_pixel_height != old_pixel_height);
597 unblock_input ();
599 run_window_configuration_change_hook (f);
602 /* Allocate basically initialized frame. */
604 static struct frame *
605 allocate_frame (void)
607 return ALLOCATE_ZEROED_PSEUDOVECTOR (struct frame, face_cache, PVEC_FRAME);
610 struct frame *
611 make_frame (bool mini_p)
613 Lisp_Object frame;
614 register struct frame *f;
615 register struct window *rw, *mw;
616 register Lisp_Object root_window;
617 register Lisp_Object mini_window;
619 f = allocate_frame ();
620 XSETFRAME (frame, f);
622 #ifdef USE_GTK
623 /* Initialize Lisp data. Note that allocate_frame initializes all
624 Lisp data to nil, so do it only for slots which should not be nil. */
625 fset_tool_bar_position (f, Qtop);
626 #endif
628 /* Initialize non-Lisp data. Note that allocate_frame zeroes out all
629 non-Lisp data, so do it only for slots which should not be zero.
630 To avoid subtle bugs and for the sake of readability, it's better to
631 initialize enum members explicitly even if their values are zero. */
632 f->wants_modeline = true;
633 f->redisplay = true;
634 f->garbaged = true;
635 f->can_x_set_window_size = false;
636 f->after_make_frame = false;
637 f->tool_bar_redisplayed_once = false;
638 f->column_width = 1; /* !FRAME_WINDOW_P value. */
639 f->line_height = 1; /* !FRAME_WINDOW_P value. */
640 #ifdef HAVE_WINDOW_SYSTEM
641 f->vertical_scroll_bar_type = vertical_scroll_bar_none;
642 f->horizontal_scroll_bars = false;
643 f->want_fullscreen = FULLSCREEN_NONE;
644 #if ! defined (USE_GTK) && ! defined (HAVE_NS)
645 f->last_tool_bar_item = -1;
646 #endif
647 #endif
649 root_window = make_window ();
650 rw = XWINDOW (root_window);
651 if (mini_p)
653 mini_window = make_window ();
654 mw = XWINDOW (mini_window);
655 wset_next (rw, mini_window);
656 wset_prev (mw, root_window);
657 mw->mini = 1;
658 wset_frame (mw, frame);
659 fset_minibuffer_window (f, mini_window);
661 else
663 mini_window = Qnil;
664 wset_next (rw, Qnil);
665 fset_minibuffer_window (f, Qnil);
668 wset_frame (rw, frame);
670 /* 10 is arbitrary,
671 just so that there is "something there."
672 Correct size will be set up later with adjust_frame_size. */
674 SET_FRAME_COLS (f, 10);
675 SET_FRAME_LINES (f, 10);
676 SET_FRAME_WIDTH (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f));
677 SET_FRAME_HEIGHT (f, FRAME_LINES (f) * FRAME_LINE_HEIGHT (f));
679 rw->total_cols = 10;
680 rw->pixel_width = rw->total_cols * FRAME_COLUMN_WIDTH (f);
681 rw->total_lines = mini_p ? 9 : 10;
682 rw->pixel_height = rw->total_lines * FRAME_LINE_HEIGHT (f);
684 if (mini_p)
686 mw->top_line = rw->total_lines;
687 mw->pixel_top = rw->pixel_height;
688 mw->total_cols = rw->total_cols;
689 mw->pixel_width = rw->pixel_width;
690 mw->total_lines = 1;
691 mw->pixel_height = FRAME_LINE_HEIGHT (f);
694 /* Choose a buffer for the frame's root window. */
696 Lisp_Object buf = Fcurrent_buffer ();
698 /* If current buffer is hidden, try to find another one. */
699 if (BUFFER_HIDDEN_P (XBUFFER (buf)))
700 buf = other_buffer_safely (buf);
702 /* Use set_window_buffer, not Fset_window_buffer, and don't let
703 hooks be run by it. The reason is that the whole frame/window
704 arrangement is not yet fully initialized at this point. Windows
705 don't have the right size, glyph matrices aren't initialized
706 etc. Running Lisp functions at this point surely ends in a
707 SEGV. */
708 set_window_buffer (root_window, buf, 0, 0);
709 fset_buffer_list (f, list1 (buf));
712 if (mini_p)
714 set_window_buffer (mini_window,
715 (NILP (Vminibuffer_list)
716 ? get_minibuffer (0)
717 : Fcar (Vminibuffer_list)),
718 0, 0);
719 /* No horizontal scroll bars in minibuffers. */
720 wset_horizontal_scroll_bar (mw, Qnil);
723 fset_root_window (f, root_window);
724 fset_selected_window (f, root_window);
725 /* Make sure this window seems more recently used than
726 a newly-created, never-selected window. */
727 XWINDOW (f->selected_window)->use_time = ++window_select_count;
729 return f;
732 #ifdef HAVE_WINDOW_SYSTEM
733 /* Make a frame using a separate minibuffer window on another frame.
734 MINI_WINDOW is the minibuffer window to use. nil means use the
735 default (the global minibuffer). */
737 struct frame *
738 make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lisp_Object display)
740 register struct frame *f;
741 struct gcpro gcpro1;
743 if (!NILP (mini_window))
744 CHECK_LIVE_WINDOW (mini_window);
746 if (!NILP (mini_window)
747 && FRAME_KBOARD (XFRAME (XWINDOW (mini_window)->frame)) != kb)
748 error ("Frame and minibuffer must be on the same terminal");
750 /* Make a frame containing just a root window. */
751 f = make_frame (0);
753 if (NILP (mini_window))
755 /* Use default-minibuffer-frame if possible. */
756 if (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
757 || ! FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame))))
759 Lisp_Object frame_dummy;
761 XSETFRAME (frame_dummy, f);
762 GCPRO1 (frame_dummy);
763 /* If there's no minibuffer frame to use, create one. */
764 kset_default_minibuffer_frame
765 (kb, call1 (intern ("make-initial-minibuffer-frame"), display));
766 UNGCPRO;
769 mini_window
770 = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
773 fset_minibuffer_window (f, mini_window);
775 /* Make the chosen minibuffer window display the proper minibuffer,
776 unless it is already showing a minibuffer. */
777 if (NILP (Fmemq (XWINDOW (mini_window)->contents, Vminibuffer_list)))
778 /* Use set_window_buffer instead of Fset_window_buffer (see
779 discussion of bug#11984, bug#12025, bug#12026). */
780 set_window_buffer (mini_window,
781 (NILP (Vminibuffer_list)
782 ? get_minibuffer (0)
783 : Fcar (Vminibuffer_list)), 0, 0);
784 return f;
787 /* Make a frame containing only a minibuffer window. */
789 struct frame *
790 make_minibuffer_frame (void)
792 /* First make a frame containing just a root window, no minibuffer. */
794 register struct frame *f = make_frame (0);
795 register Lisp_Object mini_window;
796 register Lisp_Object frame;
798 XSETFRAME (frame, f);
800 f->auto_raise = 0;
801 f->auto_lower = 0;
802 f->no_split = 1;
803 f->wants_modeline = 0;
805 /* Now label the root window as also being the minibuffer.
806 Avoid infinite looping on the window chain by marking next pointer
807 as nil. */
809 mini_window = f->root_window;
810 fset_minibuffer_window (f, mini_window);
811 XWINDOW (mini_window)->mini = 1;
812 wset_next (XWINDOW (mini_window), Qnil);
813 wset_prev (XWINDOW (mini_window), Qnil);
814 wset_frame (XWINDOW (mini_window), frame);
816 /* Put the proper buffer in that window. */
818 /* Use set_window_buffer instead of Fset_window_buffer (see
819 discussion of bug#11984, bug#12025, bug#12026). */
820 set_window_buffer (mini_window,
821 (NILP (Vminibuffer_list)
822 ? get_minibuffer (0)
823 : Fcar (Vminibuffer_list)), 0, 0);
824 return f;
826 #endif /* HAVE_WINDOW_SYSTEM */
828 /* Construct a frame that refers to a terminal. */
830 static printmax_t tty_frame_count;
832 struct frame *
833 make_initial_frame (void)
835 struct frame *f;
836 struct terminal *terminal;
837 Lisp_Object frame;
839 eassert (initial_kboard);
841 /* The first call must initialize Vframe_list. */
842 if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
843 Vframe_list = Qnil;
845 terminal = init_initial_terminal ();
847 f = make_frame (1);
848 XSETFRAME (frame, f);
850 Vframe_list = Fcons (frame, Vframe_list);
852 tty_frame_count = 1;
853 fset_name (f, build_pure_c_string ("F1"));
855 SET_FRAME_VISIBLE (f, 1);
857 f->output_method = terminal->type;
858 f->terminal = terminal;
859 f->terminal->reference_count++;
860 f->output_data.nothing = 0;
862 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
863 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
865 #ifdef HAVE_WINDOW_SYSTEM
866 f->vertical_scroll_bar_type = vertical_scroll_bar_none;
867 f->horizontal_scroll_bars = false;
868 #endif
870 /* The default value of menu-bar-mode is t. */
871 set_menu_bar_lines (f, make_number (1), Qnil);
873 if (!noninteractive)
874 init_frame_faces (f);
876 last_nonminibuf_frame = f;
878 f->can_x_set_window_size = true;
879 f->after_make_frame = true;
881 return f;
885 static struct frame *
886 make_terminal_frame (struct terminal *terminal)
888 register struct frame *f;
889 Lisp_Object frame;
890 char name[sizeof "F" + INT_STRLEN_BOUND (printmax_t)];
892 if (!terminal->name)
893 error ("Terminal is not live, can't create new frames on it");
895 f = make_frame (1);
897 XSETFRAME (frame, f);
898 Vframe_list = Fcons (frame, Vframe_list);
900 fset_name (f, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
902 SET_FRAME_VISIBLE (f, 1);
904 f->terminal = terminal;
905 f->terminal->reference_count++;
906 #ifdef MSDOS
907 f->output_data.tty->display_info = &the_only_display_info;
908 if (!inhibit_window_system
909 && (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame))
910 || XFRAME (selected_frame)->output_method == output_msdos_raw))
911 f->output_method = output_msdos_raw;
912 else
913 f->output_method = output_termcap;
914 #else /* not MSDOS */
915 f->output_method = output_termcap;
916 create_tty_output (f);
917 FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
918 FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
919 #endif /* not MSDOS */
921 #ifdef HAVE_WINDOW_SYSTEM
922 f->vertical_scroll_bar_type = vertical_scroll_bar_none;
923 f->horizontal_scroll_bars = false;
924 #endif
926 FRAME_MENU_BAR_LINES (f) = NILP (Vmenu_bar_mode) ? 0 : 1;
927 FRAME_LINES (f) = FRAME_LINES (f) - FRAME_MENU_BAR_LINES (f);
928 FRAME_MENU_BAR_HEIGHT (f) = FRAME_MENU_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
929 FRAME_TEXT_HEIGHT (f) = FRAME_TEXT_HEIGHT (f) - FRAME_MENU_BAR_HEIGHT (f);
931 /* Set the top frame to the newly created frame. */
932 if (FRAMEP (FRAME_TTY (f)->top_frame)
933 && FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
934 SET_FRAME_VISIBLE (XFRAME (FRAME_TTY (f)->top_frame), 2); /* obscured */
936 FRAME_TTY (f)->top_frame = frame;
938 if (!noninteractive)
939 init_frame_faces (f);
941 return f;
944 /* Get a suitable value for frame parameter PARAMETER for a newly
945 created frame, based on (1) the user-supplied frame parameter
946 alist SUPPLIED_PARMS, and (2) CURRENT_VALUE. */
948 static Lisp_Object
949 get_future_frame_param (Lisp_Object parameter,
950 Lisp_Object supplied_parms,
951 char *current_value)
953 Lisp_Object result;
955 result = Fassq (parameter, supplied_parms);
956 if (NILP (result))
957 result = Fassq (parameter, XFRAME (selected_frame)->param_alist);
958 if (NILP (result) && current_value != NULL)
959 result = build_string (current_value);
960 if (!NILP (result) && !STRINGP (result))
961 result = XCDR (result);
962 if (NILP (result) || !STRINGP (result))
963 result = Qnil;
965 return result;
968 DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
969 1, 1, 0,
970 doc: /* Create an additional terminal frame, possibly on another terminal.
971 This function takes one argument, an alist specifying frame parameters.
973 You can create multiple frames on a single text terminal, but only one
974 of them (the selected terminal frame) is actually displayed.
976 In practice, generally you don't need to specify any parameters,
977 except when you want to create a new frame on another terminal.
978 In that case, the `tty' parameter specifies the device file to open,
979 and the `tty-type' parameter specifies the terminal type. Example:
981 (make-terminal-frame '((tty . "/dev/pts/5") (tty-type . "xterm")))
983 Note that changing the size of one terminal frame automatically
984 affects all frames on the same terminal device. */)
985 (Lisp_Object parms)
987 struct frame *f;
988 struct terminal *t = NULL;
989 Lisp_Object frame, tem;
990 struct frame *sf = SELECTED_FRAME ();
992 #ifdef MSDOS
993 if (sf->output_method != output_msdos_raw
994 && sf->output_method != output_termcap)
995 emacs_abort ();
996 #else /* not MSDOS */
998 #ifdef WINDOWSNT /* This should work now! */
999 if (sf->output_method != output_termcap)
1000 error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
1001 #endif
1002 #endif /* not MSDOS */
1005 Lisp_Object terminal;
1007 terminal = Fassq (Qterminal, parms);
1008 if (CONSP (terminal))
1010 terminal = XCDR (terminal);
1011 t = decode_live_terminal (terminal);
1013 #ifdef MSDOS
1014 if (t && t != the_only_display_info.terminal)
1015 /* msdos.c assumes a single tty_display_info object. */
1016 error ("Multiple terminals are not supported on this platform");
1017 if (!t)
1018 t = the_only_display_info.terminal;
1019 #endif
1022 if (!t)
1024 char *name = 0, *type = 0;
1025 Lisp_Object tty, tty_type;
1026 USE_SAFE_ALLOCA;
1028 tty = get_future_frame_param
1029 (Qtty, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
1030 ? FRAME_TTY (XFRAME (selected_frame))->name
1031 : NULL));
1032 if (!NILP (tty))
1033 SAFE_ALLOCA_STRING (name, tty);
1035 tty_type = get_future_frame_param
1036 (Qtty_type, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
1037 ? FRAME_TTY (XFRAME (selected_frame))->type
1038 : NULL));
1039 if (!NILP (tty_type))
1040 SAFE_ALLOCA_STRING (type, tty_type);
1042 t = init_tty (name, type, 0); /* Errors are not fatal. */
1043 SAFE_FREE ();
1046 f = make_terminal_frame (t);
1049 int width, height;
1050 get_tty_size (fileno (FRAME_TTY (f)->input), &width, &height);
1051 adjust_frame_size (f, width, height - FRAME_MENU_BAR_LINES (f),
1052 5, 0, Qterminal_frame);
1055 adjust_frame_glyphs (f);
1056 calculate_costs (f);
1057 XSETFRAME (frame, f);
1059 store_in_alist (&parms, Qtty_type, build_string (t->display_info.tty->type));
1060 store_in_alist (&parms, Qtty,
1061 (t->display_info.tty->name
1062 ? build_string (t->display_info.tty->name)
1063 : Qnil));
1064 Fmodify_frame_parameters (frame, parms);
1066 /* Make the frame face alist be frame-specific, so that each
1067 frame could change its face definitions independently. */
1068 fset_face_alist (f, Fcopy_alist (sf->face_alist));
1069 /* Simple Fcopy_alist isn't enough, because we need the contents of
1070 the vectors which are the CDRs of associations in face_alist to
1071 be copied as well. */
1072 for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
1073 XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
1075 f->can_x_set_window_size = true;
1076 f->after_make_frame = true;
1078 return frame;
1082 /* Perform the switch to frame FRAME.
1084 If FRAME is a switch-frame event `(switch-frame FRAME1)', use
1085 FRAME1 as frame.
1087 If TRACK is non-zero and the frame that currently has the focus
1088 redirects its focus to the selected frame, redirect that focused
1089 frame's focus to FRAME instead.
1091 FOR_DELETION non-zero means that the selected frame is being
1092 deleted, which includes the possibility that the frame's terminal
1093 is dead.
1095 The value of NORECORD is passed as argument to Fselect_window. */
1097 Lisp_Object
1098 do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object norecord)
1100 struct frame *sf = SELECTED_FRAME ();
1102 /* If FRAME is a switch-frame event, extract the frame we should
1103 switch to. */
1104 if (CONSP (frame)
1105 && EQ (XCAR (frame), Qswitch_frame)
1106 && CONSP (XCDR (frame)))
1107 frame = XCAR (XCDR (frame));
1109 /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
1110 a switch-frame event to arrive after a frame is no longer live,
1111 especially when deleting the initial frame during startup. */
1112 CHECK_FRAME (frame);
1113 if (! FRAME_LIVE_P (XFRAME (frame)))
1114 return Qnil;
1116 if (sf == XFRAME (frame))
1117 return frame;
1119 /* If a frame's focus has been redirected toward the currently
1120 selected frame, we should change the redirection to point to the
1121 newly selected frame. This means that if the focus is redirected
1122 from a minibufferless frame to a surrogate minibuffer frame, we
1123 can use `other-window' to switch between all the frames using
1124 that minibuffer frame, and the focus redirection will follow us
1125 around. */
1126 #if 0
1127 /* This is too greedy; it causes inappropriate focus redirection
1128 that's hard to get rid of. */
1129 if (track)
1131 Lisp_Object tail;
1133 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
1135 Lisp_Object focus;
1137 if (!FRAMEP (XCAR (tail)))
1138 emacs_abort ();
1140 focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
1142 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
1143 Fredirect_frame_focus (XCAR (tail), frame);
1146 #else /* ! 0 */
1147 /* Instead, apply it only to the frame we're pointing to. */
1148 #ifdef HAVE_WINDOW_SYSTEM
1149 if (track && FRAME_WINDOW_P (XFRAME (frame)))
1151 Lisp_Object focus, xfocus;
1153 xfocus = x_get_focus_frame (XFRAME (frame));
1154 if (FRAMEP (xfocus))
1156 focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
1157 if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
1158 Fredirect_frame_focus (xfocus, frame);
1161 #endif /* HAVE_X_WINDOWS */
1162 #endif /* ! 0 */
1164 if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
1165 resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
1167 if (FRAME_TERMCAP_P (XFRAME (frame)) || FRAME_MSDOS_P (XFRAME (frame)))
1169 struct frame *f = XFRAME (frame);
1170 struct tty_display_info *tty = FRAME_TTY (f);
1171 Lisp_Object top_frame = tty->top_frame;
1173 /* Don't mark the frame garbaged and/or obscured if we are
1174 switching to the frame that is already the top frame of that
1175 TTY. */
1176 if (!EQ (frame, top_frame))
1178 if (FRAMEP (top_frame))
1179 /* Mark previously displayed frame as now obscured. */
1180 SET_FRAME_VISIBLE (XFRAME (top_frame), 2);
1181 SET_FRAME_VISIBLE (f, 1);
1182 /* If the new TTY frame changed dimensions, we need to
1183 resync term.c's idea of the frame size with the new
1184 frame's data. */
1185 if (FRAME_COLS (f) != FrameCols (tty))
1186 FrameCols (tty) = FRAME_COLS (f);
1187 if (FRAME_TOTAL_LINES (f) != FrameRows (tty))
1188 FrameRows (tty) = FRAME_TOTAL_LINES (f);
1190 tty->top_frame = frame;
1193 selected_frame = frame;
1194 if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
1195 last_nonminibuf_frame = XFRAME (selected_frame);
1197 Fselect_window (XFRAME (frame)->selected_window, norecord);
1199 /* We want to make sure that the next event generates a frame-switch
1200 event to the appropriate frame. This seems kludgy to me, but
1201 before you take it out, make sure that evaluating something like
1202 (select-window (frame-root-window (new-frame))) doesn't end up
1203 with your typing being interpreted in the new frame instead of
1204 the one you're actually typing in. */
1205 internal_last_event_frame = Qnil;
1207 return frame;
1210 DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
1211 doc: /* Select FRAME.
1212 Subsequent editing commands apply to its selected window.
1213 Optional argument NORECORD means to neither change the order of
1214 recently selected windows nor the buffer list.
1216 The selection of FRAME lasts until the next time the user does
1217 something to select a different frame, or until the next time
1218 this function is called. If you are using a window system, the
1219 previously selected frame may be restored as the selected frame
1220 when returning to the command loop, because it still may have
1221 the window system's input focus. On a text terminal, the next
1222 redisplay will display FRAME.
1224 This function returns FRAME, or nil if FRAME has been deleted. */)
1225 (Lisp_Object frame, Lisp_Object norecord)
1227 return do_switch_frame (frame, 1, 0, norecord);
1230 DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "^e",
1231 doc: /* Handle a switch-frame event EVENT.
1232 Switch-frame events are usually bound to this function.
1233 A switch-frame event tells Emacs that the window manager has requested
1234 that the user's events be directed to the frame mentioned in the event.
1235 This function selects the selected window of the frame of EVENT.
1237 If EVENT is frame object, handle it as if it were a switch-frame event
1238 to that frame. */)
1239 (Lisp_Object event)
1241 /* Preserve prefix arg that the command loop just cleared. */
1242 kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
1243 run_hook (Qmouse_leave_buffer_hook);
1244 /* `switch-frame' implies a focus in. */
1245 call1 (intern ("handle-focus-in"), event);
1246 return do_switch_frame (event, 0, 0, Qnil);
1249 DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
1250 doc: /* Return the frame that is now selected. */)
1251 (void)
1253 return selected_frame;
1256 DEFUN ("frame-list", Fframe_list, Sframe_list,
1257 0, 0, 0,
1258 doc: /* Return a list of all live frames. */)
1259 (void)
1261 Lisp_Object frames;
1262 frames = Fcopy_sequence (Vframe_list);
1263 #ifdef HAVE_WINDOW_SYSTEM
1264 if (FRAMEP (tip_frame))
1265 frames = Fdelq (tip_frame, frames);
1266 #endif
1267 return frames;
1270 /* Return CANDIDATE if it can be used as 'other-than-FRAME' frame on the
1271 same tty (for tty frames) or among frames which uses FRAME's keyboard.
1272 If MINIBUF is nil, do not consider minibuffer-only candidate.
1273 If MINIBUF is `visible', do not consider an invisible candidate.
1274 If MINIBUF is a window, consider only its own frame and candidate now
1275 using that window as the minibuffer.
1276 If MINIBUF is 0, consider candidate if it is visible or iconified.
1277 Otherwise consider any candidate and return nil if CANDIDATE is not
1278 acceptable. */
1280 static Lisp_Object
1281 candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
1283 struct frame *c = XFRAME (candidate), *f = XFRAME (frame);
1285 if ((!FRAME_TERMCAP_P (c) && !FRAME_TERMCAP_P (f)
1286 && FRAME_KBOARD (c) == FRAME_KBOARD (f))
1287 || (FRAME_TERMCAP_P (c) && FRAME_TERMCAP_P (f)
1288 && FRAME_TTY (c) == FRAME_TTY (f)))
1290 if (NILP (minibuf))
1292 if (!FRAME_MINIBUF_ONLY_P (c))
1293 return candidate;
1295 else if (EQ (minibuf, Qvisible))
1297 if (FRAME_VISIBLE_P (c))
1298 return candidate;
1300 else if (WINDOWP (minibuf))
1302 if (EQ (FRAME_MINIBUF_WINDOW (c), minibuf)
1303 || EQ (WINDOW_FRAME (XWINDOW (minibuf)), candidate)
1304 || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
1305 FRAME_FOCUS_FRAME (c)))
1306 return candidate;
1308 else if (XFASTINT (minibuf) == 0)
1310 if (FRAME_VISIBLE_P (c) || FRAME_ICONIFIED_P (c))
1311 return candidate;
1313 else
1314 return candidate;
1316 return Qnil;
1319 /* Return the next frame in the frame list after FRAME. */
1321 static Lisp_Object
1322 next_frame (Lisp_Object frame, Lisp_Object minibuf)
1324 Lisp_Object f, tail;
1325 int passed = 0;
1327 /* There must always be at least one frame in Vframe_list. */
1328 eassert (CONSP (Vframe_list));
1330 while (passed < 2)
1331 FOR_EACH_FRAME (tail, f)
1333 if (passed)
1335 f = candidate_frame (f, frame, minibuf);
1336 if (!NILP (f))
1337 return f;
1339 if (EQ (frame, f))
1340 passed++;
1342 return frame;
1345 /* Return the previous frame in the frame list before FRAME. */
1347 static Lisp_Object
1348 prev_frame (Lisp_Object frame, Lisp_Object minibuf)
1350 Lisp_Object f, tail, prev = Qnil;
1352 /* There must always be at least one frame in Vframe_list. */
1353 eassert (CONSP (Vframe_list));
1355 FOR_EACH_FRAME (tail, f)
1357 if (EQ (frame, f) && !NILP (prev))
1358 return prev;
1359 f = candidate_frame (f, frame, minibuf);
1360 if (!NILP (f))
1361 prev = f;
1364 /* We've scanned the entire list. */
1365 if (NILP (prev))
1366 /* We went through the whole frame list without finding a single
1367 acceptable frame. Return the original frame. */
1368 return frame;
1369 else
1370 /* There were no acceptable frames in the list before FRAME; otherwise,
1371 we would have returned directly from the loop. Since PREV is the last
1372 acceptable frame in the list, return it. */
1373 return prev;
1377 DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
1378 doc: /* Return the next frame in the frame list after FRAME.
1379 It considers only frames on the same terminal as FRAME.
1380 By default, skip minibuffer-only frames.
1381 If omitted, FRAME defaults to the selected frame.
1382 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1383 If MINIFRAME is a window, include only its own frame
1384 and any frame now using that window as the minibuffer.
1385 If MINIFRAME is `visible', include all visible frames.
1386 If MINIFRAME is 0, include all visible and iconified frames.
1387 Otherwise, include all frames. */)
1388 (Lisp_Object frame, Lisp_Object miniframe)
1390 if (NILP (frame))
1391 frame = selected_frame;
1392 CHECK_LIVE_FRAME (frame);
1393 return next_frame (frame, miniframe);
1396 DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame, 0, 2, 0,
1397 doc: /* Return the previous frame in the frame list before FRAME.
1398 It considers only frames on the same terminal as FRAME.
1399 By default, skip minibuffer-only frames.
1400 If omitted, FRAME defaults to the selected frame.
1401 If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
1402 If MINIFRAME is a window, include only its own frame
1403 and any frame now using that window as the minibuffer.
1404 If MINIFRAME is `visible', include all visible frames.
1405 If MINIFRAME is 0, include all visible and iconified frames.
1406 Otherwise, include all frames. */)
1407 (Lisp_Object frame, Lisp_Object miniframe)
1409 if (NILP (frame))
1410 frame = selected_frame;
1411 CHECK_LIVE_FRAME (frame);
1412 return prev_frame (frame, miniframe);
1415 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
1416 Slast_nonminibuf_frame, 0, 0, 0,
1417 doc: /* Return last non-minibuffer frame selected. */)
1418 (void)
1420 Lisp_Object frame = Qnil;
1422 if (last_nonminibuf_frame)
1423 XSETFRAME (frame, last_nonminibuf_frame);
1425 return frame;
1428 /* Return 1 if it is ok to delete frame F;
1429 0 if all frames aside from F are invisible.
1430 (Exception: if F is the terminal frame, and we are using X, return 1.) */
1432 static int
1433 other_visible_frames (struct frame *f)
1435 Lisp_Object frames, this;
1437 FOR_EACH_FRAME (frames, this)
1439 if (f == XFRAME (this))
1440 continue;
1442 /* Verify that we can still talk to the frame's X window,
1443 and note any recent change in visibility. */
1444 #ifdef HAVE_X_WINDOWS
1445 if (FRAME_WINDOW_P (XFRAME (this)))
1446 x_sync (XFRAME (this));
1447 #endif
1449 if (FRAME_VISIBLE_P (XFRAME (this))
1450 || FRAME_ICONIFIED_P (XFRAME (this))
1451 /* Allow deleting the terminal frame when at least one X
1452 frame exists. */
1453 || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
1454 return 1;
1456 return 0;
1459 /* Make sure that minibuf_window doesn't refer to FRAME's minibuffer
1460 window. Preferably use the selected frame's minibuffer window
1461 instead. If the selected frame doesn't have one, get some other
1462 frame's minibuffer window. SELECT non-zero means select the new
1463 minibuffer window. */
1464 static void
1465 check_minibuf_window (Lisp_Object frame, int select)
1467 struct frame *f = decode_live_frame (frame);
1469 XSETFRAME (frame, f);
1471 if (WINDOWP (minibuf_window) && EQ (f->minibuffer_window, minibuf_window))
1473 Lisp_Object frames, this, window = make_number (0);
1475 if (!EQ (frame, selected_frame)
1476 && FRAME_HAS_MINIBUF_P (XFRAME (selected_frame)))
1477 window = FRAME_MINIBUF_WINDOW (XFRAME (selected_frame));
1478 else
1479 FOR_EACH_FRAME (frames, this)
1481 if (!EQ (this, frame) && FRAME_HAS_MINIBUF_P (XFRAME (this)))
1483 window = FRAME_MINIBUF_WINDOW (XFRAME (this));
1484 break;
1488 /* Don't abort if no window was found (Bug#15247). */
1489 if (WINDOWP (window))
1491 /* Use set_window_buffer instead of Fset_window_buffer (see
1492 discussion of bug#11984, bug#12025, bug#12026). */
1493 set_window_buffer (window, XWINDOW (minibuf_window)->contents, 0, 0);
1494 minibuf_window = window;
1496 /* SELECT non-zero usually means that FRAME's minibuffer
1497 window was selected; select the new one. */
1498 if (select)
1499 Fselect_window (minibuf_window, Qnil);
1505 /* Delete FRAME. When FORCE equals Qnoelisp, delete FRAME
1506 unconditionally. x_connection_closed and delete_terminal use
1507 this. Any other value of FORCE implements the semantics
1508 described for Fdelete_frame. */
1509 Lisp_Object
1510 delete_frame (Lisp_Object frame, Lisp_Object force)
1512 struct frame *f = decode_any_frame (frame);
1513 struct frame *sf;
1514 struct kboard *kb;
1516 int minibuffer_selected, is_tooltip_frame;
1518 if (! FRAME_LIVE_P (f))
1519 return Qnil;
1521 if (NILP (force) && !other_visible_frames (f))
1522 error ("Attempt to delete the sole visible or iconified frame");
1524 /* x_connection_closed must have set FORCE to `noelisp' in order
1525 to delete the last frame, if it is gone. */
1526 if (NILP (XCDR (Vframe_list)) && !EQ (force, Qnoelisp))
1527 error ("Attempt to delete the only frame");
1529 XSETFRAME (frame, f);
1531 /* Does this frame have a minibuffer, and is it the surrogate
1532 minibuffer for any other frame? */
1533 if (FRAME_HAS_MINIBUF_P (f))
1535 Lisp_Object frames, this;
1537 FOR_EACH_FRAME (frames, this)
1539 Lisp_Object fminiw;
1541 if (EQ (this, frame))
1542 continue;
1544 fminiw = FRAME_MINIBUF_WINDOW (XFRAME (this));
1546 if (WINDOWP (fminiw) && EQ (frame, WINDOW_FRAME (XWINDOW (fminiw))))
1548 /* If we MUST delete this frame, delete the other first.
1549 But do this only if FORCE equals `noelisp'. */
1550 if (EQ (force, Qnoelisp))
1551 delete_frame (this, Qnoelisp);
1552 else
1553 error ("Attempt to delete a surrogate minibuffer frame");
1558 is_tooltip_frame = !NILP (Fframe_parameter (frame, Qtooltip));
1560 /* Run `delete-frame-functions' unless FORCE is `noelisp' or
1561 frame is a tooltip. FORCE is set to `noelisp' when handling
1562 a disconnect from the terminal, so we don't dare call Lisp
1563 code. */
1564 if (NILP (Vrun_hooks) || is_tooltip_frame)
1566 else if (EQ (force, Qnoelisp))
1567 pending_funcalls
1568 = Fcons (list3 (Qrun_hook_with_args, Qdelete_frame_functions, frame),
1569 pending_funcalls);
1570 else
1572 #ifdef HAVE_X_WINDOWS
1573 /* Also, save clipboard to the clipboard manager. */
1574 x_clipboard_manager_save_frame (frame);
1575 #endif
1577 safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
1580 /* The hook may sometimes (indirectly) cause the frame to be deleted. */
1581 if (! FRAME_LIVE_P (f))
1582 return Qnil;
1584 /* At this point, we are committed to deleting the frame.
1585 There is no more chance for errors to prevent it. */
1587 minibuffer_selected = EQ (minibuf_window, selected_window);
1588 sf = SELECTED_FRAME ();
1589 /* Don't let the frame remain selected. */
1590 if (f == sf)
1592 Lisp_Object tail;
1593 Lisp_Object frame1 = Qnil;
1595 /* Look for another visible frame on the same terminal.
1596 Do not call next_frame here because it may loop forever.
1597 See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15025. */
1598 FOR_EACH_FRAME (tail, frame1)
1599 if (!EQ (frame, frame1)
1600 && (FRAME_TERMINAL (XFRAME (frame))
1601 == FRAME_TERMINAL (XFRAME (frame1)))
1602 && FRAME_VISIBLE_P (XFRAME (frame1)))
1603 break;
1605 /* If there is none, find *some* other frame. */
1606 if (NILP (frame1) || EQ (frame1, frame))
1608 FOR_EACH_FRAME (tail, frame1)
1610 if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
1612 /* Do not change a text terminal's top-frame. */
1613 struct frame *f1 = XFRAME (frame1);
1614 if (FRAME_TERMCAP_P (f1) || FRAME_MSDOS_P (f1))
1616 Lisp_Object top_frame = FRAME_TTY (f1)->top_frame;
1617 if (!EQ (top_frame, frame))
1618 frame1 = top_frame;
1620 break;
1624 #ifdef NS_IMPL_COCOA
1625 else
1626 /* Under NS, there is no system mechanism for choosing a new
1627 window to get focus -- it is left to application code.
1628 So the portion of THIS application interfacing with NS
1629 needs to know about it. We call Fraise_frame, but the
1630 purpose is really to transfer focus. */
1631 Fraise_frame (frame1);
1632 #endif
1634 do_switch_frame (frame1, 0, 1, Qnil);
1635 sf = SELECTED_FRAME ();
1638 /* Don't allow minibuf_window to remain on a deleted frame. */
1639 check_minibuf_window (frame, minibuffer_selected);
1641 /* Don't let echo_area_window to remain on a deleted frame. */
1642 if (EQ (f->minibuffer_window, echo_area_window))
1643 echo_area_window = sf->minibuffer_window;
1645 /* Clear any X selections for this frame. */
1646 #ifdef HAVE_X_WINDOWS
1647 if (FRAME_X_P (f))
1648 x_clear_frame_selections (f);
1649 #endif
1651 /* Free glyphs.
1652 This function must be called before the window tree of the
1653 frame is deleted because windows contain dynamically allocated
1654 memory. */
1655 free_glyphs (f);
1657 #ifdef HAVE_WINDOW_SYSTEM
1658 /* Give chance to each font driver to free a frame specific data. */
1659 font_update_drivers (f, Qnil);
1660 #endif
1662 /* Mark all the windows that used to be on FRAME as deleted, and then
1663 remove the reference to them. */
1664 delete_all_child_windows (f->root_window);
1665 fset_root_window (f, Qnil);
1667 Vframe_list = Fdelq (frame, Vframe_list);
1668 SET_FRAME_VISIBLE (f, 0);
1670 /* Allow the vector of menu bar contents to be freed in the next
1671 garbage collection. The frame object itself may not be garbage
1672 collected until much later, because recent_keys and other data
1673 structures can still refer to it. */
1674 fset_menu_bar_vector (f, Qnil);
1676 /* If FRAME's buffer lists contains killed
1677 buffers, this helps GC to reclaim them. */
1678 fset_buffer_list (f, Qnil);
1679 fset_buried_buffer_list (f, Qnil);
1681 free_font_driver_list (f);
1682 #if defined (USE_X_TOOLKIT) || defined (HAVE_NTGUI)
1683 xfree (f->namebuf);
1684 #endif
1685 xfree (f->decode_mode_spec_buffer);
1686 xfree (FRAME_INSERT_COST (f));
1687 xfree (FRAME_DELETEN_COST (f));
1688 xfree (FRAME_INSERTN_COST (f));
1689 xfree (FRAME_DELETE_COST (f));
1691 /* Since some events are handled at the interrupt level, we may get
1692 an event for f at any time; if we zero out the frame's terminal
1693 now, then we may trip up the event-handling code. Instead, we'll
1694 promise that the terminal of the frame must be valid until we
1695 have called the window-system-dependent frame destruction
1696 routine. */
1700 struct terminal *terminal;
1701 block_input ();
1702 if (FRAME_TERMINAL (f)->delete_frame_hook)
1703 (*FRAME_TERMINAL (f)->delete_frame_hook) (f);
1704 terminal = FRAME_TERMINAL (f);
1705 f->output_data.nothing = 0;
1706 f->terminal = 0; /* Now the frame is dead. */
1707 unblock_input ();
1709 /* If needed, delete the terminal that this frame was on.
1710 (This must be done after the frame is killed.) */
1711 terminal->reference_count--;
1712 #ifdef USE_GTK
1713 /* FIXME: Deleting the terminal crashes emacs because of a GTK
1714 bug.
1715 http://lists.gnu.org/archive/html/emacs-devel/2011-10/msg00363.html */
1716 if (terminal->reference_count == 0 && terminal->type == output_x_window)
1717 terminal->reference_count = 1;
1718 #endif /* USE_GTK */
1719 if (terminal->reference_count == 0)
1721 Lisp_Object tmp;
1722 XSETTERMINAL (tmp, terminal);
1724 kb = NULL;
1725 Fdelete_terminal (tmp, NILP (force) ? Qt : force);
1727 else
1728 kb = terminal->kboard;
1731 /* If we've deleted the last_nonminibuf_frame, then try to find
1732 another one. */
1733 if (f == last_nonminibuf_frame)
1735 Lisp_Object frames, this;
1737 last_nonminibuf_frame = 0;
1739 FOR_EACH_FRAME (frames, this)
1741 f = XFRAME (this);
1742 if (!FRAME_MINIBUF_ONLY_P (f))
1744 last_nonminibuf_frame = f;
1745 break;
1750 /* If there's no other frame on the same kboard, get out of
1751 single-kboard state if we're in it for this kboard. */
1752 if (kb != NULL)
1754 Lisp_Object frames, this;
1755 /* Some frame we found on the same kboard, or nil if there are none. */
1756 Lisp_Object frame_on_same_kboard = Qnil;
1758 FOR_EACH_FRAME (frames, this)
1759 if (kb == FRAME_KBOARD (XFRAME (this)))
1760 frame_on_same_kboard = this;
1762 if (NILP (frame_on_same_kboard))
1763 not_single_kboard_state (kb);
1767 /* If we've deleted this keyboard's default_minibuffer_frame, try to
1768 find another one. Prefer minibuffer-only frames, but also notice
1769 frames with other windows. */
1770 if (kb != NULL && EQ (frame, KVAR (kb, Vdefault_minibuffer_frame)))
1772 Lisp_Object frames, this;
1774 /* The last frame we saw with a minibuffer, minibuffer-only or not. */
1775 Lisp_Object frame_with_minibuf = Qnil;
1776 /* Some frame we found on the same kboard, or nil if there are none. */
1777 Lisp_Object frame_on_same_kboard = Qnil;
1779 FOR_EACH_FRAME (frames, this)
1781 struct frame *f1 = XFRAME (this);
1783 /* Consider only frames on the same kboard
1784 and only those with minibuffers. */
1785 if (kb == FRAME_KBOARD (f1)
1786 && FRAME_HAS_MINIBUF_P (f1))
1788 frame_with_minibuf = this;
1789 if (FRAME_MINIBUF_ONLY_P (f1))
1790 break;
1793 if (kb == FRAME_KBOARD (f1))
1794 frame_on_same_kboard = this;
1797 if (!NILP (frame_on_same_kboard))
1799 /* We know that there must be some frame with a minibuffer out
1800 there. If this were not true, all of the frames present
1801 would have to be minibufferless, which implies that at some
1802 point their minibuffer frames must have been deleted, but
1803 that is prohibited at the top; you can't delete surrogate
1804 minibuffer frames. */
1805 if (NILP (frame_with_minibuf))
1806 emacs_abort ();
1808 kset_default_minibuffer_frame (kb, frame_with_minibuf);
1810 else
1811 /* No frames left on this kboard--say no minibuffer either. */
1812 kset_default_minibuffer_frame (kb, Qnil);
1815 /* Cause frame titles to update--necessary if we now have just one frame. */
1816 if (!is_tooltip_frame)
1817 update_mode_lines = 15;
1819 return Qnil;
1822 DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
1823 doc: /* Delete FRAME, permanently eliminating it from use.
1824 FRAME defaults to the selected frame.
1826 A frame may not be deleted if its minibuffer serves as surrogate
1827 minibuffer for another frame. Normally, you may not delete a frame if
1828 all other frames are invisible, but if the second optional argument
1829 FORCE is non-nil, you may do so.
1831 This function runs `delete-frame-functions' before actually
1832 deleting the frame, unless the frame is a tooltip.
1833 The functions are run with one argument, the frame to be deleted. */)
1834 (Lisp_Object frame, Lisp_Object force)
1836 return delete_frame (frame, !NILP (force) ? Qt : Qnil);
1840 /* Return mouse position in character cell units. */
1842 DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
1843 doc: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1844 The position is given in canonical character cells, where (0, 0) is the
1845 upper-left corner of the frame, X is the horizontal offset, and Y is the
1846 vertical offset, measured in units of the frame's default character size.
1847 If Emacs is running on a mouseless terminal or hasn't been programmed
1848 to read the mouse position, it returns the selected frame for FRAME
1849 and nil for X and Y.
1850 If `mouse-position-function' is non-nil, `mouse-position' calls it,
1851 passing the normal return value to that function as an argument,
1852 and returns whatever that function returns. */)
1853 (void)
1855 struct frame *f;
1856 Lisp_Object lispy_dummy;
1857 Lisp_Object x, y, retval;
1858 struct gcpro gcpro1;
1860 f = SELECTED_FRAME ();
1861 x = y = Qnil;
1863 /* It's okay for the hook to refrain from storing anything. */
1864 if (FRAME_TERMINAL (f)->mouse_position_hook)
1866 enum scroll_bar_part party_dummy;
1867 Time time_dummy;
1868 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1869 &lispy_dummy, &party_dummy,
1870 &x, &y,
1871 &time_dummy);
1874 if (! NILP (x))
1876 int col = XINT (x);
1877 int row = XINT (y);
1878 pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
1879 XSETINT (x, col);
1880 XSETINT (y, row);
1882 XSETFRAME (lispy_dummy, f);
1883 retval = Fcons (lispy_dummy, Fcons (x, y));
1884 GCPRO1 (retval);
1885 if (!NILP (Vmouse_position_function))
1886 retval = call1 (Vmouse_position_function, retval);
1887 RETURN_UNGCPRO (retval);
1890 DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
1891 Smouse_pixel_position, 0, 0, 0,
1892 doc: /* Return a list (FRAME X . Y) giving the current mouse frame and position.
1893 The position is given in pixel units, where (0, 0) is the
1894 upper-left corner of the frame, X is the horizontal offset, and Y is
1895 the vertical offset.
1896 If Emacs is running on a mouseless terminal or hasn't been programmed
1897 to read the mouse position, it returns the selected frame for FRAME
1898 and nil for X and Y. */)
1899 (void)
1901 struct frame *f;
1902 Lisp_Object lispy_dummy;
1903 Lisp_Object x, y, retval;
1904 struct gcpro gcpro1;
1906 f = SELECTED_FRAME ();
1907 x = y = Qnil;
1909 /* It's okay for the hook to refrain from storing anything. */
1910 if (FRAME_TERMINAL (f)->mouse_position_hook)
1912 enum scroll_bar_part party_dummy;
1913 Time time_dummy;
1914 (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
1915 &lispy_dummy, &party_dummy,
1916 &x, &y,
1917 &time_dummy);
1920 XSETFRAME (lispy_dummy, f);
1921 retval = Fcons (lispy_dummy, Fcons (x, y));
1922 GCPRO1 (retval);
1923 if (!NILP (Vmouse_position_function))
1924 retval = call1 (Vmouse_position_function, retval);
1925 RETURN_UNGCPRO (retval);
1928 #ifdef HAVE_WINDOW_SYSTEM
1930 /* On frame F, convert character coordinates X and Y to pixel
1931 coordinates *PIX_X and *PIX_Y. */
1933 static void
1934 frame_char_to_pixel_position (struct frame *f, int x, int y,
1935 int *pix_x, int *pix_y)
1937 *pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
1938 *pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
1940 if (*pix_x < 0)
1941 *pix_x = 0;
1942 if (*pix_x > FRAME_PIXEL_WIDTH (f))
1943 *pix_x = FRAME_PIXEL_WIDTH (f);
1945 if (*pix_y < 0)
1946 *pix_y = 0;
1947 if (*pix_y > FRAME_PIXEL_HEIGHT (f))
1948 *pix_y = FRAME_PIXEL_HEIGHT (f);
1951 /* On frame F, reposition mouse pointer to character coordinates X and Y. */
1953 static void
1954 frame_set_mouse_position (struct frame *f, int x, int y)
1956 int pix_x, pix_y;
1958 frame_char_to_pixel_position (f, x, y, &pix_x, &pix_y);
1959 frame_set_mouse_pixel_position (f, pix_x, pix_y);
1962 #endif /* HAVE_WINDOW_SYSTEM */
1964 DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
1965 doc: /* Move the mouse pointer to the center of character cell (X,Y) in FRAME.
1966 Coordinates are relative to the frame, not a window,
1967 so the coordinates of the top left character in the frame
1968 may be nonzero due to left-hand scroll bars or the menu bar.
1970 The position is given in canonical character cells, where (0, 0) is
1971 the upper-left corner of the frame, X is the horizontal offset, and
1972 Y is the vertical offset, measured in units of the frame's default
1973 character size.
1975 This function is a no-op for an X frame that is not visible.
1976 If you have just created a frame, you must wait for it to become visible
1977 before calling this function on it, like this.
1978 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
1979 (Lisp_Object frame, Lisp_Object x, Lisp_Object y)
1981 CHECK_LIVE_FRAME (frame);
1982 CHECK_TYPE_RANGED_INTEGER (int, x);
1983 CHECK_TYPE_RANGED_INTEGER (int, y);
1985 /* I think this should be done with a hook. */
1986 #ifdef HAVE_WINDOW_SYSTEM
1987 if (FRAME_WINDOW_P (XFRAME (frame)))
1988 /* Warping the mouse will cause enternotify and focus events. */
1989 frame_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
1990 #else
1991 #if defined (MSDOS)
1992 if (FRAME_MSDOS_P (XFRAME (frame)))
1994 Fselect_frame (frame, Qnil);
1995 mouse_moveto (XINT (x), XINT (y));
1997 #else
1998 #ifdef HAVE_GPM
2000 Fselect_frame (frame, Qnil);
2001 term_mouse_moveto (XINT (x), XINT (y));
2003 #endif
2004 #endif
2005 #endif
2007 return Qnil;
2010 DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
2011 Sset_mouse_pixel_position, 3, 3, 0,
2012 doc: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
2013 The position is given in pixels, where (0, 0) is the upper-left corner
2014 of the frame, X is the horizontal offset, and Y is the vertical offset.
2016 Note, this is a no-op for an X frame that is not visible.
2017 If you have just created a frame, you must wait for it to become visible
2018 before calling this function on it, like this.
2019 (while (not (frame-visible-p frame)) (sleep-for .5)) */)
2020 (Lisp_Object frame, Lisp_Object x, Lisp_Object y)
2022 CHECK_LIVE_FRAME (frame);
2023 CHECK_TYPE_RANGED_INTEGER (int, x);
2024 CHECK_TYPE_RANGED_INTEGER (int, y);
2026 /* I think this should be done with a hook. */
2027 #ifdef HAVE_WINDOW_SYSTEM
2028 if (FRAME_WINDOW_P (XFRAME (frame)))
2029 /* Warping the mouse will cause enternotify and focus events. */
2030 frame_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
2031 #else
2032 #if defined (MSDOS)
2033 if (FRAME_MSDOS_P (XFRAME (frame)))
2035 Fselect_frame (frame, Qnil);
2036 mouse_moveto (XINT (x), XINT (y));
2038 #else
2039 #ifdef HAVE_GPM
2041 Fselect_frame (frame, Qnil);
2042 term_mouse_moveto (XINT (x), XINT (y));
2044 #endif
2045 #endif
2046 #endif
2048 return Qnil;
2051 static void make_frame_visible_1 (Lisp_Object);
2053 DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
2054 0, 1, "",
2055 doc: /* Make the frame FRAME visible (assuming it is an X window).
2056 If omitted, FRAME defaults to the currently selected frame. */)
2057 (Lisp_Object frame)
2059 struct frame *f = decode_live_frame (frame);
2061 /* I think this should be done with a hook. */
2062 #ifdef HAVE_WINDOW_SYSTEM
2063 if (FRAME_WINDOW_P (f))
2064 x_make_frame_visible (f);
2065 #endif
2067 make_frame_visible_1 (f->root_window);
2069 /* Make menu bar update for the Buffers and Frames menus. */
2070 /* windows_or_buffers_changed = 15; FIXME: Why? */
2072 XSETFRAME (frame, f);
2073 return frame;
2076 /* Update the display_time slot of the buffers shown in WINDOW
2077 and all its descendants. */
2079 static void
2080 make_frame_visible_1 (Lisp_Object window)
2082 struct window *w;
2084 for (; !NILP (window); window = w->next)
2086 w = XWINDOW (window);
2087 if (WINDOWP (w->contents))
2088 make_frame_visible_1 (w->contents);
2089 else
2090 bset_display_time (XBUFFER (w->contents), Fcurrent_time ());
2094 DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
2095 0, 2, "",
2096 doc: /* Make the frame FRAME invisible.
2097 If omitted, FRAME defaults to the currently selected frame.
2098 On graphical displays, invisible frames are not updated and are
2099 usually not displayed at all, even in a window system's \"taskbar\".
2101 Normally you may not make FRAME invisible if all other frames are invisible,
2102 but if the second optional argument FORCE is non-nil, you may do so.
2104 This function has no effect on text terminal frames. Such frames are
2105 always considered visible, whether or not they are currently being
2106 displayed in the terminal. */)
2107 (Lisp_Object frame, Lisp_Object force)
2109 struct frame *f = decode_live_frame (frame);
2111 if (NILP (force) && !other_visible_frames (f))
2112 error ("Attempt to make invisible the sole visible or iconified frame");
2114 /* Don't allow minibuf_window to remain on an invisible frame. */
2115 check_minibuf_window (frame, EQ (minibuf_window, selected_window));
2117 /* I think this should be done with a hook. */
2118 #ifdef HAVE_WINDOW_SYSTEM
2119 if (FRAME_WINDOW_P (f))
2120 x_make_frame_invisible (f);
2121 #endif
2123 /* Make menu bar update for the Buffers and Frames menus. */
2124 windows_or_buffers_changed = 16;
2126 return Qnil;
2129 DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
2130 0, 1, "",
2131 doc: /* Make the frame FRAME into an icon.
2132 If omitted, FRAME defaults to the currently selected frame. */)
2133 (Lisp_Object frame)
2135 struct frame *f = decode_live_frame (frame);
2137 /* Don't allow minibuf_window to remain on an iconified frame. */
2138 check_minibuf_window (frame, EQ (minibuf_window, selected_window));
2140 /* I think this should be done with a hook. */
2141 #ifdef HAVE_WINDOW_SYSTEM
2142 if (FRAME_WINDOW_P (f))
2143 x_iconify_frame (f);
2144 #endif
2146 /* Make menu bar update for the Buffers and Frames menus. */
2147 windows_or_buffers_changed = 17;
2149 return Qnil;
2152 DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
2153 1, 1, 0,
2154 doc: /* Return t if FRAME is \"visible\" (actually in use for display).
2155 Return the symbol `icon' if FRAME is iconified or \"minimized\".
2156 Return nil if FRAME was made invisible, via `make-frame-invisible'.
2157 On graphical displays, invisible frames are not updated and are
2158 usually not displayed at all, even in a window system's \"taskbar\".
2160 If FRAME is a text terminal frame, this always returns t.
2161 Such frames are always considered visible, whether or not they are
2162 currently being displayed on the terminal. */)
2163 (Lisp_Object frame)
2165 CHECK_LIVE_FRAME (frame);
2167 if (FRAME_VISIBLE_P (XFRAME (frame)))
2168 return Qt;
2169 if (FRAME_ICONIFIED_P (XFRAME (frame)))
2170 return Qicon;
2171 return Qnil;
2174 DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
2175 0, 0, 0,
2176 doc: /* Return a list of all frames now \"visible\" (being updated). */)
2177 (void)
2179 Lisp_Object tail, frame, value = Qnil;
2181 FOR_EACH_FRAME (tail, frame)
2182 if (FRAME_VISIBLE_P (XFRAME (frame)))
2183 value = Fcons (frame, value);
2185 return value;
2189 DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
2190 doc: /* Bring FRAME to the front, so it occludes any frames it overlaps.
2191 If FRAME is invisible or iconified, make it visible.
2192 If you don't specify a frame, the selected frame is used.
2193 If Emacs is displaying on an ordinary terminal or some other device which
2194 doesn't support multiple overlapping frames, this function selects FRAME. */)
2195 (Lisp_Object frame)
2197 struct frame *f = decode_live_frame (frame);
2199 XSETFRAME (frame, f);
2201 if (FRAME_TERMCAP_P (f))
2202 /* On a text terminal select FRAME. */
2203 Fselect_frame (frame, Qnil);
2204 else
2205 /* Do like the documentation says. */
2206 Fmake_frame_visible (frame);
2208 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2209 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 1);
2211 return Qnil;
2214 /* Should we have a corresponding function called Flower_Power? */
2215 DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
2216 doc: /* Send FRAME to the back, so it is occluded by any frames that overlap it.
2217 If you don't specify a frame, the selected frame is used.
2218 If Emacs is displaying on an ordinary terminal or some other device which
2219 doesn't support multiple overlapping frames, this function does nothing. */)
2220 (Lisp_Object frame)
2222 struct frame *f = decode_live_frame (frame);
2224 if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
2225 (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
2227 return Qnil;
2231 DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
2232 1, 2, 0,
2233 doc: /* Arrange for keystrokes typed at FRAME to be sent to FOCUS-FRAME.
2234 In other words, switch-frame events caused by events in FRAME will
2235 request a switch to FOCUS-FRAME, and `last-event-frame' will be
2236 FOCUS-FRAME after reading an event typed at FRAME.
2238 If FOCUS-FRAME is nil, any existing redirection is canceled, and the
2239 frame again receives its own keystrokes.
2241 Focus redirection is useful for temporarily redirecting keystrokes to
2242 a surrogate minibuffer frame when a frame doesn't have its own
2243 minibuffer window.
2245 A frame's focus redirection can be changed by `select-frame'. If frame
2246 FOO is selected, and then a different frame BAR is selected, any
2247 frames redirecting their focus to FOO are shifted to redirect their
2248 focus to BAR. This allows focus redirection to work properly when the
2249 user switches from one frame to another using `select-window'.
2251 This means that a frame whose focus is redirected to itself is treated
2252 differently from a frame whose focus is redirected to nil; the former
2253 is affected by `select-frame', while the latter is not.
2255 The redirection lasts until `redirect-frame-focus' is called to change it. */)
2256 (Lisp_Object frame, Lisp_Object focus_frame)
2258 /* Note that we don't check for a live frame here. It's reasonable
2259 to redirect the focus of a frame you're about to delete, if you
2260 know what other frame should receive those keystrokes. */
2261 struct frame *f = decode_any_frame (frame);
2263 if (! NILP (focus_frame))
2264 CHECK_LIVE_FRAME (focus_frame);
2266 fset_focus_frame (f, focus_frame);
2268 if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
2269 (*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
2271 return Qnil;
2275 DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 0, 1, 0,
2276 doc: /* Return the frame to which FRAME's keystrokes are currently being sent.
2277 If FRAME is omitted or nil, the selected frame is used.
2278 Return nil if FRAME's focus is not redirected.
2279 See `redirect-frame-focus'. */)
2280 (Lisp_Object frame)
2282 return FRAME_FOCUS_FRAME (decode_live_frame (frame));
2285 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
2286 doc: /* Set the input focus to FRAME.
2287 FRAME nil means use the selected frame.
2288 If there is no window system support, this function does nothing. */)
2289 (Lisp_Object frame)
2291 #ifdef HAVE_WINDOW_SYSTEM
2292 x_focus_frame (decode_window_system_frame (frame));
2293 #endif
2294 return Qnil;
2297 DEFUN ("frame-after-make-frame",
2298 Fframe_after_make_frame,
2299 Sframe_after_make_frame, 2, 2, 0,
2300 doc: /* Mark FRAME as made.
2301 FRAME nil means use the selected frame. Second argument MADE non-nil
2302 means functions on `window-configuration-change-hook' are called
2303 whenever the window configuration of FRAME changes. MADE nil means
2304 these functions are not called.
2306 This function is currently called by `make-frame' only and should be
2307 otherwise used with utter care to avoid that running functions on
2308 `window-configuration-change-hook' is impeded forever. */)
2309 (Lisp_Object frame, Lisp_Object made)
2311 struct frame *f = decode_live_frame (frame);
2312 f->after_make_frame = !NILP (made);
2313 return made;
2317 /* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
2319 void
2320 frames_discard_buffer (Lisp_Object buffer)
2322 Lisp_Object frame, tail;
2324 FOR_EACH_FRAME (tail, frame)
2326 fset_buffer_list
2327 (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buffer_list));
2328 fset_buried_buffer_list
2329 (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
2333 /* Modify the alist in *ALISTPTR to associate PROP with VAL.
2334 If the alist already has an element for PROP, we change it. */
2336 void
2337 store_in_alist (Lisp_Object *alistptr, Lisp_Object prop, Lisp_Object val)
2339 register Lisp_Object tem;
2341 tem = Fassq (prop, *alistptr);
2342 if (EQ (tem, Qnil))
2343 *alistptr = Fcons (Fcons (prop, val), *alistptr);
2344 else
2345 Fsetcdr (tem, val);
2348 static int
2349 frame_name_fnn_p (char *str, ptrdiff_t len)
2351 if (len > 1 && str[0] == 'F' && '0' <= str[1] && str[1] <= '9')
2353 char *p = str + 2;
2354 while ('0' <= *p && *p <= '9')
2355 p++;
2356 if (p == str + len)
2357 return 1;
2359 return 0;
2362 /* Set the name of the terminal frame. Also used by MSDOS frames.
2363 Modeled after x_set_name which is used for WINDOW frames. */
2365 static void
2366 set_term_frame_name (struct frame *f, Lisp_Object name)
2368 f->explicit_name = ! NILP (name);
2370 /* If NAME is nil, set the name to F<num>. */
2371 if (NILP (name))
2373 char namebuf[sizeof "F" + INT_STRLEN_BOUND (printmax_t)];
2375 /* Check for no change needed in this very common case
2376 before we do any consing. */
2377 if (frame_name_fnn_p (SSDATA (f->name), SBYTES (f->name)))
2378 return;
2380 name = make_formatted_string (namebuf, "F%"pMd, ++tty_frame_count);
2382 else
2384 CHECK_STRING (name);
2386 /* Don't change the name if it's already NAME. */
2387 if (! NILP (Fstring_equal (name, f->name)))
2388 return;
2390 /* Don't allow the user to set the frame name to F<num>, so it
2391 doesn't clash with the names we generate for terminal frames. */
2392 if (frame_name_fnn_p (SSDATA (name), SBYTES (name)))
2393 error ("Frame names of the form F<num> are usurped by Emacs");
2396 fset_name (f, name);
2397 update_mode_lines = 16;
2400 void
2401 store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
2403 register Lisp_Object old_alist_elt;
2405 /* The buffer-list parameters are stored in a special place and not
2406 in the alist. All buffers must be live. */
2407 if (EQ (prop, Qbuffer_list))
2409 Lisp_Object list = Qnil;
2410 for (; CONSP (val); val = XCDR (val))
2411 if (!NILP (Fbuffer_live_p (XCAR (val))))
2412 list = Fcons (XCAR (val), list);
2413 fset_buffer_list (f, Fnreverse (list));
2414 return;
2416 if (EQ (prop, Qburied_buffer_list))
2418 Lisp_Object list = Qnil;
2419 for (; CONSP (val); val = XCDR (val))
2420 if (!NILP (Fbuffer_live_p (XCAR (val))))
2421 list = Fcons (XCAR (val), list);
2422 fset_buried_buffer_list (f, Fnreverse (list));
2423 return;
2426 /* If PROP is a symbol which is supposed to have frame-local values,
2427 and it is set up based on this frame, switch to the global
2428 binding. That way, we can create or alter the frame-local binding
2429 without messing up the symbol's status. */
2430 if (SYMBOLP (prop))
2432 struct Lisp_Symbol *sym = XSYMBOL (prop);
2433 start:
2434 switch (sym->redirect)
2436 case SYMBOL_VARALIAS: sym = indirect_variable (sym); goto start;
2437 case SYMBOL_PLAINVAL: case SYMBOL_FORWARDED: break;
2438 case SYMBOL_LOCALIZED:
2439 { struct Lisp_Buffer_Local_Value *blv = sym->val.blv;
2440 if (blv->frame_local && blv_found (blv) && XFRAME (blv->where) == f)
2441 swap_in_global_binding (sym);
2442 break;
2444 default: emacs_abort ();
2448 /* The tty color needed to be set before the frame's parameter
2449 alist was updated with the new value. This is not true any more,
2450 but we still do this test early on. */
2451 if (FRAME_TERMCAP_P (f) && EQ (prop, Qtty_color_mode)
2452 && f == FRAME_TTY (f)->previous_frame)
2453 /* Force redisplay of this tty. */
2454 FRAME_TTY (f)->previous_frame = NULL;
2456 /* Update the frame parameter alist. */
2457 old_alist_elt = Fassq (prop, f->param_alist);
2458 if (EQ (old_alist_elt, Qnil))
2459 fset_param_alist (f, Fcons (Fcons (prop, val), f->param_alist));
2460 else
2461 Fsetcdr (old_alist_elt, val);
2463 /* Update some other special parameters in their special places
2464 in addition to the alist. */
2466 if (EQ (prop, Qbuffer_predicate))
2467 fset_buffer_predicate (f, val);
2469 if (! FRAME_WINDOW_P (f))
2471 if (EQ (prop, Qmenu_bar_lines))
2472 set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
2473 else if (EQ (prop, Qname))
2474 set_term_frame_name (f, val);
2477 if (EQ (prop, Qminibuffer) && WINDOWP (val))
2479 if (! MINI_WINDOW_P (XWINDOW (val)))
2480 error ("Surrogate minibuffer windows must be minibuffer windows");
2482 if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
2483 && !EQ (val, f->minibuffer_window))
2484 error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
2486 /* Install the chosen minibuffer window, with proper buffer. */
2487 fset_minibuffer_window (f, val);
2491 /* Return color matches UNSPEC on frame F or nil if UNSPEC
2492 is not an unspecified foreground or background color. */
2494 static Lisp_Object
2495 frame_unspecified_color (struct frame *f, Lisp_Object unspec)
2497 return (!strncmp (SSDATA (unspec), unspecified_bg, SBYTES (unspec))
2498 ? tty_color_name (f, FRAME_BACKGROUND_PIXEL (f))
2499 : (!strncmp (SSDATA (unspec), unspecified_fg, SBYTES (unspec))
2500 ? tty_color_name (f, FRAME_FOREGROUND_PIXEL (f)) : Qnil));
2503 DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
2504 doc: /* Return the parameters-alist of frame FRAME.
2505 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
2506 The meaningful PARMs depend on the kind of frame.
2507 If FRAME is omitted or nil, return information on the currently selected frame. */)
2508 (Lisp_Object frame)
2510 Lisp_Object alist;
2511 struct frame *f = decode_any_frame (frame);
2512 int height, width;
2513 struct gcpro gcpro1;
2515 if (!FRAME_LIVE_P (f))
2516 return Qnil;
2518 alist = Fcopy_alist (f->param_alist);
2519 GCPRO1 (alist);
2521 if (!FRAME_WINDOW_P (f))
2523 Lisp_Object elt;
2525 /* If the frame's parameter alist says the colors are
2526 unspecified and reversed, take the frame's background pixel
2527 for foreground and vice versa. */
2528 elt = Fassq (Qforeground_color, alist);
2529 if (CONSP (elt) && STRINGP (XCDR (elt)))
2531 elt = frame_unspecified_color (f, XCDR (elt));
2532 if (!NILP (elt))
2533 store_in_alist (&alist, Qforeground_color, elt);
2535 else
2536 store_in_alist (&alist, Qforeground_color,
2537 tty_color_name (f, FRAME_FOREGROUND_PIXEL (f)));
2538 elt = Fassq (Qbackground_color, alist);
2539 if (CONSP (elt) && STRINGP (XCDR (elt)))
2541 elt = frame_unspecified_color (f, XCDR (elt));
2542 if (!NILP (elt))
2543 store_in_alist (&alist, Qbackground_color, elt);
2545 else
2546 store_in_alist (&alist, Qbackground_color,
2547 tty_color_name (f, FRAME_BACKGROUND_PIXEL (f)));
2548 store_in_alist (&alist, Qfont,
2549 build_string (FRAME_MSDOS_P (f)
2550 ? "ms-dos"
2551 : FRAME_W32_P (f) ? "w32term"
2552 :"tty"));
2554 store_in_alist (&alist, Qname, f->name);
2555 height = (f->new_height
2556 ? (f->new_pixelwise
2557 ? (f->new_height / FRAME_LINE_HEIGHT (f))
2558 : f->new_height)
2559 : FRAME_LINES (f));
2560 store_in_alist (&alist, Qheight, make_number (height));
2561 width = (f->new_width
2562 ? (f->new_pixelwise
2563 ? (f->new_width / FRAME_COLUMN_WIDTH (f))
2564 : f->new_width)
2565 : FRAME_COLS (f));
2566 store_in_alist (&alist, Qwidth, make_number (width));
2567 store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
2568 store_in_alist (&alist, Qminibuffer,
2569 (! FRAME_HAS_MINIBUF_P (f) ? Qnil
2570 : FRAME_MINIBUF_ONLY_P (f) ? Qonly
2571 : FRAME_MINIBUF_WINDOW (f)));
2572 store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
2573 store_in_alist (&alist, Qbuffer_list, f->buffer_list);
2574 store_in_alist (&alist, Qburied_buffer_list, f->buried_buffer_list);
2576 /* I think this should be done with a hook. */
2577 #ifdef HAVE_WINDOW_SYSTEM
2578 if (FRAME_WINDOW_P (f))
2579 x_report_frame_params (f, &alist);
2580 else
2581 #endif
2583 /* This ought to be correct in f->param_alist for an X frame. */
2584 Lisp_Object lines;
2585 XSETFASTINT (lines, FRAME_MENU_BAR_LINES (f));
2586 store_in_alist (&alist, Qmenu_bar_lines, lines);
2589 UNGCPRO;
2590 return alist;
2594 DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
2595 doc: /* Return FRAME's value for parameter PARAMETER.
2596 If FRAME is nil, describe the currently selected frame. */)
2597 (Lisp_Object frame, Lisp_Object parameter)
2599 struct frame *f = decode_any_frame (frame);
2600 Lisp_Object value = Qnil;
2602 CHECK_SYMBOL (parameter);
2604 XSETFRAME (frame, f);
2606 if (FRAME_LIVE_P (f))
2608 /* Avoid consing in frequent cases. */
2609 if (EQ (parameter, Qname))
2610 value = f->name;
2611 #ifdef HAVE_X_WINDOWS
2612 else if (EQ (parameter, Qdisplay) && FRAME_X_P (f))
2613 value = XCAR (FRAME_DISPLAY_INFO (f)->name_list_element);
2614 #endif /* HAVE_X_WINDOWS */
2615 else if (EQ (parameter, Qbackground_color)
2616 || EQ (parameter, Qforeground_color))
2618 value = Fassq (parameter, f->param_alist);
2619 if (CONSP (value))
2621 value = XCDR (value);
2622 /* Fframe_parameters puts the actual fg/bg color names,
2623 even if f->param_alist says otherwise. This is
2624 important when param_alist's notion of colors is
2625 "unspecified". We need to do the same here. */
2626 if (STRINGP (value) && !FRAME_WINDOW_P (f))
2628 Lisp_Object tem = frame_unspecified_color (f, value);
2630 if (!NILP (tem))
2631 value = tem;
2634 else
2635 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2637 else if (EQ (parameter, Qdisplay_type)
2638 || EQ (parameter, Qbackground_mode))
2639 value = Fcdr (Fassq (parameter, f->param_alist));
2640 else
2641 /* FIXME: Avoid this code path at all (as well as code duplication)
2642 by sharing more code with Fframe_parameters. */
2643 value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
2646 return value;
2650 DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
2651 Smodify_frame_parameters, 2, 2, 0,
2652 doc: /* Modify the parameters of frame FRAME according to ALIST.
2653 If FRAME is nil, it defaults to the selected frame.
2654 ALIST is an alist of parameters to change and their new values.
2655 Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
2656 The meaningful PARMs depend on the kind of frame.
2657 Undefined PARMs are ignored, but stored in the frame's parameter list
2658 so that `frame-parameters' will return them.
2660 The value of frame parameter FOO can also be accessed
2661 as a frame-local binding for the variable FOO, if you have
2662 enabled such bindings for that variable with `make-variable-frame-local'.
2663 Note that this functionality is obsolete as of Emacs 22.2, and its
2664 use is not recommended. Explicitly check for a frame-parameter instead. */)
2665 (Lisp_Object frame, Lisp_Object alist)
2667 struct frame *f = decode_live_frame (frame);
2668 register Lisp_Object prop, val;
2670 CHECK_LIST (alist);
2672 /* I think this should be done with a hook. */
2673 #ifdef HAVE_WINDOW_SYSTEM
2674 if (FRAME_WINDOW_P (f))
2675 x_set_frame_parameters (f, alist);
2676 else
2677 #endif
2678 #ifdef MSDOS
2679 if (FRAME_MSDOS_P (f))
2680 IT_set_frame_parameters (f, alist);
2681 else
2682 #endif
2685 EMACS_INT length = XFASTINT (Flength (alist));
2686 ptrdiff_t i;
2687 Lisp_Object *parms;
2688 Lisp_Object *values;
2689 USE_SAFE_ALLOCA;
2690 SAFE_ALLOCA_LISP (parms, 2 * length);
2691 values = parms + length;
2693 /* Extract parm names and values into those vectors. */
2695 for (i = 0; CONSP (alist); alist = XCDR (alist))
2697 Lisp_Object elt;
2699 elt = XCAR (alist);
2700 parms[i] = Fcar (elt);
2701 values[i] = Fcdr (elt);
2702 i++;
2705 /* Now process them in reverse of specified order. */
2706 while (--i >= 0)
2708 prop = parms[i];
2709 val = values[i];
2710 store_frame_param (f, prop, val);
2712 if (EQ (prop, Qforeground_color)
2713 || EQ (prop, Qbackground_color))
2714 update_face_from_frame_parameter (f, prop, val);
2717 SAFE_FREE ();
2719 return Qnil;
2722 DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
2723 0, 1, 0,
2724 doc: /* Height in pixels of a line in the font in frame FRAME.
2725 If FRAME is omitted or nil, the selected frame is used.
2726 For a terminal frame, the value is always 1. */)
2727 (Lisp_Object frame)
2729 #ifdef HAVE_WINDOW_SYSTEM
2730 struct frame *f = decode_any_frame (frame);
2732 if (FRAME_WINDOW_P (f))
2733 return make_number (FRAME_LINE_HEIGHT (f));
2734 else
2735 #endif
2736 return make_number (1);
2740 DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
2741 0, 1, 0,
2742 doc: /* Width in pixels of characters in the font in frame FRAME.
2743 If FRAME is omitted or nil, the selected frame is used.
2744 On a graphical screen, the width is the standard width of the default font.
2745 For a terminal screen, the value is always 1. */)
2746 (Lisp_Object frame)
2748 #ifdef HAVE_WINDOW_SYSTEM
2749 struct frame *f = decode_any_frame (frame);
2751 if (FRAME_WINDOW_P (f))
2752 return make_number (FRAME_COLUMN_WIDTH (f));
2753 else
2754 #endif
2755 return make_number (1);
2758 DEFUN ("frame-pixel-height", Fframe_pixel_height,
2759 Sframe_pixel_height, 0, 1, 0,
2760 doc: /* Return a FRAME's height in pixels.
2761 If FRAME is omitted or nil, the selected frame is used. The exact value
2762 of the result depends on the window-system and toolkit in use:
2764 In the Gtk+ version of Emacs, it includes only any window (including
2765 the minibuffer or echo area), mode line, and header line. It does not
2766 include the tool bar or menu bar.
2768 With other graphical versions, it also includes the tool bar and the
2769 menu bar.
2771 For a text terminal, it includes the menu bar. In this case, the
2772 result is really in characters rather than pixels (i.e., is identical
2773 to `frame-height'). */)
2774 (Lisp_Object frame)
2776 struct frame *f = decode_any_frame (frame);
2778 #ifdef HAVE_WINDOW_SYSTEM
2779 if (FRAME_WINDOW_P (f))
2780 return make_number (FRAME_PIXEL_HEIGHT (f));
2781 else
2782 #endif
2783 return make_number (FRAME_TOTAL_LINES (f));
2786 DEFUN ("frame-pixel-width", Fframe_pixel_width,
2787 Sframe_pixel_width, 0, 1, 0,
2788 doc: /* Return FRAME's width in pixels.
2789 For a terminal frame, the result really gives the width in characters.
2790 If FRAME is omitted or nil, the selected frame is used. */)
2791 (Lisp_Object frame)
2793 struct frame *f = decode_any_frame (frame);
2795 #ifdef HAVE_WINDOW_SYSTEM
2796 if (FRAME_WINDOW_P (f))
2797 return make_number (FRAME_PIXEL_WIDTH (f));
2798 else
2799 #endif
2800 return make_number (FRAME_TOTAL_COLS (f));
2803 DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
2804 Stool_bar_pixel_width, 0, 1, 0,
2805 doc: /* Return width in pixels of FRAME's tool bar.
2806 The result is greater than zero only when the tool bar is on the left
2807 or right side of FRAME. If FRAME is omitted or nil, the selected frame
2808 is used. */)
2809 (Lisp_Object frame)
2811 #ifdef FRAME_TOOLBAR_WIDTH
2812 struct frame *f = decode_any_frame (frame);
2814 if (FRAME_WINDOW_P (f))
2815 return make_number (FRAME_TOOLBAR_WIDTH (f));
2816 #endif
2817 return make_number (0);
2820 DEFUN ("frame-text-cols", Fframe_text_cols, Sframe_text_cols, 0, 1, 0,
2821 doc: /* Return width in columns of FRAME's text area. */)
2822 (Lisp_Object frame)
2824 return make_number (FRAME_COLS (decode_any_frame (frame)));
2827 DEFUN ("frame-text-lines", Fframe_text_lines, Sframe_text_lines, 0, 1, 0,
2828 doc: /* Return height in lines of FRAME's text area. */)
2829 (Lisp_Object frame)
2831 return make_number (FRAME_LINES (decode_any_frame (frame)));
2834 DEFUN ("frame-total-cols", Fframe_total_cols, Sframe_total_cols, 0, 1, 0,
2835 doc: /* Return number of total columns of FRAME. */)
2836 (Lisp_Object frame)
2838 return make_number (FRAME_TOTAL_COLS (decode_any_frame (frame)));
2841 DEFUN ("frame-total-lines", Fframe_total_lines, Sframe_total_lines, 0, 1, 0,
2842 doc: /* Return number of total lines of FRAME. */)
2843 (Lisp_Object frame)
2845 return make_number (FRAME_TOTAL_LINES (decode_any_frame (frame)));
2848 DEFUN ("frame-text-width", Fframe_text_width, Sframe_text_width, 0, 1, 0,
2849 doc: /* Return text area width of FRAME in pixels. */)
2850 (Lisp_Object frame)
2852 return make_number (FRAME_TEXT_WIDTH (decode_any_frame (frame)));
2855 DEFUN ("frame-text-height", Fframe_text_height, Sframe_text_height, 0, 1, 0,
2856 doc: /* Return text area height of FRAME in pixels. */)
2857 (Lisp_Object frame)
2859 return make_number (FRAME_TEXT_HEIGHT (decode_any_frame (frame)));
2862 DEFUN ("frame-scroll-bar-width", Fscroll_bar_width, Sscroll_bar_width, 0, 1, 0,
2863 doc: /* Return scroll bar width of FRAME in pixels. */)
2864 (Lisp_Object frame)
2866 return make_number (FRAME_SCROLL_BAR_AREA_WIDTH (decode_any_frame (frame)));
2869 DEFUN ("frame-scroll-bar-height", Fscroll_bar_height, Sscroll_bar_height, 0, 1, 0,
2870 doc: /* Return scroll bar height of FRAME in pixels. */)
2871 (Lisp_Object frame)
2873 return make_number (FRAME_SCROLL_BAR_AREA_HEIGHT (decode_any_frame (frame)));
2876 DEFUN ("frame-fringe-width", Ffringe_width, Sfringe_width, 0, 1, 0,
2877 doc: /* Return fringe width of FRAME in pixels. */)
2878 (Lisp_Object frame)
2880 return make_number (FRAME_TOTAL_FRINGE_WIDTH (decode_any_frame (frame)));
2883 DEFUN ("frame-border-width", Fborder_width, Sborder_width, 0, 1, 0,
2884 doc: /* Return border width of FRAME in pixels. */)
2885 (Lisp_Object frame)
2887 return make_number (FRAME_INTERNAL_BORDER_WIDTH (decode_any_frame (frame)));
2890 DEFUN ("frame-right-divider-width", Fright_divider_width, Sright_divider_width, 0, 1, 0,
2891 doc: /* Return width (in pixels) of vertical window dividers on FRAME. */)
2892 (Lisp_Object frame)
2894 return make_number (FRAME_RIGHT_DIVIDER_WIDTH (decode_any_frame (frame)));
2897 DEFUN ("frame-bottom-divider-width", Fbottom_divider_width, Sbottom_divider_width, 0, 1, 0,
2898 doc: /* Return width (in pixels) of horizontal window dividers on FRAME. */)
2899 (Lisp_Object frame)
2901 return make_number (FRAME_BOTTOM_DIVIDER_WIDTH (decode_any_frame (frame)));
2904 DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 4, 0,
2905 doc: /* Set text height of frame FRAME to HEIGHT lines.
2906 Optional third arg PRETEND non-nil means that redisplay should use
2907 HEIGHT lines but that the idea of the actual height of the frame should
2908 not be changed.
2910 Optional fourth argument PIXELWISE non-nil means that FRAME should be
2911 HEIGHT pixels high. Note: When `frame-resize-pixelwise' is nil, some
2912 window managers may refuse to honor a HEIGHT that is not an integer
2913 multiple of the default frame font height. */)
2914 (Lisp_Object frame, Lisp_Object height, Lisp_Object pretend, Lisp_Object pixelwise)
2916 struct frame *f = decode_live_frame (frame);
2917 int pixel_height;
2919 CHECK_TYPE_RANGED_INTEGER (int, height);
2921 pixel_height = (!NILP (pixelwise)
2922 ? XINT (height)
2923 : XINT (height) * FRAME_LINE_HEIGHT (f));
2924 adjust_frame_size (f, -1, pixel_height, 1, !NILP (pretend), Qheight);
2926 return Qnil;
2929 DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 4, 0,
2930 doc: /* Set text width of frame FRAME to WIDTH columns.
2931 Optional third arg PRETEND non-nil means that redisplay should use WIDTH
2932 columns but that the idea of the actual width of the frame should not
2933 be changed.
2935 Optional fourth argument PIXELWISE non-nil means that FRAME should be
2936 WIDTH pixels wide. Note: When `frame-resize-pixelwise' is nil, some
2937 window managers may refuse to honor a WIDTH that is not an integer
2938 multiple of the default frame font width. */)
2939 (Lisp_Object frame, Lisp_Object width, Lisp_Object pretend, Lisp_Object pixelwise)
2941 struct frame *f = decode_live_frame (frame);
2942 int pixel_width;
2944 CHECK_TYPE_RANGED_INTEGER (int, width);
2946 pixel_width = (!NILP (pixelwise)
2947 ? XINT (width)
2948 : XINT (width) * FRAME_COLUMN_WIDTH (f));
2949 adjust_frame_size (f, pixel_width, -1, 1, !NILP (pretend), Qwidth);
2951 return Qnil;
2954 DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 4, 0,
2955 doc: /* Set text size of FRAME to WIDTH by HEIGHT, measured in characters.
2956 Optional argument PIXELWISE non-nil means to measure in pixels. Note:
2957 When `frame-resize-pixelwise' is nil, some window managers may refuse to
2958 honor a WIDTH that is not an integer multiple of the default frame font
2959 width or a HEIGHT that is not an integer multiple of the default frame
2960 font height. */)
2961 (Lisp_Object frame, Lisp_Object width, Lisp_Object height, Lisp_Object pixelwise)
2963 struct frame *f = decode_live_frame (frame);
2964 int pixel_width, pixel_height;
2966 CHECK_TYPE_RANGED_INTEGER (int, width);
2967 CHECK_TYPE_RANGED_INTEGER (int, height);
2969 pixel_width = (!NILP (pixelwise)
2970 ? XINT (width)
2971 : XINT (width) * FRAME_COLUMN_WIDTH (f));
2972 pixel_height = (!NILP (pixelwise)
2973 ? XINT (height)
2974 : XINT (height) * FRAME_LINE_HEIGHT (f));
2975 adjust_frame_size (f, pixel_width, pixel_height, 1, 0, Qsize);
2977 return Qnil;
2980 DEFUN ("set-frame-position", Fset_frame_position,
2981 Sset_frame_position, 3, 3, 0,
2982 doc: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
2983 If FRAME is nil, the selected frame is used. XOFFSET and YOFFSET are
2984 actually the position of the upper left corner of the frame. Negative
2985 values for XOFFSET or YOFFSET are interpreted relative to the rightmost
2986 or bottommost possible position (that stays within the screen). */)
2987 (Lisp_Object frame, Lisp_Object xoffset, Lisp_Object yoffset)
2989 register struct frame *f = decode_live_frame (frame);
2991 CHECK_TYPE_RANGED_INTEGER (int, xoffset);
2992 CHECK_TYPE_RANGED_INTEGER (int, yoffset);
2994 /* I think this should be done with a hook. */
2995 #ifdef HAVE_WINDOW_SYSTEM
2996 if (FRAME_WINDOW_P (f))
2997 x_set_offset (f, XINT (xoffset), XINT (yoffset), 1);
2998 #endif
3000 return Qt;
3004 /***********************************************************************
3005 Frame Parameters
3006 ***********************************************************************/
3008 /* Connect the frame-parameter names for X frames
3009 to the ways of passing the parameter values to the window system.
3011 The name of a parameter, as a Lisp symbol,
3012 has an `x-frame-parameter' property which is an integer in Lisp
3013 that is an index in this table. */
3015 struct frame_parm_table {
3016 const char *name;
3017 int sym;
3020 static const struct frame_parm_table frame_parms[] =
3022 {"auto-raise", SYMBOL_INDEX (Qauto_raise)},
3023 {"auto-lower", SYMBOL_INDEX (Qauto_lower)},
3024 {"background-color", -1},
3025 {"border-color", SYMBOL_INDEX (Qborder_color)},
3026 {"border-width", SYMBOL_INDEX (Qborder_width)},
3027 {"cursor-color", SYMBOL_INDEX (Qcursor_color)},
3028 {"cursor-type", SYMBOL_INDEX (Qcursor_type)},
3029 {"font", -1},
3030 {"foreground-color", -1},
3031 {"icon-name", SYMBOL_INDEX (Qicon_name)},
3032 {"icon-type", SYMBOL_INDEX (Qicon_type)},
3033 {"internal-border-width", SYMBOL_INDEX (Qinternal_border_width)},
3034 {"right-divider-width", SYMBOL_INDEX (Qright_divider_width)},
3035 {"bottom-divider-width", SYMBOL_INDEX (Qbottom_divider_width)},
3036 {"menu-bar-lines", SYMBOL_INDEX (Qmenu_bar_lines)},
3037 {"mouse-color", SYMBOL_INDEX (Qmouse_color)},
3038 {"name", SYMBOL_INDEX (Qname)},
3039 {"scroll-bar-width", SYMBOL_INDEX (Qscroll_bar_width)},
3040 {"scroll-bar-height", SYMBOL_INDEX (Qscroll_bar_height)},
3041 {"title", SYMBOL_INDEX (Qtitle)},
3042 {"unsplittable", SYMBOL_INDEX (Qunsplittable)},
3043 {"vertical-scroll-bars", SYMBOL_INDEX (Qvertical_scroll_bars)},
3044 {"horizontal-scroll-bars", SYMBOL_INDEX (Qhorizontal_scroll_bars)},
3045 {"visibility", SYMBOL_INDEX (Qvisibility)},
3046 {"tool-bar-lines", SYMBOL_INDEX (Qtool_bar_lines)},
3047 {"scroll-bar-foreground", SYMBOL_INDEX (Qscroll_bar_foreground)},
3048 {"scroll-bar-background", SYMBOL_INDEX (Qscroll_bar_background)},
3049 {"screen-gamma", SYMBOL_INDEX (Qscreen_gamma)},
3050 {"line-spacing", SYMBOL_INDEX (Qline_spacing)},
3051 {"left-fringe", SYMBOL_INDEX (Qleft_fringe)},
3052 {"right-fringe", SYMBOL_INDEX (Qright_fringe)},
3053 {"wait-for-wm", SYMBOL_INDEX (Qwait_for_wm)},
3054 {"fullscreen", SYMBOL_INDEX (Qfullscreen)},
3055 {"font-backend", SYMBOL_INDEX (Qfont_backend)},
3056 {"alpha", SYMBOL_INDEX (Qalpha)},
3057 {"sticky", SYMBOL_INDEX (Qsticky)},
3058 {"tool-bar-position", SYMBOL_INDEX (Qtool_bar_position)},
3061 #ifdef HAVE_WINDOW_SYSTEM
3063 /* Change the parameters of frame F as specified by ALIST.
3064 If a parameter is not specially recognized, do nothing special;
3065 otherwise call the `x_set_...' function for that parameter.
3066 Except for certain geometry properties, always call store_frame_param
3067 to store the new value in the parameter alist. */
3069 void
3070 x_set_frame_parameters (struct frame *f, Lisp_Object alist)
3072 Lisp_Object tail;
3074 /* If both of these parameters are present, it's more efficient to
3075 set them both at once. So we wait until we've looked at the
3076 entire list before we set them. */
3077 int width IF_LINT (= 0), height IF_LINT (= 0);
3078 bool width_change = false, height_change = false;
3080 /* Same here. */
3081 Lisp_Object left, top;
3083 /* Same with these. */
3084 Lisp_Object icon_left, icon_top;
3086 /* And with this. */
3087 Lisp_Object fullscreen;
3088 bool fullscreen_change = false;
3090 /* Record in these vectors all the parms specified. */
3091 Lisp_Object *parms;
3092 Lisp_Object *values;
3093 ptrdiff_t i, p;
3094 bool left_no_change = 0, top_no_change = 0;
3095 #ifdef HAVE_X_WINDOWS
3096 bool icon_left_no_change = 0, icon_top_no_change = 0;
3097 #endif
3099 i = 0;
3100 for (tail = alist; CONSP (tail); tail = XCDR (tail))
3101 i++;
3103 USE_SAFE_ALLOCA;
3104 SAFE_ALLOCA_LISP (parms, 2 * i);
3105 values = parms + i;
3107 /* Extract parm names and values into those vectors. */
3109 i = 0;
3110 for (tail = alist; CONSP (tail); tail = XCDR (tail))
3112 Lisp_Object elt;
3114 elt = XCAR (tail);
3115 parms[i] = Fcar (elt);
3116 values[i] = Fcdr (elt);
3117 i++;
3119 /* TAIL and ALIST are not used again below here. */
3120 alist = tail = Qnil;
3122 /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
3123 because their values appear in VALUES and strings are not valid. */
3124 top = left = Qunbound;
3125 icon_left = icon_top = Qunbound;
3127 /* Process foreground_color and background_color before anything else.
3128 They are independent of other properties, but other properties (e.g.,
3129 cursor_color) are dependent upon them. */
3130 /* Process default font as well, since fringe widths depends on it. */
3131 for (p = 0; p < i; p++)
3133 Lisp_Object prop, val;
3135 prop = parms[p];
3136 val = values[p];
3137 if (EQ (prop, Qforeground_color)
3138 || EQ (prop, Qbackground_color)
3139 || EQ (prop, Qfont))
3141 register Lisp_Object param_index, old_value;
3143 old_value = get_frame_param (f, prop);
3144 if (NILP (Fequal (val, old_value)))
3146 store_frame_param (f, prop, val);
3148 param_index = Fget (prop, Qx_frame_parameter);
3149 if (NATNUMP (param_index)
3150 && XFASTINT (param_index) < ARRAYELTS (frame_parms)
3151 && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
3152 (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
3157 /* Now process them in reverse of specified order. */
3158 while (i-- != 0)
3160 Lisp_Object prop, val;
3162 prop = parms[i];
3163 val = values[i];
3165 if (EQ (prop, Qwidth) && RANGED_INTEGERP (0, val, INT_MAX))
3167 width_change = 1;
3168 width = XFASTINT (val) * FRAME_COLUMN_WIDTH (f) ;
3170 else if (EQ (prop, Qheight) && RANGED_INTEGERP (0, val, INT_MAX))
3172 height_change = 1;
3173 height = XFASTINT (val) * FRAME_LINE_HEIGHT (f);
3175 else if (EQ (prop, Qtop))
3176 top = val;
3177 else if (EQ (prop, Qleft))
3178 left = val;
3179 else if (EQ (prop, Qicon_top))
3180 icon_top = val;
3181 else if (EQ (prop, Qicon_left))
3182 icon_left = val;
3183 else if (EQ (prop, Qfullscreen))
3185 fullscreen = val;
3186 fullscreen_change = true;
3188 else if (EQ (prop, Qforeground_color)
3189 || EQ (prop, Qbackground_color)
3190 || EQ (prop, Qfont))
3191 /* Processed above. */
3192 continue;
3193 else
3195 register Lisp_Object param_index, old_value;
3197 old_value = get_frame_param (f, prop);
3199 store_frame_param (f, prop, val);
3201 param_index = Fget (prop, Qx_frame_parameter);
3202 if (NATNUMP (param_index)
3203 && XFASTINT (param_index) < ARRAYELTS (frame_parms)
3204 && FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])
3205 (*(FRAME_RIF (f)->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
3209 /* Don't die if just one of these was set. */
3210 if (EQ (left, Qunbound))
3212 left_no_change = 1;
3213 if (f->left_pos < 0)
3214 left = list2 (Qplus, make_number (f->left_pos));
3215 else
3216 XSETINT (left, f->left_pos);
3218 if (EQ (top, Qunbound))
3220 top_no_change = 1;
3221 if (f->top_pos < 0)
3222 top = list2 (Qplus, make_number (f->top_pos));
3223 else
3224 XSETINT (top, f->top_pos);
3227 /* If one of the icon positions was not set, preserve or default it. */
3228 if (! TYPE_RANGED_INTEGERP (int, icon_left))
3230 #ifdef HAVE_X_WINDOWS
3231 icon_left_no_change = 1;
3232 #endif
3233 icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
3234 if (NILP (icon_left))
3235 XSETINT (icon_left, 0);
3237 if (! TYPE_RANGED_INTEGERP (int, icon_top))
3239 #ifdef HAVE_X_WINDOWS
3240 icon_top_no_change = 1;
3241 #endif
3242 icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
3243 if (NILP (icon_top))
3244 XSETINT (icon_top, 0);
3247 /* Don't set these parameters unless they've been explicitly
3248 specified. The window might be mapped or resized while we're in
3249 this function, and we don't want to override that unless the lisp
3250 code has asked for it.
3252 Don't set these parameters unless they actually differ from the
3253 window's current parameters; the window may not actually exist
3254 yet. */
3256 Lisp_Object frame;
3258 XSETFRAME (frame, f);
3260 if ((width_change && width != FRAME_TEXT_WIDTH (f))
3261 || (height_change && height != FRAME_TEXT_HEIGHT (f))
3262 || (f->can_x_set_window_size && (f->new_height || f->new_width)))
3264 /* If necessary provide default values for HEIGHT and WIDTH. Do
3265 that here since otherwise a size change implied by an
3266 intermittent font change may get lost as in Bug#17142. */
3267 if (!width_change)
3268 width = ((f->can_x_set_window_size && f->new_width)
3269 ? (f->new_pixelwise
3270 ? f->new_width
3271 : (f->new_width * FRAME_COLUMN_WIDTH (f)))
3272 : FRAME_TEXT_WIDTH (f));
3274 if (!height_change)
3275 height = ((f->can_x_set_window_size && f->new_height)
3276 ? (f->new_pixelwise
3277 ? f->new_height
3278 : (f->new_height * FRAME_LINE_HEIGHT (f)))
3279 : FRAME_TEXT_HEIGHT (f));
3281 Fset_frame_size (frame, make_number (width), make_number (height), Qt);
3284 if ((!NILP (left) || !NILP (top))
3285 && ! (left_no_change && top_no_change)
3286 && ! (NUMBERP (left) && XINT (left) == f->left_pos
3287 && NUMBERP (top) && XINT (top) == f->top_pos))
3289 int leftpos = 0;
3290 int toppos = 0;
3292 /* Record the signs. */
3293 f->size_hint_flags &= ~ (XNegative | YNegative);
3294 if (EQ (left, Qminus))
3295 f->size_hint_flags |= XNegative;
3296 else if (TYPE_RANGED_INTEGERP (int, left))
3298 leftpos = XINT (left);
3299 if (leftpos < 0)
3300 f->size_hint_flags |= XNegative;
3302 else if (CONSP (left) && EQ (XCAR (left), Qminus)
3303 && CONSP (XCDR (left))
3304 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
3306 leftpos = - XINT (XCAR (XCDR (left)));
3307 f->size_hint_flags |= XNegative;
3309 else if (CONSP (left) && EQ (XCAR (left), Qplus)
3310 && CONSP (XCDR (left))
3311 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
3313 leftpos = XINT (XCAR (XCDR (left)));
3316 if (EQ (top, Qminus))
3317 f->size_hint_flags |= YNegative;
3318 else if (TYPE_RANGED_INTEGERP (int, top))
3320 toppos = XINT (top);
3321 if (toppos < 0)
3322 f->size_hint_flags |= YNegative;
3324 else if (CONSP (top) && EQ (XCAR (top), Qminus)
3325 && CONSP (XCDR (top))
3326 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
3328 toppos = - XINT (XCAR (XCDR (top)));
3329 f->size_hint_flags |= YNegative;
3331 else if (CONSP (top) && EQ (XCAR (top), Qplus)
3332 && CONSP (XCDR (top))
3333 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
3335 toppos = XINT (XCAR (XCDR (top)));
3339 /* Store the numeric value of the position. */
3340 f->top_pos = toppos;
3341 f->left_pos = leftpos;
3343 f->win_gravity = NorthWestGravity;
3345 /* Actually set that position, and convert to absolute. */
3346 x_set_offset (f, leftpos, toppos, -1);
3349 if (fullscreen_change)
3351 Lisp_Object old_value = get_frame_param (f, Qfullscreen);
3353 frame_size_history_add
3354 (f, Qx_set_fullscreen, 0, 0, list2 (old_value, fullscreen));
3356 store_frame_param (f, Qfullscreen, fullscreen);
3357 if (!EQ (fullscreen, old_value))
3358 x_set_fullscreen (f, fullscreen, old_value);
3362 #ifdef HAVE_X_WINDOWS
3363 if ((!NILP (icon_left) || !NILP (icon_top))
3364 && ! (icon_left_no_change && icon_top_no_change))
3365 x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
3366 #endif /* HAVE_X_WINDOWS */
3369 SAFE_FREE ();
3373 /* Insert a description of internally-recorded parameters of frame X
3374 into the parameter alist *ALISTPTR that is to be given to the user.
3375 Only parameters that are specific to the X window system
3376 and whose values are not correctly recorded in the frame's
3377 param_alist need to be considered here. */
3379 void
3380 x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
3382 Lisp_Object tem;
3383 uprintmax_t w;
3384 char buf[INT_BUFSIZE_BOUND (w)];
3386 /* Represent negative positions (off the top or left screen edge)
3387 in a way that Fmodify_frame_parameters will understand correctly. */
3388 XSETINT (tem, f->left_pos);
3389 if (f->left_pos >= 0)
3390 store_in_alist (alistptr, Qleft, tem);
3391 else
3392 store_in_alist (alistptr, Qleft, list2 (Qplus, tem));
3394 XSETINT (tem, f->top_pos);
3395 if (f->top_pos >= 0)
3396 store_in_alist (alistptr, Qtop, tem);
3397 else
3398 store_in_alist (alistptr, Qtop, list2 (Qplus, tem));
3400 store_in_alist (alistptr, Qborder_width,
3401 make_number (f->border_width));
3402 store_in_alist (alistptr, Qinternal_border_width,
3403 make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
3404 store_in_alist (alistptr, Qright_divider_width,
3405 make_number (FRAME_RIGHT_DIVIDER_WIDTH (f)));
3406 store_in_alist (alistptr, Qbottom_divider_width,
3407 make_number (FRAME_BOTTOM_DIVIDER_WIDTH (f)));
3408 store_in_alist (alistptr, Qleft_fringe,
3409 make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
3410 store_in_alist (alistptr, Qright_fringe,
3411 make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
3412 store_in_alist (alistptr, Qscroll_bar_width,
3413 (! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
3414 ? make_number (0)
3415 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
3416 ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3417 /* nil means "use default width"
3418 for non-toolkit scroll bar.
3419 ruler-mode.el depends on this. */
3420 : Qnil));
3421 store_in_alist (alistptr, Qscroll_bar_height,
3422 (! FRAME_HAS_HORIZONTAL_SCROLL_BARS (f)
3423 ? make_number (0)
3424 : FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) > 0
3425 ? make_number (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
3426 /* nil means "use default height"
3427 for non-toolkit scroll bar. */
3428 : Qnil));
3429 /* FRAME_X_WINDOW is not guaranteed to return an integer. E.g., on
3430 MS-Windows it returns a value whose type is HANDLE, which is
3431 actually a pointer. Explicit casting avoids compiler
3432 warnings. */
3433 w = (uintptr_t) FRAME_X_WINDOW (f);
3434 store_in_alist (alistptr, Qwindow_id,
3435 make_formatted_string (buf, "%"pMu, w));
3436 #ifdef HAVE_X_WINDOWS
3437 #ifdef USE_X_TOOLKIT
3438 /* Tooltip frame may not have this widget. */
3439 if (FRAME_X_OUTPUT (f)->widget)
3440 #endif
3441 w = (uintptr_t) FRAME_OUTER_WINDOW (f);
3442 store_in_alist (alistptr, Qouter_window_id,
3443 make_formatted_string (buf, "%"pMu, w));
3444 #endif
3445 store_in_alist (alistptr, Qicon_name, f->icon_name);
3446 store_in_alist (alistptr, Qvisibility,
3447 (FRAME_VISIBLE_P (f) ? Qt
3448 : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
3449 store_in_alist (alistptr, Qdisplay,
3450 XCAR (FRAME_DISPLAY_INFO (f)->name_list_element));
3452 if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_DISPLAY_INFO (f)->root_window)
3453 tem = Qnil;
3454 else
3455 tem = make_natnum ((uintptr_t) FRAME_X_OUTPUT (f)->parent_desc);
3456 store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
3457 store_in_alist (alistptr, Qparent_id, tem);
3458 store_in_alist (alistptr, Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f));
3462 /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
3463 the previous value of that parameter, NEW_VALUE is the new value. */
3465 void
3466 x_set_fullscreen (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3468 if (NILP (new_value))
3469 f->want_fullscreen = FULLSCREEN_NONE;
3470 else if (EQ (new_value, Qfullboth) || EQ (new_value, Qfullscreen))
3471 f->want_fullscreen = FULLSCREEN_BOTH;
3472 else if (EQ (new_value, Qfullwidth))
3473 f->want_fullscreen = FULLSCREEN_WIDTH;
3474 else if (EQ (new_value, Qfullheight))
3475 f->want_fullscreen = FULLSCREEN_HEIGHT;
3476 else if (EQ (new_value, Qmaximized))
3477 f->want_fullscreen = FULLSCREEN_MAXIMIZED;
3479 if (FRAME_TERMINAL (f)->fullscreen_hook != NULL)
3480 FRAME_TERMINAL (f)->fullscreen_hook (f);
3484 /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
3485 the previous value of that parameter, NEW_VALUE is the new value. */
3487 void
3488 x_set_line_spacing (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3490 if (NILP (new_value))
3491 f->extra_line_spacing = 0;
3492 else if (RANGED_INTEGERP (0, new_value, INT_MAX))
3493 f->extra_line_spacing = XFASTINT (new_value);
3494 else if (FLOATP (new_value))
3496 int new_spacing = XFLOAT_DATA (new_value) * FRAME_LINE_HEIGHT (f) + 0.5;
3498 if (new_spacing >= 0)
3499 f->extra_line_spacing = new_spacing;
3500 else
3501 signal_error ("Invalid line-spacing", new_value);
3503 else
3504 signal_error ("Invalid line-spacing", new_value);
3505 if (FRAME_VISIBLE_P (f))
3506 redraw_frame (f);
3510 /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
3511 the previous value of that parameter, NEW_VALUE is the new value. */
3513 void
3514 x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3516 Lisp_Object bgcolor;
3518 if (NILP (new_value))
3519 f->gamma = 0;
3520 else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
3521 /* The value 0.4545 is the normal viewing gamma. */
3522 f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
3523 else
3524 signal_error ("Invalid screen-gamma", new_value);
3526 /* Apply the new gamma value to the frame background. */
3527 bgcolor = Fassq (Qbackground_color, f->param_alist);
3528 if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
3530 Lisp_Object parm_index = Fget (Qbackground_color, Qx_frame_parameter);
3531 if (NATNUMP (parm_index)
3532 && XFASTINT (parm_index) < ARRAYELTS (frame_parms)
3533 && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
3534 (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
3535 (f, bgcolor, Qnil);
3538 Fclear_face_cache (Qnil);
3542 void
3543 x_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3545 Lisp_Object font_object;
3546 int fontset = -1;
3547 #ifdef HAVE_X_WINDOWS
3548 Lisp_Object font_param = arg;
3549 #endif
3551 /* Set the frame parameter back to the old value because we may
3552 fail to use ARG as the new parameter value. */
3553 store_frame_param (f, Qfont, oldval);
3555 /* ARG is a fontset name, a font name, a cons of fontset name and a
3556 font object, or a font object. In the last case, this function
3557 never fail. */
3558 if (STRINGP (arg))
3560 fontset = fs_query_fontset (arg, 0);
3561 if (fontset < 0)
3563 font_object = font_open_by_name (f, arg);
3564 if (NILP (font_object))
3565 error ("Font `%s' is not defined", SSDATA (arg));
3566 arg = AREF (font_object, FONT_NAME_INDEX);
3568 else if (fontset > 0)
3570 font_object = font_open_by_name (f, fontset_ascii (fontset));
3571 if (NILP (font_object))
3572 error ("Font `%s' is not defined", SDATA (arg));
3573 arg = AREF (font_object, FONT_NAME_INDEX);
3575 else
3576 error ("The default fontset can't be used for a frame font");
3578 else if (CONSP (arg) && STRINGP (XCAR (arg)) && FONT_OBJECT_P (XCDR (arg)))
3580 /* This is the case that the ASCII font of F's fontset XCAR
3581 (arg) is changed to the font XCDR (arg) by
3582 `set-fontset-font'. */
3583 fontset = fs_query_fontset (XCAR (arg), 0);
3584 if (fontset < 0)
3585 error ("Unknown fontset: %s", SDATA (XCAR (arg)));
3586 font_object = XCDR (arg);
3587 arg = AREF (font_object, FONT_NAME_INDEX);
3588 #ifdef HAVE_X_WINDOWS
3589 font_param = Ffont_get (font_object, QCname);
3590 #endif
3592 else if (FONT_OBJECT_P (arg))
3594 font_object = arg;
3595 #ifdef HAVE_X_WINDOWS
3596 font_param = Ffont_get (font_object, QCname);
3597 #endif
3598 /* This is to store the XLFD font name in the frame parameter for
3599 backward compatibility. We should store the font-object
3600 itself in the future. */
3601 arg = AREF (font_object, FONT_NAME_INDEX);
3602 fontset = FRAME_FONTSET (f);
3603 /* Check if we can use the current fontset. If not, set FONTSET
3604 to -1 to generate a new fontset from FONT-OBJECT. */
3605 if (fontset >= 0)
3607 Lisp_Object ascii_font = fontset_ascii (fontset);
3608 Lisp_Object spec = font_spec_from_name (ascii_font);
3610 if (NILP (spec))
3611 signal_error ("Invalid font name", ascii_font);
3613 if (! font_match_p (spec, font_object))
3614 fontset = -1;
3617 else
3618 signal_error ("Invalid font", arg);
3620 if (! NILP (Fequal (font_object, oldval)))
3621 return;
3623 x_new_font (f, font_object, fontset);
3624 store_frame_param (f, Qfont, arg);
3625 #ifdef HAVE_X_WINDOWS
3626 store_frame_param (f, Qfont_param, font_param);
3627 #endif
3628 /* Recalculate toolbar height. */
3629 f->n_tool_bar_rows = 0;
3630 f->tool_bar_redisplayed_once = false;
3632 /* Ensure we redraw it. */
3633 clear_current_matrices (f);
3635 /* Attempt to hunt down bug#16028. */
3636 SET_FRAME_GARBAGED (f);
3638 recompute_basic_faces (f);
3640 do_pending_window_change (0);
3642 /* We used to call face-set-after-frame-default here, but it leads to
3643 recursive calls (since that function can set the `default' face's
3644 font which in turns changes the frame's `font' parameter).
3645 Also I don't know what this call is meant to do, but it seems the
3646 wrong way to do it anyway (it does a lot more work than what seems
3647 reasonable in response to a change to `font'). */
3651 void
3652 x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3654 if (! NILP (new_value)
3655 && !CONSP (new_value))
3657 char *p0, *p1;
3659 CHECK_STRING (new_value);
3660 p0 = p1 = SSDATA (new_value);
3661 new_value = Qnil;
3662 while (*p0)
3664 while (*p1 && ! c_isspace (*p1) && *p1 != ',') p1++;
3665 if (p0 < p1)
3666 new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
3667 new_value);
3668 if (*p1)
3670 int c;
3672 while ((c = *++p1) && c_isspace (c));
3674 p0 = p1;
3676 new_value = Fnreverse (new_value);
3679 if (! NILP (old_value) && ! NILP (Fequal (old_value, new_value)))
3680 return;
3682 if (FRAME_FONT (f))
3683 free_all_realized_faces (Qnil);
3685 new_value = font_update_drivers (f, NILP (new_value) ? Qt : new_value);
3686 if (NILP (new_value))
3688 if (NILP (old_value))
3689 error ("No font backend available");
3690 font_update_drivers (f, old_value);
3691 error ("None of specified font backends are available");
3693 store_frame_param (f, Qfont_backend, new_value);
3695 if (FRAME_FONT (f))
3697 Lisp_Object frame;
3699 XSETFRAME (frame, f);
3700 x_set_font (f, Fframe_parameter (frame, Qfont), Qnil);
3701 face_change = true;
3702 windows_or_buffers_changed = 18;
3706 void
3707 x_set_left_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3709 int unit = FRAME_COLUMN_WIDTH (f);
3710 int old_width = FRAME_LEFT_FRINGE_WIDTH (f);
3711 int new_width;
3713 new_width = (RANGED_INTEGERP (-INT_MAX, new_value, INT_MAX)
3714 ? eabs (XINT (new_value)) : 8);
3716 if (new_width != old_width)
3718 FRAME_LEFT_FRINGE_WIDTH (f) = new_width;
3719 FRAME_FRINGE_COLS (f) /* Round up. */
3720 = (new_width + FRAME_RIGHT_FRINGE_WIDTH (f) + unit - 1) / unit;
3722 if (FRAME_X_WINDOW (f) != 0)
3723 adjust_frame_size (f, -1, -1, 3, 0, Qleft_fringe);
3725 SET_FRAME_GARBAGED (f);
3730 void
3731 x_set_right_fringe (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
3733 int unit = FRAME_COLUMN_WIDTH (f);
3734 int old_width = FRAME_RIGHT_FRINGE_WIDTH (f);
3735 int new_width;
3737 new_width = (RANGED_INTEGERP (-INT_MAX, new_value, INT_MAX)
3738 ? eabs (XINT (new_value)) : 8);
3740 if (new_width != old_width)
3742 FRAME_RIGHT_FRINGE_WIDTH (f) = new_width;
3743 FRAME_FRINGE_COLS (f) /* Round up. */
3744 = (new_width + FRAME_LEFT_FRINGE_WIDTH (f) + unit - 1) / unit;
3746 if (FRAME_X_WINDOW (f) != 0)
3747 adjust_frame_size (f, -1, -1, 3, 0, Qright_fringe);
3749 SET_FRAME_GARBAGED (f);
3754 void
3755 x_set_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3757 CHECK_TYPE_RANGED_INTEGER (int, arg);
3759 if (XINT (arg) == f->border_width)
3760 return;
3762 if (FRAME_X_WINDOW (f) != 0)
3763 error ("Cannot change the border width of a frame");
3765 f->border_width = XINT (arg);
3768 void
3769 x_set_right_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3771 int old = FRAME_RIGHT_DIVIDER_WIDTH (f);
3773 CHECK_TYPE_RANGED_INTEGER (int, arg);
3774 FRAME_RIGHT_DIVIDER_WIDTH (f) = XINT (arg);
3775 if (FRAME_RIGHT_DIVIDER_WIDTH (f) < 0)
3776 FRAME_RIGHT_DIVIDER_WIDTH (f) = 0;
3777 if (FRAME_RIGHT_DIVIDER_WIDTH (f) != old)
3779 adjust_frame_size (f, -1, -1, 4, 0, Qright_divider_width);
3780 adjust_frame_glyphs (f);
3781 SET_FRAME_GARBAGED (f);
3786 void
3787 x_set_bottom_divider_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3789 int old = FRAME_BOTTOM_DIVIDER_WIDTH (f);
3791 CHECK_TYPE_RANGED_INTEGER (int, arg);
3792 FRAME_BOTTOM_DIVIDER_WIDTH (f) = XINT (arg);
3793 if (FRAME_BOTTOM_DIVIDER_WIDTH (f) < 0)
3794 FRAME_BOTTOM_DIVIDER_WIDTH (f) = 0;
3795 if (FRAME_BOTTOM_DIVIDER_WIDTH (f) != old)
3797 adjust_frame_size (f, -1, -1, 4, 0, Qbottom_divider_width);
3798 adjust_frame_glyphs (f);
3799 SET_FRAME_GARBAGED (f);
3803 void
3804 x_set_visibility (struct frame *f, Lisp_Object value, Lisp_Object oldval)
3806 Lisp_Object frame;
3807 XSETFRAME (frame, f);
3809 if (NILP (value))
3810 Fmake_frame_invisible (frame, Qt);
3811 else if (EQ (value, Qicon))
3812 Ficonify_frame (frame);
3813 else
3814 Fmake_frame_visible (frame);
3817 void
3818 x_set_autoraise (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3820 f->auto_raise = !EQ (Qnil, arg);
3823 void
3824 x_set_autolower (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3826 f->auto_lower = !EQ (Qnil, arg);
3829 void
3830 x_set_unsplittable (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3832 f->no_split = !NILP (arg);
3835 void
3836 x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3838 if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
3839 || (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
3840 || (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
3841 || (!NILP (arg) && !FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
3843 FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
3844 = (NILP (arg)
3845 ? vertical_scroll_bar_none
3846 : EQ (Qleft, arg)
3847 ? vertical_scroll_bar_left
3848 : EQ (Qright, arg)
3849 ? vertical_scroll_bar_right
3850 : EQ (Qleft, Vdefault_frame_scroll_bars)
3851 ? vertical_scroll_bar_left
3852 : EQ (Qright, Vdefault_frame_scroll_bars)
3853 ? vertical_scroll_bar_right
3854 : vertical_scroll_bar_none);
3856 /* We set this parameter before creating the X window for the
3857 frame, so we can get the geometry right from the start.
3858 However, if the window hasn't been created yet, we shouldn't
3859 call x_set_window_size. */
3860 if (FRAME_X_WINDOW (f))
3861 adjust_frame_size (f, -1, -1, 3, 0, Qvertical_scroll_bars);
3863 SET_FRAME_GARBAGED (f);
3867 void
3868 x_set_horizontal_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3870 #if USE_HORIZONTAL_SCROLL_BARS
3871 if ((NILP (arg) && FRAME_HAS_HORIZONTAL_SCROLL_BARS (f))
3872 || (!NILP (arg) && !FRAME_HAS_HORIZONTAL_SCROLL_BARS (f)))
3874 f->horizontal_scroll_bars = NILP (arg) ? false : true;
3876 /* We set this parameter before creating the X window for the
3877 frame, so we can get the geometry right from the start.
3878 However, if the window hasn't been created yet, we shouldn't
3879 call x_set_window_size. */
3880 if (FRAME_X_WINDOW (f))
3881 adjust_frame_size (f, -1, -1, 3, 0, Qhorizontal_scroll_bars);
3883 SET_FRAME_GARBAGED (f);
3885 #endif
3888 void
3889 x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3891 int unit = FRAME_COLUMN_WIDTH (f);
3893 if (NILP (arg))
3895 x_set_scroll_bar_default_width (f);
3897 if (FRAME_X_WINDOW (f))
3898 adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_width);
3900 SET_FRAME_GARBAGED (f);
3902 else if (RANGED_INTEGERP (1, arg, INT_MAX)
3903 && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
3905 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
3906 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + unit - 1) / unit;
3907 if (FRAME_X_WINDOW (f))
3908 adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_width);
3910 SET_FRAME_GARBAGED (f);
3913 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
3914 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
3917 void
3918 x_set_scroll_bar_height (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3920 #if USE_HORIZONTAL_SCROLL_BARS
3921 int unit = FRAME_LINE_HEIGHT (f);
3923 if (NILP (arg))
3925 x_set_scroll_bar_default_height (f);
3927 if (FRAME_X_WINDOW (f))
3928 adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_height);
3930 SET_FRAME_GARBAGED (f);
3932 else if (RANGED_INTEGERP (1, arg, INT_MAX)
3933 && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_HEIGHT (f))
3935 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = XFASTINT (arg);
3936 FRAME_CONFIG_SCROLL_BAR_LINES (f) = (XFASTINT (arg) + unit - 1) / unit;
3937 if (FRAME_X_WINDOW (f))
3938 adjust_frame_size (f, -1, -1, 3, 0, Qscroll_bar_height);
3940 SET_FRAME_GARBAGED (f);
3943 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.vpos = 0;
3944 XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.y = 0;
3945 #endif
3948 void
3949 x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
3951 double alpha = 1.0;
3952 double newval[2];
3953 int i;
3954 Lisp_Object item;
3956 for (i = 0; i < 2; i++)
3958 newval[i] = 1.0;
3959 if (CONSP (arg))
3961 item = CAR (arg);
3962 arg = CDR (arg);
3964 else
3965 item = arg;
3967 if (NILP (item))
3968 alpha = - 1.0;
3969 else if (FLOATP (item))
3971 alpha = XFLOAT_DATA (item);
3972 if (! (0 <= alpha && alpha <= 1.0))
3973 args_out_of_range (make_float (0.0), make_float (1.0));
3975 else if (INTEGERP (item))
3977 EMACS_INT ialpha = XINT (item);
3978 if (! (0 <= ialpha && alpha <= 100))
3979 args_out_of_range (make_number (0), make_number (100));
3980 alpha = ialpha / 100.0;
3982 else
3983 wrong_type_argument (Qnumberp, item);
3984 newval[i] = alpha;
3987 for (i = 0; i < 2; i++)
3988 f->alpha[i] = newval[i];
3990 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA)
3991 block_input ();
3992 x_set_frame_alpha (f);
3993 unblock_input ();
3994 #endif
3996 return;
3999 #ifndef HAVE_NS
4001 /* Non-zero if mouse is grabbed on DPYINFO
4002 and we know the frame where it is. */
4004 bool x_mouse_grabbed (Display_Info *dpyinfo)
4006 return (dpyinfo->grabbed
4007 && dpyinfo->last_mouse_frame
4008 && FRAME_LIVE_P (dpyinfo->last_mouse_frame));
4011 /* Re-highlight something with mouse-face properties
4012 on DPYINFO using saved frame and mouse position. */
4014 void
4015 x_redo_mouse_highlight (Display_Info *dpyinfo)
4017 if (dpyinfo->last_mouse_motion_frame
4018 && FRAME_LIVE_P (dpyinfo->last_mouse_motion_frame))
4019 note_mouse_highlight (dpyinfo->last_mouse_motion_frame,
4020 dpyinfo->last_mouse_motion_x,
4021 dpyinfo->last_mouse_motion_y);
4024 #endif /* HAVE_NS */
4026 /* Subroutines of creating an X frame. */
4028 /* Make sure that Vx_resource_name is set to a reasonable value.
4029 Fix it up, or set it to `emacs' if it is too hopeless. */
4031 void
4032 validate_x_resource_name (void)
4034 ptrdiff_t len = 0;
4035 /* Number of valid characters in the resource name. */
4036 ptrdiff_t good_count = 0;
4037 /* Number of invalid characters in the resource name. */
4038 ptrdiff_t bad_count = 0;
4039 Lisp_Object new;
4040 ptrdiff_t i;
4042 if (!STRINGP (Vx_resource_class))
4043 Vx_resource_class = build_string (EMACS_CLASS);
4045 if (STRINGP (Vx_resource_name))
4047 unsigned char *p = SDATA (Vx_resource_name);
4049 len = SBYTES (Vx_resource_name);
4051 /* Only letters, digits, - and _ are valid in resource names.
4052 Count the valid characters and count the invalid ones. */
4053 for (i = 0; i < len; i++)
4055 int c = p[i];
4056 if (! ((c >= 'a' && c <= 'z')
4057 || (c >= 'A' && c <= 'Z')
4058 || (c >= '0' && c <= '9')
4059 || c == '-' || c == '_'))
4060 bad_count++;
4061 else
4062 good_count++;
4065 else
4066 /* Not a string => completely invalid. */
4067 bad_count = 5, good_count = 0;
4069 /* If name is valid already, return. */
4070 if (bad_count == 0)
4071 return;
4073 /* If name is entirely invalid, or nearly so, or is so implausibly
4074 large that alloca might not work, use `emacs'. */
4075 if (good_count < 2 || MAX_ALLOCA - sizeof ".customization" < len)
4077 Vx_resource_name = build_string ("emacs");
4078 return;
4081 /* Name is partly valid. Copy it and replace the invalid characters
4082 with underscores. */
4084 Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
4086 for (i = 0; i < len; i++)
4088 int c = SREF (new, i);
4089 if (! ((c >= 'a' && c <= 'z')
4090 || (c >= 'A' && c <= 'Z')
4091 || (c >= '0' && c <= '9')
4092 || c == '-' || c == '_'))
4093 SSET (new, i, '_');
4097 /* Get specified attribute from resource database RDB.
4098 See Fx_get_resource below for other parameters. */
4100 static Lisp_Object
4101 xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
4103 CHECK_STRING (attribute);
4104 CHECK_STRING (class);
4106 if (!NILP (component))
4107 CHECK_STRING (component);
4108 if (!NILP (subclass))
4109 CHECK_STRING (subclass);
4110 if (NILP (component) != NILP (subclass))
4111 error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
4113 validate_x_resource_name ();
4115 /* Allocate space for the components, the dots which separate them,
4116 and the final '\0'. Make them big enough for the worst case. */
4117 ptrdiff_t name_keysize = (SBYTES (Vx_resource_name)
4118 + (STRINGP (component)
4119 ? SBYTES (component) : 0)
4120 + SBYTES (attribute)
4121 + 3);
4123 ptrdiff_t class_keysize = (SBYTES (Vx_resource_class)
4124 + SBYTES (class)
4125 + (STRINGP (subclass)
4126 ? SBYTES (subclass) : 0)
4127 + 3);
4128 USE_SAFE_ALLOCA;
4129 char *name_key = SAFE_ALLOCA (name_keysize + class_keysize);
4130 char *class_key = name_key + name_keysize;
4132 /* Start with emacs.FRAMENAME for the name (the specific one)
4133 and with `Emacs' for the class key (the general one). */
4134 char *nz = lispstpcpy (name_key, Vx_resource_name);
4135 char *cz = lispstpcpy (class_key, Vx_resource_class);
4137 *cz++ = '.';
4138 cz = lispstpcpy (cz, class);
4140 if (!NILP (component))
4142 *cz++ = '.';
4143 lispstpcpy (cz, subclass);
4145 *nz++ = '.';
4146 nz = lispstpcpy (nz, component);
4149 *nz++ = '.';
4150 lispstpcpy (nz, attribute);
4152 char *value = x_get_string_resource (rdb, name_key, class_key);
4153 SAFE_FREE();
4155 if (value && *value)
4156 return build_string (value);
4157 else
4158 return Qnil;
4162 DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
4163 doc: /* Return the value of ATTRIBUTE, of class CLASS, from the X defaults database.
4164 This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
4165 class, where INSTANCE is the name under which Emacs was invoked, or
4166 the name specified by the `-name' or `-rn' command-line arguments.
4168 The optional arguments COMPONENT and SUBCLASS add to the key and the
4169 class, respectively. You must specify both of them or neither.
4170 If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
4171 and the class is `Emacs.CLASS.SUBCLASS'. */)
4172 (Lisp_Object attribute, Lisp_Object class, Lisp_Object component,
4173 Lisp_Object subclass)
4175 check_window_system (NULL);
4177 return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
4178 attribute, class, component, subclass);
4181 /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
4183 Lisp_Object
4184 display_x_get_resource (Display_Info *dpyinfo, Lisp_Object attribute,
4185 Lisp_Object class, Lisp_Object component,
4186 Lisp_Object subclass)
4188 return xrdb_get_resource (dpyinfo->xrdb,
4189 attribute, class, component, subclass);
4192 #if defined HAVE_X_WINDOWS && !defined USE_X_TOOLKIT && !defined USE_GTK
4193 /* Used when C code wants a resource value. */
4194 /* Called from oldXMenu/Create.c. */
4195 char *
4196 x_get_resource_string (const char *attribute, const char *class)
4198 char *result;
4199 struct frame *sf = SELECTED_FRAME ();
4200 ptrdiff_t invocation_namelen = SBYTES (Vinvocation_name);
4201 USE_SAFE_ALLOCA;
4203 /* Allocate space for the components, the dots which separate them,
4204 and the final '\0'. */
4205 ptrdiff_t name_keysize = invocation_namelen + strlen (attribute) + 2;
4206 ptrdiff_t class_keysize = sizeof (EMACS_CLASS) - 1 + strlen (class) + 2;
4207 char *name_key = SAFE_ALLOCA (name_keysize + class_keysize);
4208 char *class_key = name_key + name_keysize;
4210 esprintf (name_key, "%s.%s", SSDATA (Vinvocation_name), attribute);
4211 sprintf (class_key, "%s.%s", EMACS_CLASS, class);
4213 result = x_get_string_resource (FRAME_DISPLAY_INFO (sf)->xrdb,
4214 name_key, class_key);
4215 SAFE_FREE ();
4216 return result;
4218 #endif
4220 /* Return the value of parameter PARAM.
4222 First search ALIST, then Vdefault_frame_alist, then the X defaults
4223 database, using ATTRIBUTE as the attribute name and CLASS as its class.
4225 Convert the resource to the type specified by desired_type.
4227 If no default is specified, return Qunbound. If you call
4228 x_get_arg, make sure you deal with Qunbound in a reasonable way,
4229 and don't let it get stored in any Lisp-visible variables! */
4231 Lisp_Object
4232 x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
4233 const char *attribute, const char *class, enum resource_types type)
4235 Lisp_Object tem;
4237 tem = Fassq (param, alist);
4239 if (!NILP (tem))
4241 /* If we find this parm in ALIST, clear it out
4242 so that it won't be "left over" at the end. */
4243 Lisp_Object tail;
4244 XSETCAR (tem, Qnil);
4245 /* In case the parameter appears more than once in the alist,
4246 clear it out. */
4247 for (tail = alist; CONSP (tail); tail = XCDR (tail))
4248 if (CONSP (XCAR (tail))
4249 && EQ (XCAR (XCAR (tail)), param))
4250 XSETCAR (XCAR (tail), Qnil);
4252 else
4253 tem = Fassq (param, Vdefault_frame_alist);
4255 /* If it wasn't specified in ALIST or the Lisp-level defaults,
4256 look in the X resources. */
4257 if (EQ (tem, Qnil))
4259 if (attribute && dpyinfo)
4261 AUTO_STRING (at, attribute);
4262 AUTO_STRING (cl, class);
4263 tem = display_x_get_resource (dpyinfo, at, cl, Qnil, Qnil);
4265 if (NILP (tem))
4266 return Qunbound;
4268 switch (type)
4270 case RES_TYPE_NUMBER:
4271 return make_number (atoi (SSDATA (tem)));
4273 case RES_TYPE_BOOLEAN_NUMBER:
4274 if (!strcmp (SSDATA (tem), "on")
4275 || !strcmp (SSDATA (tem), "true"))
4276 return make_number (1);
4277 return make_number (atoi (SSDATA (tem)));
4278 break;
4280 case RES_TYPE_FLOAT:
4281 return make_float (atof (SSDATA (tem)));
4283 case RES_TYPE_BOOLEAN:
4284 tem = Fdowncase (tem);
4285 if (!strcmp (SSDATA (tem), "on")
4286 #ifdef HAVE_NS
4287 || !strcmp (SSDATA (tem), "yes")
4288 #endif
4289 || !strcmp (SSDATA (tem), "true"))
4290 return Qt;
4291 else
4292 return Qnil;
4294 case RES_TYPE_STRING:
4295 return tem;
4297 case RES_TYPE_SYMBOL:
4298 /* As a special case, we map the values `true' and `on'
4299 to Qt, and `false' and `off' to Qnil. */
4301 Lisp_Object lower;
4302 lower = Fdowncase (tem);
4303 if (!strcmp (SSDATA (lower), "on")
4304 #ifdef HAVE_NS
4305 || !strcmp (SSDATA (lower), "yes")
4306 #endif
4307 || !strcmp (SSDATA (lower), "true"))
4308 return Qt;
4309 else if (!strcmp (SSDATA (lower), "off")
4310 #ifdef HAVE_NS
4311 || !strcmp (SSDATA (lower), "no")
4312 #endif
4313 || !strcmp (SSDATA (lower), "false"))
4314 return Qnil;
4315 else
4316 return Fintern (tem, Qnil);
4319 default:
4320 emacs_abort ();
4323 else
4324 return Qunbound;
4326 return Fcdr (tem);
4329 static Lisp_Object
4330 x_frame_get_arg (struct frame *f, Lisp_Object alist, Lisp_Object param,
4331 const char *attribute, const char *class,
4332 enum resource_types type)
4334 return x_get_arg (FRAME_DISPLAY_INFO (f),
4335 alist, param, attribute, class, type);
4338 /* Like x_frame_get_arg, but also record the value in f->param_alist. */
4340 Lisp_Object
4341 x_frame_get_and_record_arg (struct frame *f, Lisp_Object alist,
4342 Lisp_Object param,
4343 const char *attribute, const char *class,
4344 enum resource_types type)
4346 Lisp_Object value;
4348 value = x_get_arg (FRAME_DISPLAY_INFO (f), alist, param,
4349 attribute, class, type);
4350 if (! NILP (value) && ! EQ (value, Qunbound))
4351 store_frame_param (f, param, value);
4353 return value;
4357 /* Record in frame F the specified or default value according to ALIST
4358 of the parameter named PROP (a Lisp symbol).
4359 If no value is specified for PROP, look for an X default for XPROP
4360 on the frame named NAME.
4361 If that is not found either, use the value DEFLT. */
4363 Lisp_Object
4364 x_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop,
4365 Lisp_Object deflt, const char *xprop, const char *xclass,
4366 enum resource_types type)
4368 Lisp_Object tem;
4370 tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
4371 if (EQ (tem, Qunbound))
4372 tem = deflt;
4373 AUTO_FRAME_ARG (arg, prop, tem);
4374 x_set_frame_parameters (f, arg);
4375 return tem;
4379 #if !defined (HAVE_X_WINDOWS) && defined (NoValue)
4382 * XParseGeometry parses strings of the form
4383 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
4384 * width, height, xoffset, and yoffset are unsigned integers.
4385 * Example: "=80x24+300-49"
4386 * The equal sign is optional.
4387 * It returns a bitmask that indicates which of the four values
4388 * were actually found in the string. For each value found,
4389 * the corresponding argument is updated; for each value
4390 * not found, the corresponding argument is left unchanged.
4393 static int
4394 XParseGeometry (char *string,
4395 int *x, int *y,
4396 unsigned int *width, unsigned int *height)
4398 int mask = NoValue;
4399 char *strind;
4400 unsigned long tempWidth, tempHeight;
4401 long int tempX, tempY;
4402 char *nextCharacter;
4404 if (string == NULL || *string == '\0')
4405 return mask;
4406 if (*string == '=')
4407 string++; /* ignore possible '=' at beg of geometry spec */
4409 strind = string;
4410 if (*strind != '+' && *strind != '-' && *strind != 'x')
4412 tempWidth = strtoul (strind, &nextCharacter, 10);
4413 if (strind == nextCharacter)
4414 return 0;
4415 strind = nextCharacter;
4416 mask |= WidthValue;
4419 if (*strind == 'x' || *strind == 'X')
4421 strind++;
4422 tempHeight = strtoul (strind, &nextCharacter, 10);
4423 if (strind == nextCharacter)
4424 return 0;
4425 strind = nextCharacter;
4426 mask |= HeightValue;
4429 if (*strind == '+' || *strind == '-')
4431 if (*strind == '-')
4432 mask |= XNegative;
4433 tempX = strtol (strind, &nextCharacter, 10);
4434 if (strind == nextCharacter)
4435 return 0;
4436 strind = nextCharacter;
4437 mask |= XValue;
4438 if (*strind == '+' || *strind == '-')
4440 if (*strind == '-')
4441 mask |= YNegative;
4442 tempY = strtol (strind, &nextCharacter, 10);
4443 if (strind == nextCharacter)
4444 return 0;
4445 strind = nextCharacter;
4446 mask |= YValue;
4450 /* If strind isn't at the end of the string then it's an invalid
4451 geometry specification. */
4453 if (*strind != '\0')
4454 return 0;
4456 if (mask & XValue)
4457 *x = clip_to_bounds (INT_MIN, tempX, INT_MAX);
4458 if (mask & YValue)
4459 *y = clip_to_bounds (INT_MIN, tempY, INT_MAX);
4460 if (mask & WidthValue)
4461 *width = min (tempWidth, UINT_MAX);
4462 if (mask & HeightValue)
4463 *height = min (tempHeight, UINT_MAX);
4464 return mask;
4467 #endif /* !defined (HAVE_X_WINDOWS) && defined (NoValue) */
4470 /* NS used to define x-parse-geometry in ns-win.el, but that confused
4471 make-docfile: the documentation string in ns-win.el was used for
4472 x-parse-geometry even in non-NS builds.
4474 With two definitions of x-parse-geometry in this file, various
4475 things still get confused (eg M-x apropos documentation), so that
4476 it is best if the two definitions just share the same doc-string.
4478 DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
4479 doc: /* Parse a display geometry string STRING.
4480 Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
4481 The properties returned may include `top', `left', `height', and `width'.
4482 For X, the value of `left' or `top' may be an integer,
4483 or a list (+ N) meaning N pixels relative to top/left corner,
4484 or a list (- N) meaning -N pixels relative to bottom/right corner.
4485 On Nextstep, this just calls `ns-parse-geometry'. */)
4486 (Lisp_Object string)
4488 int geometry, x, y;
4489 unsigned int width, height;
4490 Lisp_Object result;
4492 CHECK_STRING (string);
4494 #ifdef HAVE_NS
4495 if (strchr (SSDATA (string), ' ') != NULL)
4496 return call1 (Qns_parse_geometry, string);
4497 #endif
4498 geometry = XParseGeometry (SSDATA (string),
4499 &x, &y, &width, &height);
4500 result = Qnil;
4501 if (geometry & XValue)
4503 Lisp_Object element;
4505 if (x >= 0 && (geometry & XNegative))
4506 element = list3 (Qleft, Qminus, make_number (-x));
4507 else if (x < 0 && ! (geometry & XNegative))
4508 element = list3 (Qleft, Qplus, make_number (x));
4509 else
4510 element = Fcons (Qleft, make_number (x));
4511 result = Fcons (element, result);
4514 if (geometry & YValue)
4516 Lisp_Object element;
4518 if (y >= 0 && (geometry & YNegative))
4519 element = list3 (Qtop, Qminus, make_number (-y));
4520 else if (y < 0 && ! (geometry & YNegative))
4521 element = list3 (Qtop, Qplus, make_number (y));
4522 else
4523 element = Fcons (Qtop, make_number (y));
4524 result = Fcons (element, result);
4527 if (geometry & WidthValue)
4528 result = Fcons (Fcons (Qwidth, make_number (width)), result);
4529 if (geometry & HeightValue)
4530 result = Fcons (Fcons (Qheight, make_number (height)), result);
4532 return result;
4536 /* Calculate the desired size and position of frame F.
4537 Return the flags saying which aspects were specified.
4539 Also set the win_gravity and size_hint_flags of F.
4541 Adjust height for toolbar if TOOLBAR_P is 1.
4543 This function does not make the coordinates positive. */
4545 #define DEFAULT_ROWS 35
4546 #define DEFAULT_COLS 80
4548 long
4549 x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p)
4551 Lisp_Object height, width, user_size, top, left, user_position;
4552 long window_prompting = 0;
4553 Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
4555 /* Default values if we fall through.
4556 Actually, if that happens we should get
4557 window manager prompting. */
4558 SET_FRAME_WIDTH (f, DEFAULT_COLS * FRAME_COLUMN_WIDTH (f));
4559 SET_FRAME_COLS (f, DEFAULT_COLS);
4560 SET_FRAME_HEIGHT (f, DEFAULT_ROWS * FRAME_LINE_HEIGHT (f));
4561 SET_FRAME_LINES (f, DEFAULT_ROWS);
4563 /* Window managers expect that if program-specified
4564 positions are not (0,0), they're intentional, not defaults. */
4565 f->top_pos = 0;
4566 f->left_pos = 0;
4568 /* Ensure that earlier new_width and new_height settings won't
4569 override what we specify below. */
4570 f->new_width = f->new_height = 0;
4572 height = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
4573 width = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
4574 if (!EQ (width, Qunbound) || !EQ (height, Qunbound))
4576 if (!EQ (width, Qunbound))
4578 CHECK_NUMBER (width);
4579 if (! (0 <= XINT (width) && XINT (width) <= INT_MAX))
4580 xsignal1 (Qargs_out_of_range, width);
4582 SET_FRAME_WIDTH (f, XINT (width) * FRAME_COLUMN_WIDTH (f));
4585 if (!EQ (height, Qunbound))
4587 CHECK_NUMBER (height);
4588 if (! (0 <= XINT (height) && XINT (height) <= INT_MAX))
4589 xsignal1 (Qargs_out_of_range, height);
4591 SET_FRAME_HEIGHT (f, XINT (height) * FRAME_LINE_HEIGHT (f));
4594 user_size = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
4595 if (!NILP (user_size) && !EQ (user_size, Qunbound))
4596 window_prompting |= USSize;
4597 else
4598 window_prompting |= PSize;
4601 /* Add a tool bar height to the initial frame height so that the user
4602 gets a text display area of the size he specified with -g or via
4603 .Xdefaults. Later changes of the tool bar height don't change the
4604 frame size. This is done so that users can create tall Emacs
4605 frames without having to guess how tall the tool bar will get. */
4606 if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
4608 if (frame_default_tool_bar_height)
4609 FRAME_TOOL_BAR_HEIGHT (f) = frame_default_tool_bar_height;
4610 else
4612 int margin, relief;
4614 relief = (tool_bar_button_relief >= 0
4615 ? tool_bar_button_relief
4616 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
4618 if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
4619 margin = XFASTINT (Vtool_bar_button_margin);
4620 else if (CONSP (Vtool_bar_button_margin)
4621 && RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
4622 margin = XFASTINT (XCDR (Vtool_bar_button_margin));
4623 else
4624 margin = 0;
4626 FRAME_TOOL_BAR_HEIGHT (f)
4627 = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
4631 top = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
4632 left = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
4633 user_position = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
4634 if (! EQ (top, Qunbound) || ! EQ (left, Qunbound))
4636 if (EQ (top, Qminus))
4638 f->top_pos = 0;
4639 window_prompting |= YNegative;
4641 else if (CONSP (top) && EQ (XCAR (top), Qminus)
4642 && CONSP (XCDR (top))
4643 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
4645 f->top_pos = - XINT (XCAR (XCDR (top)));
4646 window_prompting |= YNegative;
4648 else if (CONSP (top) && EQ (XCAR (top), Qplus)
4649 && CONSP (XCDR (top))
4650 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
4652 f->top_pos = XINT (XCAR (XCDR (top)));
4654 else if (EQ (top, Qunbound))
4655 f->top_pos = 0;
4656 else
4658 CHECK_TYPE_RANGED_INTEGER (int, top);
4659 f->top_pos = XINT (top);
4660 if (f->top_pos < 0)
4661 window_prompting |= YNegative;
4664 if (EQ (left, Qminus))
4666 f->left_pos = 0;
4667 window_prompting |= XNegative;
4669 else if (CONSP (left) && EQ (XCAR (left), Qminus)
4670 && CONSP (XCDR (left))
4671 && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
4673 f->left_pos = - XINT (XCAR (XCDR (left)));
4674 window_prompting |= XNegative;
4676 else if (CONSP (left) && EQ (XCAR (left), Qplus)
4677 && CONSP (XCDR (left))
4678 && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
4680 f->left_pos = XINT (XCAR (XCDR (left)));
4682 else if (EQ (left, Qunbound))
4683 f->left_pos = 0;
4684 else
4686 CHECK_TYPE_RANGED_INTEGER (int, left);
4687 f->left_pos = XINT (left);
4688 if (f->left_pos < 0)
4689 window_prompting |= XNegative;
4692 if (!NILP (user_position) && ! EQ (user_position, Qunbound))
4693 window_prompting |= USPosition;
4694 else
4695 window_prompting |= PPosition;
4698 if (window_prompting & XNegative)
4700 if (window_prompting & YNegative)
4701 f->win_gravity = SouthEastGravity;
4702 else
4703 f->win_gravity = NorthEastGravity;
4705 else
4707 if (window_prompting & YNegative)
4708 f->win_gravity = SouthWestGravity;
4709 else
4710 f->win_gravity = NorthWestGravity;
4713 f->size_hint_flags = window_prompting;
4715 return window_prompting;
4720 #endif /* HAVE_WINDOW_SYSTEM */
4722 void
4723 frame_make_pointer_invisible (struct frame *f)
4725 if (! NILP (Vmake_pointer_invisible))
4727 if (f && FRAME_LIVE_P (f) && !f->pointer_invisible
4728 && FRAME_TERMINAL (f)->toggle_invisible_pointer_hook)
4730 f->mouse_moved = 0;
4731 FRAME_TERMINAL (f)->toggle_invisible_pointer_hook (f, 1);
4732 f->pointer_invisible = 1;
4737 void
4738 frame_make_pointer_visible (struct frame *f)
4740 /* We don't check Vmake_pointer_invisible here in case the
4741 pointer was invisible when Vmake_pointer_invisible was set to nil. */
4742 if (f && FRAME_LIVE_P (f) && f->pointer_invisible && f->mouse_moved
4743 && FRAME_TERMINAL (f)->toggle_invisible_pointer_hook)
4745 FRAME_TERMINAL (f)->toggle_invisible_pointer_hook (f, 0);
4746 f->pointer_invisible = 0;
4750 DEFUN ("frame-pointer-visible-p", Fframe_pointer_visible_p,
4751 Sframe_pointer_visible_p, 0, 1, 0,
4752 doc: /* Return t if the mouse pointer displayed on FRAME is visible.
4753 Otherwise it returns nil. FRAME omitted or nil means the
4754 selected frame. This is useful when `make-pointer-invisible' is set. */)
4755 (Lisp_Object frame)
4757 return decode_any_frame (frame)->pointer_invisible ? Qnil : Qt;
4762 /***********************************************************************
4763 Multimonitor data
4764 ***********************************************************************/
4766 #ifdef HAVE_WINDOW_SYSTEM
4768 # if (defined HAVE_NS \
4769 || (!defined USE_GTK && (defined HAVE_XINERAMA || defined HAVE_XRANDR)))
4770 void
4771 free_monitors (struct MonitorInfo *monitors, int n_monitors)
4773 int i;
4774 for (i = 0; i < n_monitors; ++i)
4775 xfree (monitors[i].name);
4776 xfree (monitors);
4778 # endif
4780 Lisp_Object
4781 make_monitor_attribute_list (struct MonitorInfo *monitors,
4782 int n_monitors,
4783 int primary_monitor,
4784 Lisp_Object monitor_frames,
4785 const char *source)
4787 Lisp_Object attributes_list = Qnil;
4788 Lisp_Object primary_monitor_attributes = Qnil;
4789 int i;
4791 for (i = 0; i < n_monitors; ++i)
4793 Lisp_Object geometry, workarea, attributes = Qnil;
4794 struct MonitorInfo *mi = &monitors[i];
4796 if (mi->geom.width == 0) continue;
4798 workarea = list4i (mi->work.x, mi->work.y,
4799 mi->work.width, mi->work.height);
4800 geometry = list4i (mi->geom.x, mi->geom.y,
4801 mi->geom.width, mi->geom.height);
4802 attributes = Fcons (Fcons (Qsource, build_string (source)),
4803 attributes);
4804 attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
4805 attributes);
4806 attributes = Fcons (Fcons (Qmm_size,
4807 list2i (mi->mm_width, mi->mm_height)),
4808 attributes);
4809 attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
4810 attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
4811 if (mi->name)
4812 attributes = Fcons (Fcons (Qname, make_string (mi->name,
4813 strlen (mi->name))),
4814 attributes);
4816 if (i == primary_monitor)
4817 primary_monitor_attributes = attributes;
4818 else
4819 attributes_list = Fcons (attributes, attributes_list);
4822 if (!NILP (primary_monitor_attributes))
4823 attributes_list = Fcons (primary_monitor_attributes, attributes_list);
4824 return attributes_list;
4827 #endif /* HAVE_WINDOW_SYSTEM */
4830 /***********************************************************************
4831 Initialization
4832 ***********************************************************************/
4834 void
4835 syms_of_frame (void)
4837 DEFSYM (Qframep, "framep");
4838 DEFSYM (Qframe_live_p, "frame-live-p");
4839 DEFSYM (Qframe_windows_min_size, "frame-windows-min-size");
4840 DEFSYM (Qwindow_pixel_to_total, "window--pixel-to-total");
4841 DEFSYM (Qexplicit_name, "explicit-name");
4842 DEFSYM (Qheight, "height");
4843 DEFSYM (Qicon, "icon");
4844 DEFSYM (Qminibuffer, "minibuffer");
4845 DEFSYM (Qmodeline, "modeline");
4846 DEFSYM (Qonly, "only");
4847 DEFSYM (Qnone, "none");
4848 DEFSYM (Qwidth, "width");
4849 DEFSYM (Qgeometry, "geometry");
4850 DEFSYM (Qicon_left, "icon-left");
4851 DEFSYM (Qicon_top, "icon-top");
4852 DEFSYM (Qtooltip, "tooltip");
4853 DEFSYM (Quser_position, "user-position");
4854 DEFSYM (Quser_size, "user-size");
4855 DEFSYM (Qwindow_id, "window-id");
4856 #ifdef HAVE_X_WINDOWS
4857 DEFSYM (Qouter_window_id, "outer-window-id");
4858 #endif
4859 DEFSYM (Qparent_id, "parent-id");
4860 DEFSYM (Qx, "x");
4861 DEFSYM (Qw32, "w32");
4862 DEFSYM (Qpc, "pc");
4863 DEFSYM (Qns, "ns");
4864 DEFSYM (Qvisible, "visible");
4865 DEFSYM (Qbuffer_predicate, "buffer-predicate");
4866 DEFSYM (Qbuffer_list, "buffer-list");
4867 DEFSYM (Qburied_buffer_list, "buried-buffer-list");
4868 DEFSYM (Qdisplay_type, "display-type");
4869 DEFSYM (Qbackground_mode, "background-mode");
4870 DEFSYM (Qnoelisp, "noelisp");
4871 DEFSYM (Qtty_color_mode, "tty-color-mode");
4872 DEFSYM (Qtty, "tty");
4873 DEFSYM (Qtty_type, "tty-type");
4875 DEFSYM (Qface_set_after_frame_default, "face-set-after-frame-default");
4877 DEFSYM (Qfullwidth, "fullwidth");
4878 DEFSYM (Qfullheight, "fullheight");
4879 DEFSYM (Qfullboth, "fullboth");
4880 DEFSYM (Qmaximized, "maximized");
4881 DEFSYM (Qx_resource_name, "x-resource-name");
4882 DEFSYM (Qx_frame_parameter, "x-frame-parameter");
4884 DEFSYM (Qterminal, "terminal");
4886 DEFSYM (Qworkarea, "workarea");
4887 DEFSYM (Qmm_size, "mm-size");
4888 DEFSYM (Qframes, "frames");
4889 DEFSYM (Qsource, "source");
4891 DEFSYM (Qframe_position, "frame-position");
4892 DEFSYM (Qframe_outer_size, "frame-outer-size");
4893 DEFSYM (Qexternal_border_size, "external-border-size");
4894 DEFSYM (Qtitle_height, "title-height");
4895 DEFSYM (Qmenu_bar_external, "menu-bar-external");
4896 DEFSYM (Qmenu_bar_size, "menu-bar-size");
4897 DEFSYM (Qtool_bar_external, "tool-bar-external");
4898 DEFSYM (Qtool_bar_size, "tool-bar-size");
4899 DEFSYM (Qframe_inner_size, "frame-inner-size");
4900 /* The following are used for frame_size_history. */
4901 DEFSYM (Qadjust_frame_size_1, "adjust-frame-size-1");
4902 DEFSYM (Qadjust_frame_size_2, "adjust-frame-size-2");
4903 DEFSYM (Qadjust_frame_size_3, "adjust-frame-size-3");
4904 DEFSYM (QEmacsFrameResize, "EmacsFrameResize");
4905 DEFSYM (Qframe_inhibit_resize, "frame-inhibit-resize");
4906 DEFSYM (Qx_set_fullscreen, "x-set-fullscreen");
4907 DEFSYM (Qx_check_fullscreen, "x-check-fullscreen");
4908 DEFSYM (Qxg_frame_resized, "xg-frame-resized");
4909 DEFSYM (Qxg_frame_set_char_size_1, "xg-frame-set-char-size-1");
4910 DEFSYM (Qxg_frame_set_char_size_2, "xg-frame-set-char-size-2");
4911 DEFSYM (Qxg_frame_set_char_size_3, "xg-frame-set-char-size-3");
4912 DEFSYM (Qxg_change_toolbar_position, "xg-change-toolbar-position");
4913 DEFSYM (Qx_net_wm_state, "x-net-wm-state");
4914 DEFSYM (Qx_handle_net_wm_state, "x-handle-net-wm-state");
4915 DEFSYM (Qtb_size_cb, "tb-size-cb");
4916 DEFSYM (Qupdate_frame_tool_bar, "update-frame-tool-bar");
4917 DEFSYM (Qfree_frame_tool_bar, "free-frame-tool-bar");
4919 DEFSYM (Qchange_frame_size, "change-frame-size");
4920 DEFSYM (Qxg_frame_set_char_size, "xg-frame-set-char-size");
4921 DEFSYM (Qset_window_configuration, "set-window-configuration");
4922 DEFSYM (Qx_create_frame_1, "x-create-frame-1");
4923 DEFSYM (Qx_create_frame_2, "x-create-frame-2");
4924 DEFSYM (Qterminal_frame, "terminal-frame");
4926 #ifdef HAVE_NS
4927 DEFSYM (Qns_parse_geometry, "ns-parse-geometry");
4928 #endif
4930 DEFSYM (Qalpha, "alpha");
4931 DEFSYM (Qauto_lower, "auto-lower");
4932 DEFSYM (Qauto_raise, "auto-raise");
4933 DEFSYM (Qborder_color, "border-color");
4934 DEFSYM (Qborder_width, "border-width");
4935 DEFSYM (Qbottom_divider_width, "bottom-divider-width");
4936 DEFSYM (Qcursor_color, "cursor-color");
4937 DEFSYM (Qcursor_type, "cursor-type");
4938 DEFSYM (Qfont_backend, "font-backend");
4939 DEFSYM (Qfullscreen, "fullscreen");
4940 DEFSYM (Qhorizontal_scroll_bars, "horizontal-scroll-bars");
4941 DEFSYM (Qicon_name, "icon-name");
4942 DEFSYM (Qicon_type, "icon-type");
4943 DEFSYM (Qinternal_border_width, "internal-border-width");
4944 DEFSYM (Qleft_fringe, "left-fringe");
4945 DEFSYM (Qline_spacing, "line-spacing");
4946 DEFSYM (Qmenu_bar_lines, "menu-bar-lines");
4947 DEFSYM (Qmouse_color, "mouse-color");
4948 DEFSYM (Qname, "name");
4949 DEFSYM (Qright_divider_width, "right-divider-width");
4950 DEFSYM (Qright_fringe, "right-fringe");
4951 DEFSYM (Qscreen_gamma, "screen-gamma");
4952 DEFSYM (Qscroll_bar_background, "scroll-bar-background");
4953 DEFSYM (Qscroll_bar_foreground, "scroll-bar-foreground");
4954 DEFSYM (Qscroll_bar_height, "scroll-bar-height");
4955 DEFSYM (Qscroll_bar_width, "scroll-bar-width");
4956 DEFSYM (Qsticky, "sticky");
4957 DEFSYM (Qtitle, "title");
4958 DEFSYM (Qtool_bar_lines, "tool-bar-lines");
4959 DEFSYM (Qtool_bar_position, "tool-bar-position");
4960 DEFSYM (Qunsplittable, "unsplittable");
4961 DEFSYM (Qvertical_scroll_bars, "vertical-scroll-bars");
4962 DEFSYM (Qvisibility, "visibility");
4963 DEFSYM (Qwait_for_wm, "wait-for-wm");
4966 int i;
4968 for (i = 0; i < ARRAYELTS (frame_parms); i++)
4970 Lisp_Object v = (frame_parms[i].sym < 0
4971 ? intern_c_string (frame_parms[i].name)
4972 : builtin_lisp_symbol (frame_parms[i].sym));
4973 Fput (v, Qx_frame_parameter, make_number (i));
4977 #ifdef HAVE_WINDOW_SYSTEM
4978 DEFVAR_LISP ("x-resource-name", Vx_resource_name,
4979 doc: /* The name Emacs uses to look up X resources.
4980 `x-get-resource' uses this as the first component of the instance name
4981 when requesting resource values.
4982 Emacs initially sets `x-resource-name' to the name under which Emacs
4983 was invoked, or to the value specified with the `-name' or `-rn'
4984 switches, if present.
4986 It may be useful to bind this variable locally around a call
4987 to `x-get-resource'. See also the variable `x-resource-class'. */);
4988 Vx_resource_name = Qnil;
4990 DEFVAR_LISP ("x-resource-class", Vx_resource_class,
4991 doc: /* The class Emacs uses to look up X resources.
4992 `x-get-resource' uses this as the first component of the instance class
4993 when requesting resource values.
4995 Emacs initially sets `x-resource-class' to "Emacs".
4997 Setting this variable permanently is not a reasonable thing to do,
4998 but binding this variable locally around a call to `x-get-resource'
4999 is a reasonable practice. See also the variable `x-resource-name'. */);
5000 Vx_resource_class = build_string (EMACS_CLASS);
5002 DEFVAR_LISP ("frame-alpha-lower-limit", Vframe_alpha_lower_limit,
5003 doc: /* The lower limit of the frame opacity (alpha transparency).
5004 The value should range from 0 (invisible) to 100 (completely opaque).
5005 You can also use a floating number between 0.0 and 1.0. */);
5006 Vframe_alpha_lower_limit = make_number (20);
5007 #endif
5009 DEFVAR_LISP ("default-frame-alist", Vdefault_frame_alist,
5010 doc: /* Alist of default values for frame creation.
5011 These may be set in your init file, like this:
5012 (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1)))
5013 These override values given in window system configuration data,
5014 including X Windows' defaults database.
5015 For values specific to the first Emacs frame, see `initial-frame-alist'.
5016 For window-system specific values, see `window-system-default-frame-alist'.
5017 For values specific to the separate minibuffer frame, see
5018 `minibuffer-frame-alist'.
5019 The `menu-bar-lines' element of the list controls whether new frames
5020 have menu bars; `menu-bar-mode' works by altering this element.
5021 Setting this variable does not affect existing frames, only new ones. */);
5022 Vdefault_frame_alist = Qnil;
5024 DEFVAR_LISP ("default-frame-scroll-bars", Vdefault_frame_scroll_bars,
5025 doc: /* Default position of vertical scroll bars on this window-system. */);
5026 #ifdef HAVE_WINDOW_SYSTEM
5027 #if defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA) || (defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS))
5028 /* MS-Windows, Mac OS X, and GTK have scroll bars on the right by
5029 default. */
5030 Vdefault_frame_scroll_bars = Qright;
5031 #else
5032 Vdefault_frame_scroll_bars = Qleft;
5033 #endif
5034 #else
5035 Vdefault_frame_scroll_bars = Qnil;
5036 #endif
5038 DEFVAR_BOOL ("scroll-bar-adjust-thumb-portion",
5039 scroll_bar_adjust_thumb_portion_p,
5040 doc: /* Adjust thumb for overscrolling for Gtk+ and MOTIF.
5041 Non-nil means adjust the thumb in the scroll bar so it can be dragged downwards
5042 even if the end of the buffer is shown (i.e. overscrolling).
5043 Set to nil if you want the thumb to be at the bottom when the end of the buffer
5044 is shown. Also, the thumb fills the whole scroll bar when the entire buffer
5045 is visible. In this case you can not overscroll. */);
5046 scroll_bar_adjust_thumb_portion_p = 1;
5048 DEFVAR_LISP ("terminal-frame", Vterminal_frame,
5049 doc: /* The initial frame-object, which represents Emacs's stdout. */);
5051 DEFVAR_LISP ("mouse-position-function", Vmouse_position_function,
5052 doc: /* If non-nil, function to transform normal value of `mouse-position'.
5053 `mouse-position' and `mouse-pixel-position' call this function, passing their
5054 usual return value as argument, and return whatever this function returns.
5055 This abnormal hook exists for the benefit of packages like `xt-mouse.el'
5056 which need to do mouse handling at the Lisp level. */);
5057 Vmouse_position_function = Qnil;
5059 DEFVAR_LISP ("mouse-highlight", Vmouse_highlight,
5060 doc: /* If non-nil, clickable text is highlighted when mouse is over it.
5061 If the value is an integer, highlighting is only shown after moving the
5062 mouse, while keyboard input turns off the highlight even when the mouse
5063 is over the clickable text. However, the mouse shape still indicates
5064 when the mouse is over clickable text. */);
5065 Vmouse_highlight = Qt;
5067 DEFVAR_LISP ("make-pointer-invisible", Vmake_pointer_invisible,
5068 doc: /* If non-nil, make pointer invisible while typing.
5069 The pointer becomes visible again when the mouse is moved. */);
5070 Vmake_pointer_invisible = Qt;
5072 DEFVAR_LISP ("focus-in-hook", Vfocus_in_hook,
5073 doc: /* Normal hook run when a frame gains input focus. */);
5074 Vfocus_in_hook = Qnil;
5076 DEFVAR_LISP ("focus-out-hook", Vfocus_out_hook,
5077 doc: /* Normal hook run when a frame loses input focus. */);
5078 Vfocus_out_hook = Qnil;
5080 DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
5081 doc: /* Functions run before deleting a frame.
5082 The functions are run with one arg, the frame to be deleted.
5083 See `delete-frame'.
5085 Note that functions in this list may be called just before the frame is
5086 actually deleted, or some time later (or even both when an earlier function
5087 in `delete-frame-functions' (indirectly) calls `delete-frame'
5088 recursively). */);
5089 Vdelete_frame_functions = Qnil;
5090 DEFSYM (Qdelete_frame_functions, "delete-frame-functions");
5092 DEFVAR_LISP ("menu-bar-mode", Vmenu_bar_mode,
5093 doc: /* Non-nil if Menu-Bar mode is enabled.
5094 See the command `menu-bar-mode' for a description of this minor mode.
5095 Setting this variable directly does not take effect;
5096 either customize it (see the info node `Easy Customization')
5097 or call the function `menu-bar-mode'. */);
5098 Vmenu_bar_mode = Qt;
5100 DEFVAR_LISP ("tool-bar-mode", Vtool_bar_mode,
5101 doc: /* Non-nil if Tool-Bar mode is enabled.
5102 See the command `tool-bar-mode' for a description of this minor mode.
5103 Setting this variable directly does not take effect;
5104 either customize it (see the info node `Easy Customization')
5105 or call the function `tool-bar-mode'. */);
5106 #ifdef HAVE_WINDOW_SYSTEM
5107 Vtool_bar_mode = Qt;
5108 #else
5109 Vtool_bar_mode = Qnil;
5110 #endif
5112 DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
5113 doc: /* Minibufferless frames use this frame's minibuffer.
5114 Emacs cannot create minibufferless frames unless this is set to an
5115 appropriate surrogate.
5117 Emacs consults this variable only when creating minibufferless
5118 frames; once the frame is created, it sticks with its assigned
5119 minibuffer, no matter what this variable is set to. This means that
5120 this variable doesn't necessarily say anything meaningful about the
5121 current set of frames, or where the minibuffer is currently being
5122 displayed.
5124 This variable is local to the current terminal and cannot be buffer-local. */);
5126 DEFVAR_BOOL ("focus-follows-mouse", focus_follows_mouse,
5127 doc: /* Non-nil if window system changes focus when you move the mouse.
5128 You should set this variable to tell Emacs how your window manager
5129 handles focus, since there is no way in general for Emacs to find out
5130 automatically. See also `mouse-autoselect-window'. */);
5131 focus_follows_mouse = 0;
5133 DEFVAR_BOOL ("frame-resize-pixelwise", frame_resize_pixelwise,
5134 doc: /* Non-nil means resize frames pixelwise.
5135 If this option is nil, resizing a frame rounds its sizes to the frame's
5136 current values of `frame-char-height' and `frame-char-width'. If this
5137 is non-nil, no rounding occurs, hence frame sizes can increase/decrease
5138 by one pixel.
5140 With some window managers you may have to set this to non-nil in order
5141 to set the size of a frame in pixels, to maximize frames or to make them
5142 fullscreen. To resize your initial frame pixelwise, set this option to
5143 a non-nil value in your init file. */);
5144 frame_resize_pixelwise = 0;
5146 DEFVAR_LISP ("frame-inhibit-implied-resize", frame_inhibit_implied_resize,
5147 doc: /* Whether frames should be resized implicitly.
5148 If this option is nil, setting font, menu bar, tool bar, internal
5149 borders, fringes or scroll bars of a specific frame may resize the frame
5150 in order to preserve the number of columns or lines it displays. If
5151 this option is t, no such resizing is done. Note that the size of
5152 fullscreen and maximized frames, the height of fullheight frames and the
5153 width of fullwidth frames never change implicitly.
5155 The value of this option can be also be a list of frame parameters. In
5156 this case, resizing is inhibited when changing a parameter that appears
5157 in that list. The parameters currently handled by this option include
5158 `font', `font-backend', `internal-border-width', `menu-bar-lines' and
5159 `tool-bar-lines'.
5161 Changing any of the parameters `scroll-bar-width', `scroll-bar-height',
5162 `vertical-scroll-bars', `horizontal-scroll-bars', `left-fringe' and
5163 `right-fringe' is handled as if the frame contained just one live
5164 window. This means, for example, that removing vertical scroll bars on
5165 a frame containing several side by side windows will shrink the frame
5166 width by the width of one scroll bar provided this option is nil and
5167 keep it unchanged if this option is either t or a list containing
5168 `vertical-scroll-bars'.
5170 The default value is '(tool-bar-lines) on Lucid, Motif and Windows
5171 \(which means that adding/removing a tool bar does not change the frame
5172 height), nil on all other window systems including GTK+ (which means
5173 that changing any of the parameters listed above may change the size of
5174 the frame), and t otherwise (which means the frame size never changes
5175 implicitly when there's no window system support).
5177 Note that when a frame is not large enough to accommodate a change of
5178 any of the parameters listed above, Emacs may try to enlarge the frame
5179 even if this option is non-nil. */);
5180 #if defined (HAVE_WINDOW_SYSTEM)
5181 #if defined (USE_LUCID) || defined (USE_MOTIF) || defined (HAVE_NTGUI)
5182 frame_inhibit_implied_resize = list1 (Qtool_bar_lines);
5183 #else
5184 frame_inhibit_implied_resize = Qnil;
5185 #endif
5186 #else
5187 frame_inhibit_implied_resize = Qt;
5188 #endif
5190 DEFVAR_LISP ("frame-size-history", frame_size_history,
5191 doc: /* History of frame size adjustments.
5192 If non-nil, list recording frame size adjustment. Adjustments are
5193 recorded only if the first element of this list is a positive number.
5194 Adding an adjustment decrements that number by one.
5196 The remaining elements are the adjustments. Each adjustment is a list
5197 of four elements `frame', `function', `sizes' and `more'. `frame' is
5198 the affected frame and `function' the invoking function. `sizes' is
5199 usually a list of four elements `old-width', `old-height', `new-width'
5200 and `new-height' representing the old and new sizes recorded/requested
5201 by `function'. `more' is a list with additional information.
5203 The function `frame--size-history' displays the value of this variable
5204 in a more readable form. */);
5205 frame_size_history = Qnil;
5207 staticpro (&Vframe_list);
5209 defsubr (&Sframep);
5210 defsubr (&Sframe_live_p);
5211 defsubr (&Swindow_system);
5212 defsubr (&Sframe_windows_min_size);
5213 defsubr (&Smake_terminal_frame);
5214 defsubr (&Shandle_switch_frame);
5215 defsubr (&Sselect_frame);
5216 defsubr (&Sselected_frame);
5217 defsubr (&Sframe_list);
5218 defsubr (&Snext_frame);
5219 defsubr (&Sprevious_frame);
5220 defsubr (&Slast_nonminibuf_frame);
5221 defsubr (&Sdelete_frame);
5222 defsubr (&Smouse_position);
5223 defsubr (&Smouse_pixel_position);
5224 defsubr (&Sset_mouse_position);
5225 defsubr (&Sset_mouse_pixel_position);
5226 #if 0
5227 defsubr (&Sframe_configuration);
5228 defsubr (&Srestore_frame_configuration);
5229 #endif
5230 defsubr (&Smake_frame_visible);
5231 defsubr (&Smake_frame_invisible);
5232 defsubr (&Siconify_frame);
5233 defsubr (&Sframe_visible_p);
5234 defsubr (&Svisible_frame_list);
5235 defsubr (&Sraise_frame);
5236 defsubr (&Slower_frame);
5237 defsubr (&Sx_focus_frame);
5238 defsubr (&Sframe_after_make_frame);
5239 defsubr (&Sredirect_frame_focus);
5240 defsubr (&Sframe_focus);
5241 defsubr (&Sframe_parameters);
5242 defsubr (&Sframe_parameter);
5243 defsubr (&Smodify_frame_parameters);
5244 defsubr (&Sframe_char_height);
5245 defsubr (&Sframe_char_width);
5246 defsubr (&Sframe_pixel_height);
5247 defsubr (&Sframe_pixel_width);
5248 defsubr (&Sframe_text_cols);
5249 defsubr (&Sframe_text_lines);
5250 defsubr (&Sframe_total_cols);
5251 defsubr (&Sframe_total_lines);
5252 defsubr (&Sframe_text_width);
5253 defsubr (&Sframe_text_height);
5254 defsubr (&Sscroll_bar_width);
5255 defsubr (&Sscroll_bar_height);
5256 defsubr (&Sfringe_width);
5257 defsubr (&Sborder_width);
5258 defsubr (&Sright_divider_width);
5259 defsubr (&Sbottom_divider_width);
5260 defsubr (&Stool_bar_pixel_width);
5261 defsubr (&Sset_frame_height);
5262 defsubr (&Sset_frame_width);
5263 defsubr (&Sset_frame_size);
5264 defsubr (&Sset_frame_position);
5265 defsubr (&Sframe_pointer_visible_p);
5267 #ifdef HAVE_WINDOW_SYSTEM
5268 defsubr (&Sx_get_resource);
5269 defsubr (&Sx_parse_geometry);
5270 #endif