[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] Changes to emacs/src/frame.c [Boehm-GC]
From: |
Dave Love |
Subject: |
[Emacs-diffs] Changes to emacs/src/frame.c [Boehm-GC] |
Date: |
Wed, 11 Jun 2003 07:44:45 -0400 |
Index: emacs/src/frame.c
diff -c /dev/null emacs/src/frame.c:1.299.2.1
*** /dev/null Wed Jun 11 07:44:45 2003
--- emacs/src/frame.c Wed Jun 11 07:44:45 2003
***************
*** 0 ****
--- 1,4137 ----
+ /* Generic frame functions.
+ Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2003
+ Free Software Foundation.
+
+ This file is part of GNU Emacs.
+
+ GNU Emacs is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
+
+ GNU Emacs is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNU Emacs; see the file COPYING. If not, write to
+ the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
+
+ #include <config.h>
+
+ #include <stdio.h>
+ #ifdef BOEHM_GC
+ #include <gc.h>
+ #endif
+ #include "lisp.h"
+ #include "charset.h"
+ #ifdef HAVE_X_WINDOWS
+ #include "xterm.h"
+ #endif
+ #ifdef WINDOWSNT
+ #include "w32term.h"
+ #endif
+ #ifdef MAC_OS
+ #include "macterm.h"
+ #endif
+ #include "buffer.h"
+ /* These help us bind and responding to switch-frame events. */
+ #include "commands.h"
+ #include "keyboard.h"
+ #include "frame.h"
+ #ifdef HAVE_WINDOW_SYSTEM
+ #include "fontset.h"
+ #endif
+ #include "blockinput.h"
+ #include "termhooks.h"
+ #include "dispextern.h"
+ #include "window.h"
+ #ifdef MSDOS
+ #include "msdos.h"
+ #include "dosfns.h"
+ #endif
+
+
+ #ifdef HAVE_WINDOW_SYSTEM
+
+ /* The name we're using in resource queries. Most often "emacs". */
+
+ Lisp_Object Vx_resource_name;
+
+ /* The application class we're using in resource queries.
+ Normally "Emacs". */
+
+ Lisp_Object Vx_resource_class;
+
+ #endif
+
+ Lisp_Object Qframep, Qframe_live_p;
+ Lisp_Object Qicon, Qmodeline;
+ Lisp_Object Qonly;
+ Lisp_Object Qx, Qw32, Qmac, Qpc;
+ Lisp_Object Qvisible;
+ Lisp_Object Qdisplay_type;
+ Lisp_Object Qbackground_mode;
+ Lisp_Object Qinhibit_default_face_x_resources;
+
+ Lisp_Object Qx_frame_parameter;
+ Lisp_Object Qx_resource_name;
+
+ /* Frame parameters (set or reported). */
+
+ Lisp_Object Qauto_raise, Qauto_lower;
+ Lisp_Object Qborder_color, Qborder_width;
+ Lisp_Object Qcursor_color, Qcursor_type;
+ Lisp_Object Qgeometry; /* Not used */
+ Lisp_Object Qheight, Qwidth;
+ Lisp_Object Qleft, Qright;
+ Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
+ Lisp_Object Qinternal_border_width;
+ Lisp_Object Qmouse_color;
+ Lisp_Object Qminibuffer;
+ Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
+ Lisp_Object Qvisibility;
+ Lisp_Object Qscroll_bar_foreground, Qscroll_bar_background;
+ Lisp_Object Qscreen_gamma;
+ Lisp_Object Qline_spacing;
+ Lisp_Object Quser_position, Quser_size;
+ Lisp_Object Qwait_for_wm;
+ Lisp_Object Qwindow_id;
+ #ifdef HAVE_X_WINDOWS
+ Lisp_Object Qouter_window_id;
+ #endif
+ Lisp_Object Qparent_id;
+ Lisp_Object Qtitle, Qname;
+ Lisp_Object Qunsplittable;
+ Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
+ Lisp_Object Qleft_fringe, Qright_fringe;
+ Lisp_Object Qbuffer_predicate, Qbuffer_list;
+ Lisp_Object Qtty_color_mode;
+
+ Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth;
+
+ Lisp_Object Qface_set_after_frame_default;
+
+
+ Lisp_Object Vterminal_frame;
+ Lisp_Object Vdefault_frame_alist;
+ Lisp_Object Vmouse_position_function;
+ Lisp_Object Vmouse_highlight;
+ Lisp_Object Vdelete_frame_functions;
+
+ static void
+ set_menu_bar_lines_1 (window, n)
+ Lisp_Object window;
+ int n;
+ {
+ struct window *w = XWINDOW (window);
+
+ XSETFASTINT (w->last_modified, 0);
+ XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
+ XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
+
+ if (INTEGERP (w->orig_top_line))
+ XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
+ if (INTEGERP (w->orig_total_lines))
+ XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
+
+ /* Handle just the top child in a vertical split. */
+ if (!NILP (w->vchild))
+ set_menu_bar_lines_1 (w->vchild, n);
+
+ /* Adjust all children in a horizontal split. */
+ for (window = w->hchild; !NILP (window); window = w->next)
+ {
+ w = XWINDOW (window);
+ set_menu_bar_lines_1 (window, n);
+ }
+ }
+
+ void
+ set_menu_bar_lines (f, value, oldval)
+ struct frame *f;
+ Lisp_Object value, oldval;
+ {
+ int nlines;
+ int olines = FRAME_MENU_BAR_LINES (f);
+
+ /* Right now, menu bars don't work properly in minibuf-only frames;
+ most of the commands try to apply themselves to the minibuffer
+ frame itself, and get an error because you can't switch buffers
+ in or split the minibuffer window. */
+ if (FRAME_MINIBUF_ONLY_P (f))
+ return;
+
+ if (INTEGERP (value))
+ nlines = XINT (value);
+ else
+ nlines = 0;
+
+ if (nlines != olines)
+ {
+ windows_or_buffers_changed++;
+ FRAME_WINDOW_SIZES_CHANGED (f) = 1;
+ FRAME_MENU_BAR_LINES (f) = nlines;
+ set_menu_bar_lines_1 (f->root_window, nlines - olines);
+ adjust_glyphs (f);
+ }
+ }
+
+ Lisp_Object Vemacs_iconified;
+ Lisp_Object Vframe_list;
+
+ struct x_output tty_display;
+
+ extern Lisp_Object Vminibuffer_list;
+ extern Lisp_Object get_minibuffer ();
+ extern Lisp_Object Fhandle_switch_frame ();
+ extern Lisp_Object Fredirect_frame_focus ();
+ extern Lisp_Object x_get_focus_frame ();
+
+ DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
+ doc: /* Return non-nil if OBJECT is a frame.
+ Value is t for a termcap frame (a character-only terminal),
+ `x' for an Emacs frame that is really an X window,
+ `w32' for an Emacs frame that is a window on MS-Windows display,
+ `mac' for an Emacs frame on a Macintosh display,
+ `pc' for a direct-write MS-DOS frame.
+ See also `frame-live-p'. */)
+ (object)
+ Lisp_Object object;
+ {
+ if (!FRAMEP (object))
+ return Qnil;
+ switch (XFRAME (object)->output_method)
+ {
+ case output_termcap:
+ return Qt;
+ case output_x_window:
+ return Qx;
+ case output_w32:
+ return Qw32;
+ case output_msdos_raw:
+ return Qpc;
+ case output_mac:
+ return Qmac;
+ default:
+ abort ();
+ }
+ }
+
+ DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
+ doc: /* Return non-nil if OBJECT is a frame which has not been deleted.
+ Value is nil if OBJECT is not a live frame. If object is a live
+ frame, the return value indicates what sort of output device it is
+ displayed on. See the documentation of `framep' for possible
+ return values. */)
+ (object)
+ Lisp_Object object;
+ {
+ return ((FRAMEP (object)
+ && FRAME_LIVE_P (XFRAME (object)))
+ ? Fframep (object)
+ : Qnil);
+ }
+
+ struct frame *
+ make_frame (mini_p)
+ int mini_p;
+ {
+ Lisp_Object frame;
+ register struct frame *f;
+ register Lisp_Object root_window;
+ register Lisp_Object mini_window;
+
+ f = allocate_frame ();
+ XSETFRAME (frame, f);
+
+ f->desired_matrix = 0;
+ f->current_matrix = 0;
+ f->desired_pool = 0;
+ f->current_pool = 0;
+ f->glyphs_initialized_p = 0;
+ f->decode_mode_spec_buffer = 0;
+ f->visible = 0;
+ f->async_visible = 0;
+ f->output_data.nothing = 0;
+ f->iconified = 0;
+ f->async_iconified = 0;
+ f->wants_modeline = 1;
+ f->auto_raise = 0;
+ f->auto_lower = 0;
+ f->no_split = 0;
+ f->garbaged = 1;
+ f->has_minibuffer = mini_p;
+ f->focus_frame = Qnil;
+ f->explicit_name = 0;
+ f->can_have_scroll_bars = 0;
+ f->vertical_scroll_bar_type = vertical_scroll_bar_none;
+ f->param_alist = Qnil;
+ f->scroll_bars = Qnil;
+ f->condemned_scroll_bars = Qnil;
+ f->face_alist = Qnil;
+ f->face_cache = NULL;
+ f->menu_bar_items = Qnil;
+ f->menu_bar_vector = Qnil;
+ f->menu_bar_items_used = 0;
+ f->buffer_predicate = Qnil;
+ f->buffer_list = Qnil;
+ #ifdef MULTI_KBOARD
+ f->kboard = initial_kboard;
+ #endif
+ f->namebuf = 0;
+ f->title = Qnil;
+ f->menu_bar_window = Qnil;
+ f->tool_bar_window = Qnil;
+ f->tool_bar_items = Qnil;
+ f->desired_tool_bar_string = f->current_tool_bar_string = Qnil;
+ f->n_tool_bar_items = 0;
+ f->left_fringe_width = f->right_fringe_width = 0;
+ f->fringe_cols = 0;
+ f->scroll_bar_actual_width = 0;
+ f->border_width = 0;
+ f->internal_border_width = 0;
+ f->column_width = 1; /* !FRAME_WINDOW_P value */
+ f->line_height = 1; /* !FRAME_WINDOW_P value */
+ f->x_pixels_diff = f->y_pixels_diff = 0;
+ #ifdef HAVE_WINDOW_SYSTEM
+ f->want_fullscreen = FULLSCREEN_NONE;
+ #endif
+ f->size_hint_flags = 0;
+ f->win_gravity = 0;
+
+ root_window = make_window ();
+ if (mini_p)
+ {
+ mini_window = make_window ();
+ XWINDOW (root_window)->next = mini_window;
+ XWINDOW (mini_window)->prev = root_window;
+ XWINDOW (mini_window)->mini_p = Qt;
+ XWINDOW (mini_window)->frame = frame;
+ f->minibuffer_window = mini_window;
+ }
+ else
+ {
+ mini_window = Qnil;
+ XWINDOW (root_window)->next = Qnil;
+ f->minibuffer_window = Qnil;
+ }
+
+ XWINDOW (root_window)->frame = frame;
+
+ /* 10 is arbitrary,
+ just so that there is "something there."
+ Correct size will be set up later with change_frame_size. */
+
+ SET_FRAME_COLS (f, 10);
+ FRAME_LINES (f) = 10;
+
+ XSETFASTINT (XWINDOW (root_window)->total_cols, 10);
+ XSETFASTINT (XWINDOW (root_window)->total_lines, (mini_p ? 9 : 10));
+
+ if (mini_p)
+ {
+ XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
+ XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
+ XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
+ }
+
+ /* Choose a buffer for the frame's root window. */
+ {
+ Lisp_Object buf;
+
+ XWINDOW (root_window)->buffer = Qt;
+ buf = Fcurrent_buffer ();
+ /* If buf is a 'hidden' buffer (i.e. one whose name starts with
+ a space), try to find another one. */
+ if (SREF (Fbuffer_name (buf), 0) == ' ')
+ buf = Fother_buffer (buf, Qnil, Qnil);
+
+ /* Use set_window_buffer, not Fset_window_buffer, and don't let
+ hooks be run by it. The reason is that the whole frame/window
+ arrangement is not yet fully intialized at this point. Windows
+ don't have the right size, glyph matrices aren't initialized
+ etc. Running Lisp functions at this point surely ends in a
+ SEGV. */
+ set_window_buffer (root_window, buf, 0, 0);
+ f->buffer_list = Fcons (buf, Qnil);
+ }
+
+ if (mini_p)
+ {
+ XWINDOW (mini_window)->buffer = Qt;
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)),
+ 0, 0);
+ }
+
+ f->root_window = root_window;
+ f->selected_window = root_window;
+ /* Make sure this window seems more recently used than
+ a newly-created, never-selected window. */
+ XSETFASTINT (XWINDOW (f->selected_window)->use_time, ++window_select_count);
+
+ return f;
+ }
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ /* Make a frame using a separate minibuffer window on another frame.
+ MINI_WINDOW is the minibuffer window to use. nil means use the
+ default (the global minibuffer). */
+
+ struct frame *
+ make_frame_without_minibuffer (mini_window, kb, display)
+ register Lisp_Object mini_window;
+ KBOARD *kb;
+ Lisp_Object display;
+ {
+ register struct frame *f;
+ struct gcpro gcpro1;
+
+ if (!NILP (mini_window))
+ CHECK_LIVE_WINDOW (mini_window);
+
+ #ifdef MULTI_KBOARD
+ if (!NILP (mini_window)
+ && XFRAME (XWINDOW (mini_window)->frame)->kboard != kb)
+ error ("frame and minibuffer must be on the same display");
+ #endif
+
+ /* Make a frame containing just a root window. */
+ f = make_frame (0);
+
+ if (NILP (mini_window))
+ {
+ /* Use default-minibuffer-frame if possible. */
+ if (!FRAMEP (kb->Vdefault_minibuffer_frame)
+ || ! FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame)))
+ {
+ Lisp_Object frame_dummy;
+
+ XSETFRAME (frame_dummy, f);
+ GCPRO1 (frame_dummy);
+ /* If there's no minibuffer frame to use, create one. */
+ kb->Vdefault_minibuffer_frame =
+ call1 (intern ("make-initial-minibuffer-frame"), display);
+ UNGCPRO;
+ }
+
+ mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
+ }
+
+ f->minibuffer_window = mini_window;
+
+ /* Make the chosen minibuffer window display the proper minibuffer,
+ unless it is already showing a minibuffer. */
+ if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
+ Fset_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), Qnil);
+ return f;
+ }
+
+ /* Make a frame containing only a minibuffer window. */
+
+ struct frame *
+ make_minibuffer_frame ()
+ {
+ /* First make a frame containing just a root window, no minibuffer. */
+
+ register struct frame *f = make_frame (0);
+ register Lisp_Object mini_window;
+ register Lisp_Object frame;
+
+ XSETFRAME (frame, f);
+
+ f->auto_raise = 0;
+ f->auto_lower = 0;
+ f->no_split = 1;
+ f->wants_modeline = 0;
+ f->has_minibuffer = 1;
+
+ /* Now label the root window as also being the minibuffer.
+ Avoid infinite looping on the window chain by marking next pointer
+ as nil. */
+
+ mini_window = f->minibuffer_window = f->root_window;
+ XWINDOW (mini_window)->mini_p = Qt;
+ XWINDOW (mini_window)->next = Qnil;
+ XWINDOW (mini_window)->prev = Qnil;
+ XWINDOW (mini_window)->frame = frame;
+
+ /* Put the proper buffer in that window. */
+
+ Fset_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), Qnil);
+ return f;
+ }
+ #endif /* HAVE_WINDOW_SYSTEM */
+
+ /* Construct a frame that refers to the terminal (stdin and stdout). */
+
+ static int terminal_frame_count;
+
+ struct frame *
+ make_terminal_frame ()
+ {
+ register struct frame *f;
+ Lisp_Object frame;
+ char name[20];
+
+ #ifdef MULTI_KBOARD
+ if (!initial_kboard)
+ {
+ initial_kboard = (KBOARD *) XGC_MALLOC (sizeof (KBOARD));
+ init_kboard (initial_kboard);
+ initial_kboard->next_kboard = all_kboards;
+ all_kboards = initial_kboard;
+ }
+ #endif
+
+ /* The first call must initialize Vframe_list. */
+ if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
+ Vframe_list = Qnil;
+
+ f = make_frame (1);
+
+ XSETFRAME (frame, f);
+ Vframe_list = Fcons (frame, Vframe_list);
+
+ terminal_frame_count++;
+ sprintf (name, "F%d", terminal_frame_count);
+ f->name = build_string (name);
+
+ f->visible = 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
+ f->async_visible = 1; /* Don't let visible be cleared later.
*/
+ #ifdef MSDOS
+ f->output_data.x = &the_only_x_display;
+ if (!inhibit_window_system
+ && (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame))
+ || XFRAME (selected_frame)->output_method == output_msdos_raw))
+ {
+ f->output_method = output_msdos_raw;
+ /* This initialization of foreground and background pixels is
+ only important for the initial frame created in temacs. If
+ we don't do that, we get black background and foreground in
+ the dumped Emacs because the_only_x_display is a static
+ variable, hence it is born all-zeroes, and zero is the code
+ for the black color. Other frames all inherit their pixels
+ from what's already in the_only_x_display. */
+ if ((!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME
(selected_frame)))
+ && f->output_data.x->background_pixel == 0
+ && f->output_data.x->foreground_pixel == 0)
+ {
+ f->output_data.x->background_pixel = FACE_TTY_DEFAULT_BG_COLOR;
+ f->output_data.x->foreground_pixel = FACE_TTY_DEFAULT_FG_COLOR;
+ }
+ }
+ else
+ f->output_method = output_termcap;
+ #else
+ #ifdef WINDOWSNT
+ f->output_method = output_termcap;
+ f->output_data.x = &tty_display;
+ #else
+ #ifdef MAC_OS8
+ make_mac_terminal_frame (f);
+ #else
+ f->output_data.x = &tty_display;
+ #ifdef CANNOT_DUMP
+ FRAME_FOREGROUND_PIXEL(f) = FACE_TTY_DEFAULT_FG_COLOR;
+ FRAME_BACKGROUND_PIXEL(f) = FACE_TTY_DEFAULT_BG_COLOR;
+ #endif
+ #endif /* MAC_OS8 */
+ #endif /* WINDOWSNT */
+ #endif /* MSDOS */
+
+ if (!noninteractive)
+ init_frame_faces (f);
+
+ return f;
+ }
+
+ DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
+ 1, 1, 0,
+ doc: /* Create an additional terminal frame.
+ You can create multiple frames on a text-only terminal in this way.
+ Only the selected terminal frame is actually displayed.
+ This function takes one argument, an alist specifying frame parameters.
+ In practice, generally you don't need to specify any parameters.
+ Note that changing the size of one terminal frame automatically affects all.
*/)
+ (parms)
+ Lisp_Object parms;
+ {
+ struct frame *f;
+ Lisp_Object frame, tem;
+ struct frame *sf = SELECTED_FRAME ();
+
+ #ifdef MSDOS
+ if (sf->output_method != output_msdos_raw
+ && sf->output_method != output_termcap)
+ abort ();
+ #else /* not MSDOS */
+
+ #ifdef MAC_OS
+ if (sf->output_method != output_mac)
+ error ("Not running on a Macintosh screen; cannot make a new Macintosh
frame");
+ #else
+ if (sf->output_method != output_termcap)
+ error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
+ #endif
+ #endif /* not MSDOS */
+
+ f = make_terminal_frame ();
+
+ change_frame_size (f, FRAME_LINES (sf),
+ FRAME_COLS (sf), 0, 0, 0);
+ adjust_glyphs (f);
+ calculate_costs (f);
+ XSETFRAME (frame, f);
+ Fmodify_frame_parameters (frame, Vdefault_frame_alist);
+ Fmodify_frame_parameters (frame, parms);
+
+ /* Make the frame face alist be frame-specific, so that each
+ frame could change its face definitions independently. */
+ f->face_alist = Fcopy_alist (sf->face_alist);
+ /* Simple Fcopy_alist isn't enough, because we need the contents of
+ the vectors which are the CDRs of associations in face_alist to
+ be copied as well. */
+ for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
+ XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
+ return frame;
+ }
+
+
+ /* Perform the switch to frame FRAME.
+
+ If FRAME is a switch-frame event `(switch-frame FRAME1)', use
+ FRAME1 as frame.
+
+ If TRACK is non-zero and the frame that currently has the focus
+ redirects its focus to the selected frame, redirect that focused
+ frame's focus to FRAME instead.
+
+ FOR_DELETION non-zero means that the selected frame is being
+ deleted, which includes the possibility that the frame's display
+ is dead. */
+
+ Lisp_Object
+ do_switch_frame (frame, track, for_deletion)
+ Lisp_Object frame;
+ int track, for_deletion;
+ {
+ struct frame *sf = SELECTED_FRAME ();
+
+ /* If FRAME is a switch-frame event, extract the frame we should
+ switch to. */
+ if (CONSP (frame)
+ && EQ (XCAR (frame), Qswitch_frame)
+ && CONSP (XCDR (frame)))
+ frame = XCAR (XCDR (frame));
+
+ /* This used to say CHECK_LIVE_FRAME, but apparently it's possible for
+ a switch-frame event to arrive after a frame is no longer live,
+ especially when deleting the initial frame during startup. */
+ CHECK_FRAME (frame);
+ if (! FRAME_LIVE_P (XFRAME (frame)))
+ return Qnil;
+
+ if (sf == XFRAME (frame))
+ return frame;
+
+ /* This is too greedy; it causes inappropriate focus redirection
+ that's hard to get rid of. */
+ #if 0
+ /* If a frame's focus has been redirected toward the currently
+ selected frame, we should change the redirection to point to the
+ newly selected frame. This means that if the focus is redirected
+ from a minibufferless frame to a surrogate minibuffer frame, we
+ can use `other-window' to switch between all the frames using
+ that minibuffer frame, and the focus redirection will follow us
+ around. */
+ if (track)
+ {
+ Lisp_Object tail;
+
+ for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+ {
+ Lisp_Object focus;
+
+ if (!FRAMEP (XCAR (tail)))
+ abort ();
+
+ focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
+
+ if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
+ Fredirect_frame_focus (XCAR (tail), frame);
+ }
+ }
+ #else /* ! 0 */
+ /* Instead, apply it only to the frame we're pointing to. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (track && FRAME_WINDOW_P (XFRAME (frame)))
+ {
+ Lisp_Object focus, xfocus;
+
+ xfocus = x_get_focus_frame (XFRAME (frame));
+ if (FRAMEP (xfocus))
+ {
+ focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
+ if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
+ Fredirect_frame_focus (xfocus, frame);
+ }
+ }
+ #endif /* HAVE_X_WINDOWS */
+ #endif /* ! 0 */
+
+ if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
+ resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
+
+ selected_frame = frame;
+ if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
+ last_nonminibuf_frame = XFRAME (selected_frame);
+
+ Fselect_window (XFRAME (frame)->selected_window, Qnil);
+
+ #ifndef WINDOWSNT
+ /* Make sure to switch the tty color mode to that of the newly
+ selected frame. */
+ sf = SELECTED_FRAME ();
+ if (FRAME_TERMCAP_P (sf))
+ {
+ Lisp_Object color_mode_spec, color_mode;
+
+ color_mode_spec = assq_no_quit (Qtty_color_mode, sf->param_alist);
+ if (CONSP (color_mode_spec))
+ color_mode = XCDR (color_mode_spec);
+ else
+ color_mode = make_number (0);
+ set_tty_color_mode (sf, color_mode);
+ }
+ #endif /* !WINDOWSNT */
+
+ /* We want to make sure that the next event generates a frame-switch
+ event to the appropriate frame. This seems kludgy to me, but
+ before you take it out, make sure that evaluating something like
+ (select-window (frame-root-window (new-frame))) doesn't end up
+ with your typing being interpreted in the new frame instead of
+ the one you're actually typing in. */
+ internal_last_event_frame = Qnil;
+
+ return frame;
+ }
+
+ DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
+ doc: /* Select the frame FRAME.
+ Subsequent editing commands apply to its selected window.
+ The selection of FRAME lasts until the next time the user does
+ something to select a different frame, or until the next time this
+ function is called. */)
+ (frame, no_enter)
+ Lisp_Object frame, no_enter;
+ {
+ return do_switch_frame (frame, 1, 0);
+ }
+
+
+ DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1,
2, "e",
+ doc: /* Handle a switch-frame event EVENT.
+ Switch-frame events are usually bound to this function.
+ A switch-frame event tells Emacs that the window manager has requested
+ that the user's events be directed to the frame mentioned in the event.
+ This function selects the selected window of the frame of EVENT.
+
+ If EVENT is frame object, handle it as if it were a switch-frame event
+ to that frame. */)
+ (event, no_enter)
+ Lisp_Object event, no_enter;
+ {
+ /* Preserve prefix arg that the command loop just cleared. */
+ current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
+ call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
+ return do_switch_frame (event, 0, 0);
+ }
+
+ DEFUN ("ignore-event", Fignore_event, Signore_event, 0, 0, "",
+ doc: /* Do nothing, but preserve any prefix argument already specified.
+ This is a suitable binding for `iconify-frame' and `make-frame-visible'. */)
+ ()
+ {
+ current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
+ return Qnil;
+ }
+
+ DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
+ doc: /* Return the frame that is now selected. */)
+ ()
+ {
+ return selected_frame;
+ }
+
+ DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
+ doc: /* Return the frame object that window WINDOW is on. */)
+ (window)
+ Lisp_Object window;
+ {
+ CHECK_LIVE_WINDOW (window);
+ return XWINDOW (window)->frame;
+ }
+
+ DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1,
0,
+ doc: /* Returns the topmost, leftmost window of FRAME.
+ If omitted, FRAME defaults to the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ Lisp_Object w;
+
+ if (NILP (frame))
+ w = SELECTED_FRAME ()->root_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame);
+ w = XFRAME (frame)->root_window;
+ }
+ while (NILP (XWINDOW (w)->buffer))
+ {
+ if (! NILP (XWINDOW (w)->hchild))
+ w = XWINDOW (w)->hchild;
+ else if (! NILP (XWINDOW (w)->vchild))
+ w = XWINDOW (w)->vchild;
+ else
+ abort ();
+ }
+ return w;
+ }
+
+ DEFUN ("active-minibuffer-window", Factive_minibuffer_window,
+ Sactive_minibuffer_window, 0, 0, 0,
+ doc: /* Return the currently active minibuffer window, or nil if none.
*/)
+ ()
+ {
+ return minibuf_level ? minibuf_window : Qnil;
+ }
+
+ DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
+ doc: /* Returns the root-window of FRAME.
+ If omitted, FRAME defaults to the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ Lisp_Object window;
+
+ if (NILP (frame))
+ window = SELECTED_FRAME ()->root_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame);
+ window = XFRAME (frame)->root_window;
+ }
+
+ return window;
+ }
+
+ DEFUN ("frame-selected-window", Fframe_selected_window,
+ Sframe_selected_window, 0, 1, 0,
+ doc: /* Return the selected window of frame object FRAME.
+ If omitted, FRAME defaults to the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ Lisp_Object window;
+
+ if (NILP (frame))
+ window = SELECTED_FRAME ()->selected_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame);
+ window = XFRAME (frame)->selected_window;
+ }
+
+ return window;
+ }
+
+ DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
+ Sset_frame_selected_window, 2, 2, 0,
+ doc: /* Set the selected window of frame object FRAME to WINDOW.
+ If FRAME is nil, the selected frame is used.
+ If FRAME is the selected frame, this makes WINDOW the selected window. */)
+ (frame, window)
+ Lisp_Object frame, window;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+ CHECK_LIVE_WINDOW (window);
+
+ if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
+ error ("In `set-frame-selected-window', WINDOW is not on FRAME");
+
+ if (EQ (frame, selected_frame))
+ return Fselect_window (window, Qnil);
+
+ return XFRAME (frame)->selected_window = window;
+ }
+
+ DEFUN ("frame-list", Fframe_list, Sframe_list,
+ 0, 0, 0,
+ doc: /* Return a list of all frames. */)
+ ()
+ {
+ Lisp_Object frames;
+ frames = Fcopy_sequence (Vframe_list);
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAMEP (tip_frame))
+ frames = Fdelq (tip_frame, frames);
+ #endif
+ return frames;
+ }
+
+ /* Return the next frame in the frame list after FRAME.
+ If MINIBUF is nil, exclude minibuffer-only frames.
+ If MINIBUF is a window, include only its own frame
+ and any frame now using that window as the minibuffer.
+ If MINIBUF is `visible', include all visible frames.
+ If MINIBUF is 0, include all visible and iconified frames.
+ Otherwise, include all frames. */
+
+ Lisp_Object
+ next_frame (frame, minibuf)
+ Lisp_Object frame;
+ Lisp_Object minibuf;
+ {
+ Lisp_Object tail;
+ int passed = 0;
+
+ /* There must always be at least one frame in Vframe_list. */
+ if (! CONSP (Vframe_list))
+ abort ();
+
+ /* If this frame is dead, it won't be in Vframe_list, and we'll loop
+ forever. Forestall that. */
+ CHECK_LIVE_FRAME (frame);
+
+ while (1)
+ for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+ {
+ Lisp_Object f;
+
+ f = XCAR (tail);
+
+ if (passed
+ && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+ {
+ /* Decide whether this frame is eligible to be returned. */
+
+ /* If we've looped all the way around without finding any
+ eligible frames, return the original frame. */
+ if (EQ (f, frame))
+ return f;
+
+ /* Let minibuf decide if this frame is acceptable. */
+ if (NILP (minibuf))
+ {
+ if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
+ return f;
+ }
+ else if (EQ (minibuf, Qvisible))
+ {
+ FRAME_SAMPLE_VISIBILITY (XFRAME (f));
+ if (FRAME_VISIBLE_P (XFRAME (f)))
+ return f;
+ }
+ else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
+ {
+ FRAME_SAMPLE_VISIBILITY (XFRAME (f));
+ if (FRAME_VISIBLE_P (XFRAME (f))
+ || FRAME_ICONIFIED_P (XFRAME (f)))
+ return f;
+ }
+ else if (WINDOWP (minibuf))
+ {
+ if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
+ FRAME_FOCUS_FRAME (XFRAME (f))))
+ return f;
+ }
+ else
+ return f;
+ }
+
+ if (EQ (frame, f))
+ passed++;
+ }
+ }
+
+ /* Return the previous frame in the frame list before FRAME.
+ If MINIBUF is nil, exclude minibuffer-only frames.
+ If MINIBUF is a window, include only its own frame
+ and any frame now using that window as the minibuffer.
+ If MINIBUF is `visible', include all visible frames.
+ If MINIBUF is 0, include all visible and iconified frames.
+ Otherwise, include all frames. */
+
+ Lisp_Object
+ prev_frame (frame, minibuf)
+ Lisp_Object frame;
+ Lisp_Object minibuf;
+ {
+ Lisp_Object tail;
+ Lisp_Object prev;
+
+ /* There must always be at least one frame in Vframe_list. */
+ if (! CONSP (Vframe_list))
+ abort ();
+
+ prev = Qnil;
+ for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+ {
+ Lisp_Object f;
+
+ f = XCAR (tail);
+ if (!FRAMEP (f))
+ abort ();
+
+ if (EQ (frame, f) && !NILP (prev))
+ return prev;
+
+ if (FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
+ {
+ /* Decide whether this frame is eligible to be returned,
+ according to minibuf. */
+ if (NILP (minibuf))
+ {
+ if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
+ prev = f;
+ }
+ else if (WINDOWP (minibuf))
+ {
+ if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
+ FRAME_FOCUS_FRAME (XFRAME (f))))
+ prev = f;
+ }
+ else if (EQ (minibuf, Qvisible))
+ {
+ FRAME_SAMPLE_VISIBILITY (XFRAME (f));
+ if (FRAME_VISIBLE_P (XFRAME (f)))
+ prev = f;
+ }
+ else if (XFASTINT (minibuf) == 0)
+ {
+ FRAME_SAMPLE_VISIBILITY (XFRAME (f));
+ if (FRAME_VISIBLE_P (XFRAME (f))
+ || FRAME_ICONIFIED_P (XFRAME (f)))
+ prev = f;
+ }
+ else
+ prev = f;
+ }
+ }
+
+ /* We've scanned the entire list. */
+ if (NILP (prev))
+ /* We went through the whole frame list without finding a single
+ acceptable frame. Return the original frame. */
+ return frame;
+ else
+ /* There were no acceptable frames in the list before FRAME; otherwise,
+ we would have returned directly from the loop. Since PREV is the last
+ acceptable frame in the list, return it. */
+ return prev;
+ }
+
+
+ DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
+ doc: /* Return the next frame in the frame list after FRAME.
+ It considers only frames on the same terminal as FRAME.
+ By default, skip minibuffer-only frames.
+ If omitted, FRAME defaults to the selected frame.
+ If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
+ If MINIFRAME is a window, include only its own frame
+ and any frame now using that window as the minibuffer.
+ If MINIFRAME is `visible', include all visible frames.
+ If MINIFRAME is 0, include all visible and iconified frames.
+ Otherwise, include all frames. */)
+ (frame, miniframe)
+ Lisp_Object frame, miniframe;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+ return next_frame (frame, miniframe);
+ }
+
+ DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame, 0, 2, 0,
+ doc: /* Return the previous frame in the frame list before FRAME.
+ It considers only frames on the same terminal as FRAME.
+ By default, skip minibuffer-only frames.
+ If omitted, FRAME defaults to the selected frame.
+ If optional argument MINIFRAME is nil, exclude minibuffer-only frames.
+ If MINIFRAME is a window, include only its own frame
+ and any frame now using that window as the minibuffer.
+ If MINIFRAME is `visible', include all visible frames.
+ If MINIFRAME is 0, include all visible and iconified frames.
+ Otherwise, include all frames. */)
+ (frame, miniframe)
+ Lisp_Object frame, miniframe;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ return prev_frame (frame, miniframe);
+ }
+
+ /* Return 1 if it is ok to delete frame F;
+ 0 if all frames aside from F are invisible.
+ (Exception: if F is the terminal frame, and we are using X, return 1.) */
+
+ int
+ other_visible_frames (f)
+ FRAME_PTR f;
+ {
+ /* We know the selected frame is visible,
+ so if F is some other frame, it can't be the sole visible one. */
+ if (f == SELECTED_FRAME ())
+ {
+ Lisp_Object frames;
+ int count = 0;
+
+ for (frames = Vframe_list;
+ CONSP (frames);
+ frames = XCDR (frames))
+ {
+ Lisp_Object this;
+
+ this = XCAR (frames);
+ /* Verify that the frame's window still exists
+ and we can still talk to it. And note any recent change
+ in visibility. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (this)))
+ {
+ x_sync (XFRAME (this));
+ FRAME_SAMPLE_VISIBILITY (XFRAME (this));
+ }
+ #endif
+
+ if (FRAME_VISIBLE_P (XFRAME (this))
+ || FRAME_ICONIFIED_P (XFRAME (this))
+ /* Allow deleting the terminal frame when at least
+ one X frame exists! */
+ || (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
+ count++;
+ }
+ return count > 1;
+ }
+ return 1;
+ }
+
+ DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
+ doc: /* Delete FRAME, permanently eliminating it from use.
+ If omitted, FRAME defaults to the selected frame.
+ A frame may not be deleted if its minibuffer is used by other frames.
+ Normally, you may not delete a frame if all other frames are invisible,
+ but if the second optional argument FORCE is non-nil, you may do so.
+
+ This function runs `delete-frame-functions' before actually deleting the
+ frame, unless the frame is a tooltip.
+ The functions are run with one arg, the frame to be deleted. */)
+ (frame, force)
+ Lisp_Object frame, force;
+ {
+ struct frame *f;
+ struct frame *sf = SELECTED_FRAME ();
+ int minibuffer_selected;
+
+ if (EQ (frame, Qnil))
+ {
+ f = sf;
+ XSETFRAME (frame, f);
+ }
+ else
+ {
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+ }
+
+ if (! FRAME_LIVE_P (f))
+ return Qnil;
+
+ if (NILP (force) && !other_visible_frames (f)
+ #ifdef MAC_OS8
+ /* Terminal frame deleted before any other visible frames are
+ created. */
+ && strcmp (SDATA (f->name), "F1") != 0
+ #endif
+ )
+ error ("Attempt to delete the sole visible or iconified frame");
+
+ #if 0
+ /* This is a nice idea, but x_connection_closed needs to be able
+ to delete the last frame, if it is gone. */
+ if (NILP (XCDR (Vframe_list)))
+ error ("Attempt to delete the only frame");
+ #endif
+
+ /* Does this frame have a minibuffer, and is it the surrogate
+ minibuffer for any other frame? */
+ if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
+ {
+ Lisp_Object frames;
+
+ for (frames = Vframe_list;
+ CONSP (frames);
+ frames = XCDR (frames))
+ {
+ Lisp_Object this;
+ this = XCAR (frames);
+
+ if (! EQ (this, frame)
+ && EQ (frame,
+ WINDOW_FRAME (XWINDOW
+ (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
+ error ("Attempt to delete a surrogate minibuffer frame");
+ }
+ }
+
+ /* Run `delete-frame-functions' unless frame is a tooltip. */
+ if (!NILP (Vrun_hooks)
+ && NILP (Fframe_parameter (frame, intern ("tooltip"))))
+ {
+ Lisp_Object args[2];
+ args[0] = intern ("delete-frame-functions");
+ args[1] = frame;
+ Frun_hook_with_args (2, args);
+ }
+
+ minibuffer_selected = EQ (minibuf_window, selected_window);
+
+ /* Don't let the frame remain selected. */
+ if (f == sf)
+ {
+ Lisp_Object tail, frame1;
+
+ /* Look for another visible frame on the same terminal. */
+ frame1 = next_frame (frame, Qvisible);
+
+ /* If there is none, find *some* other frame. */
+ if (NILP (frame1) || EQ (frame1, frame))
+ {
+ FOR_EACH_FRAME (tail, frame1)
+ {
+ if (! EQ (frame, frame1))
+ break;
+ }
+ }
+
+ do_switch_frame (frame1, 0, 1);
+ sf = SELECTED_FRAME ();
+ }
+
+ /* Don't allow minibuf_window to remain on a deleted frame. */
+ if (EQ (f->minibuffer_window, minibuf_window))
+ {
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
+
+ /* If the dying minibuffer window was selected,
+ select the new one. */
+ if (minibuffer_selected)
+ Fselect_window (minibuf_window, Qnil);
+ }
+
+ /* Don't let echo_area_window to remain on a deleted frame. */
+ if (EQ (f->minibuffer_window, echo_area_window))
+ echo_area_window = sf->minibuffer_window;
+
+ /* Clear any X selections for this frame. */
+ #ifdef HAVE_X_WINDOWS
+ if (FRAME_X_P (f))
+ x_clear_frame_selections (f);
+ #endif
+
+ /* Free glyphs.
+ This function must be called before the window tree of the
+ frame is deleted because windows contain dynamically allocated
+ memory. */
+ free_glyphs (f);
+
+ /* Mark all the windows that used to be on FRAME as deleted, and then
+ remove the reference to them. */
+ delete_all_subwindows (XWINDOW (f->root_window));
+ f->root_window = Qnil;
+
+ Vframe_list = Fdelq (frame, Vframe_list);
+ FRAME_SET_VISIBLE (f, 0);
+
+ if (f->namebuf)
+ xfree (f->namebuf);
+ if (FRAME_INSERT_COST (f))
+ xfree (FRAME_INSERT_COST (f));
+ if (FRAME_DELETEN_COST (f))
+ xfree (FRAME_DELETEN_COST (f));
+ if (FRAME_INSERTN_COST (f))
+ xfree (FRAME_INSERTN_COST (f));
+ if (FRAME_DELETE_COST (f))
+ xfree (FRAME_DELETE_COST (f));
+ if (FRAME_MESSAGE_BUF (f))
+ xfree (FRAME_MESSAGE_BUF (f));
+
+ /* Since some events are handled at the interrupt level, we may get
+ an event for f at any time; if we zero out the frame's display
+ now, then we may trip up the event-handling code. Instead, we'll
+ promise that the display of the frame must be valid until we have
+ called the window-system-dependent frame destruction routine. */
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ x_destroy_window (f);
+ #endif
+
+ f->output_data.nothing = 0;
+
+ /* If we've deleted the last_nonminibuf_frame, then try to find
+ another one. */
+ if (f == last_nonminibuf_frame)
+ {
+ Lisp_Object frames;
+
+ last_nonminibuf_frame = 0;
+
+ for (frames = Vframe_list;
+ CONSP (frames);
+ frames = XCDR (frames))
+ {
+ f = XFRAME (XCAR (frames));
+ if (!FRAME_MINIBUF_ONLY_P (f))
+ {
+ last_nonminibuf_frame = f;
+ break;
+ }
+ }
+ }
+
+ /* If we've deleted this keyboard's default_minibuffer_frame, try to
+ find another one. Prefer minibuffer-only frames, but also notice
+ frames with other windows. */
+ if (EQ (frame, FRAME_KBOARD (f)->Vdefault_minibuffer_frame))
+ {
+ Lisp_Object frames;
+
+ /* The last frame we saw with a minibuffer, minibuffer-only or not. */
+ Lisp_Object frame_with_minibuf;
+ /* Some frame we found on the same kboard, or nil if there are none. */
+ Lisp_Object frame_on_same_kboard;
+
+ frame_on_same_kboard = Qnil;
+ frame_with_minibuf = Qnil;
+
+ for (frames = Vframe_list;
+ CONSP (frames);
+ frames = XCDR (frames))
+ {
+ Lisp_Object this;
+ struct frame *f1;
+
+ this = XCAR (frames);
+ if (!FRAMEP (this))
+ abort ();
+ f1 = XFRAME (this);
+
+ /* Consider only frames on the same kboard
+ and only those with minibuffers. */
+ if (FRAME_KBOARD (f) == FRAME_KBOARD (f1)
+ && FRAME_HAS_MINIBUF_P (f1))
+ {
+ frame_with_minibuf = this;
+ if (FRAME_MINIBUF_ONLY_P (f1))
+ break;
+ }
+
+ if (FRAME_KBOARD (f) == FRAME_KBOARD (f1))
+ frame_on_same_kboard = this;
+ }
+
+ if (!NILP (frame_on_same_kboard))
+ {
+ /* We know that there must be some frame with a minibuffer out
+ there. If this were not true, all of the frames present
+ would have to be minibufferless, which implies that at some
+ point their minibuffer frames must have been deleted, but
+ that is prohibited at the top; you can't delete surrogate
+ minibuffer frames. */
+ if (NILP (frame_with_minibuf))
+ abort ();
+
+ FRAME_KBOARD (f)->Vdefault_minibuffer_frame = frame_with_minibuf;
+ }
+ else
+ /* No frames left on this kboard--say no minibuffer either. */
+ FRAME_KBOARD (f)->Vdefault_minibuffer_frame = Qnil;
+ }
+
+ /* Cause frame titles to update--necessary if we now have just one frame.
*/
+ update_mode_lines = 1;
+
+ return Qnil;
+ }
+
+ /* Return mouse position in character cell units. */
+
+ DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
+ doc: /* Return a list (FRAME X . Y) giving the current mouse frame and
position.
+ The position is given in character cells, where (0, 0) is the
+ upper-left corner.
+ If Emacs is running on a mouseless terminal or hasn't been programmed
+ to read the mouse position, it returns the selected frame for FRAME
+ and nil for X and Y.
+ If `mouse-position-function' is non-nil, `mouse-position' calls it,
+ passing the normal return value to that function as an argument,
+ and returns whatever that function returns. */)
+ ()
+ {
+ FRAME_PTR f;
+ Lisp_Object lispy_dummy;
+ enum scroll_bar_part party_dummy;
+ Lisp_Object x, y, retval;
+ int col, row;
+ unsigned long long_dummy;
+ struct gcpro gcpro1;
+
+ f = SELECTED_FRAME ();
+ x = y = Qnil;
+
+ #ifdef HAVE_MOUSE
+ /* It's okay for the hook to refrain from storing anything. */
+ if (mouse_position_hook)
+ (*mouse_position_hook) (&f, -1,
+ &lispy_dummy, &party_dummy,
+ &x, &y,
+ &long_dummy);
+ if (! NILP (x))
+ {
+ col = XINT (x);
+ row = XINT (y);
+ pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
+ XSETINT (x, col);
+ XSETINT (y, row);
+ }
+ #endif
+ XSETFRAME (lispy_dummy, f);
+ retval = Fcons (lispy_dummy, Fcons (x, y));
+ GCPRO1 (retval);
+ if (!NILP (Vmouse_position_function))
+ retval = call1 (Vmouse_position_function, retval);
+ RETURN_UNGCPRO (retval);
+ }
+
+ DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
+ Smouse_pixel_position, 0, 0, 0,
+ doc: /* Return a list (FRAME X . Y) giving the current mouse frame and
position.
+ The position is given in pixel units, where (0, 0) is the
+ upper-left corner.
+ If Emacs is running on a mouseless terminal or hasn't been programmed
+ to read the mouse position, it returns the selected frame for FRAME
+ and nil for X and Y. */)
+ ()
+ {
+ FRAME_PTR f;
+ Lisp_Object lispy_dummy;
+ enum scroll_bar_part party_dummy;
+ Lisp_Object x, y;
+ unsigned long long_dummy;
+
+ f = SELECTED_FRAME ();
+ x = y = Qnil;
+
+ #ifdef HAVE_MOUSE
+ /* It's okay for the hook to refrain from storing anything. */
+ if (mouse_position_hook)
+ (*mouse_position_hook) (&f, -1,
+ &lispy_dummy, &party_dummy,
+ &x, &y,
+ &long_dummy);
+ #endif
+ XSETFRAME (lispy_dummy, f);
+ return Fcons (lispy_dummy, Fcons (x, y));
+ }
+
+ DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3,
0,
+ doc: /* Move the mouse pointer to the center of character cell (X,Y)
in FRAME.
+ Coordinates are relative to the frame, not a window,
+ so the coordinates of the top left character in the frame
+ may be nonzero due to left-hand scroll bars or the menu bar.
+
+ This function is a no-op for an X frame that is not visible.
+ If you have just created a frame, you must wait for it to become visible
+ before calling this function on it, like this.
+ (while (not (frame-visible-p frame)) (sleep-for .5)) */)
+ (frame, x, y)
+ Lisp_Object frame, x, y;
+ {
+ CHECK_LIVE_FRAME (frame);
+ CHECK_NUMBER (x);
+ CHECK_NUMBER (y);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ /* Warping the mouse will cause enternotify and focus events. */
+ x_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
+ #else
+ #if defined (MSDOS) && defined (HAVE_MOUSE)
+ if (FRAME_MSDOS_P (XFRAME (frame)))
+ {
+ Fselect_frame (frame, Qnil);
+ mouse_moveto (XINT (x), XINT (y));
+ }
+ #endif
+ #endif
+
+ return Qnil;
+ }
+
+ DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
+ Sset_mouse_pixel_position, 3, 3, 0,
+ doc: /* Move the mouse pointer to pixel position (X,Y) in FRAME.
+ Note, this is a no-op for an X frame that is not visible.
+ If you have just created a frame, you must wait for it to become visible
+ before calling this function on it, like this.
+ (while (not (frame-visible-p frame)) (sleep-for .5)) */)
+ (frame, x, y)
+ Lisp_Object frame, x, y;
+ {
+ CHECK_LIVE_FRAME (frame);
+ CHECK_NUMBER (x);
+ CHECK_NUMBER (y);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ /* Warping the mouse will cause enternotify and focus events. */
+ x_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
+ #else
+ #if defined (MSDOS) && defined (HAVE_MOUSE)
+ if (FRAME_MSDOS_P (XFRAME (frame)))
+ {
+ Fselect_frame (frame, Qnil);
+ mouse_moveto (XINT (x), XINT (y));
+ }
+ #endif
+ #endif
+
+ return Qnil;
+ }
+
+ static void make_frame_visible_1 P_ ((Lisp_Object));
+
+ DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
+ 0, 1, "",
+ doc: /* Make the frame FRAME visible (assuming it is an X window).
+ If omitted, FRAME defaults to the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ {
+ FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+ x_make_frame_visible (XFRAME (frame));
+ }
+ #endif
+
+ make_frame_visible_1 (XFRAME (frame)->root_window);
+
+ /* Make menu bar update for the Buffers and Frames menus. */
+ windows_or_buffers_changed++;
+
+ return frame;
+ }
+
+ /* Update the display_time slot of the buffers shown in WINDOW
+ and all its descendents. */
+
+ static void
+ make_frame_visible_1 (window)
+ Lisp_Object window;
+ {
+ struct window *w;
+
+ for (;!NILP (window); window = w->next)
+ {
+ w = XWINDOW (window);
+
+ if (!NILP (w->buffer))
+ XBUFFER (w->buffer)->display_time = Fcurrent_time ();
+
+ if (!NILP (w->vchild))
+ make_frame_visible_1 (w->vchild);
+ if (!NILP (w->hchild))
+ make_frame_visible_1 (w->hchild);
+ }
+ }
+
+ DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
+ 0, 2, "",
+ doc: /* Make the frame FRAME invisible (assuming it is an X window).
+ If omitted, FRAME defaults to the currently selected frame.
+ Normally you may not make FRAME invisible if all other frames are invisible,
+ but if the second optional argument FORCE is non-nil, you may do so. */)
+ (frame, force)
+ Lisp_Object frame, force;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+
+ if (NILP (force) && !other_visible_frames (XFRAME (frame)))
+ error ("Attempt to make invisible the sole visible or iconified frame");
+
+ #if 0 /* This isn't logically necessary, and it can do GC. */
+ /* Don't let the frame remain selected. */
+ if (EQ (frame, selected_frame))
+ do_switch_frame (next_frame (frame, Qt), 0, 0)
+ #endif
+
+ /* Don't allow minibuf_window to remain on a deleted frame. */
+ if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
+ {
+ struct frame *sf = XFRAME (selected_frame);
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
+ }
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ x_make_frame_invisible (XFRAME (frame));
+ #endif
+
+ /* Make menu bar update for the Buffers and Frames menus. */
+ windows_or_buffers_changed++;
+
+ return Qnil;
+ }
+
+ DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
+ 0, 1, "",
+ doc: /* Make the frame FRAME into an icon.
+ If omitted, FRAME defaults to the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+
+ #if 0 /* This isn't logically necessary, and it can do GC. */
+ /* Don't let the frame remain selected. */
+ if (EQ (frame, selected_frame))
+ Fhandle_switch_frame (next_frame (frame, Qt), Qnil);
+ #endif
+
+ /* Don't allow minibuf_window to remain on a deleted frame. */
+ if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
+ {
+ struct frame *sf = XFRAME (selected_frame);
+ Fset_window_buffer (sf->minibuffer_window,
+ XWINDOW (minibuf_window)->buffer, Qnil);
+ minibuf_window = sf->minibuffer_window;
+ }
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (XFRAME (frame)))
+ x_iconify_frame (XFRAME (frame));
+ #endif
+
+ /* Make menu bar update for the Buffers and Frames menus. */
+ windows_or_buffers_changed++;
+
+ return Qnil;
+ }
+
+ DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
+ 1, 1, 0,
+ doc: /* Return t if FRAME is now \"visible\" (actually in use for
display).
+ A frame that is not \"visible\" is not updated and, if it works through
+ a window system, it may not show at all.
+ Return the symbol `icon' if frame is visible only as an icon. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ CHECK_LIVE_FRAME (frame);
+
+ FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+
+ if (FRAME_VISIBLE_P (XFRAME (frame)))
+ return Qt;
+ if (FRAME_ICONIFIED_P (XFRAME (frame)))
+ return Qicon;
+ return Qnil;
+ }
+
+ DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
+ 0, 0, 0,
+ doc: /* Return a list of all frames now \"visible\" (being updated).
*/)
+ ()
+ {
+ Lisp_Object tail, frame;
+ struct frame *f;
+ Lisp_Object value;
+
+ value = Qnil;
+ for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+ {
+ frame = XCAR (tail);
+ if (!FRAMEP (frame))
+ continue;
+ f = XFRAME (frame);
+ if (FRAME_VISIBLE_P (f))
+ value = Fcons (frame, value);
+ }
+ return value;
+ }
+
+
+ DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
+ doc: /* Bring FRAME to the front, so it occludes any frames it
overlaps.
+ If FRAME is invisible, make it visible.
+ If you don't specify a frame, the selected frame is used.
+ If Emacs is displaying on an ordinary terminal or some other device which
+ doesn't support multiple overlapping frames, this function does nothing. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+
+ /* Do like the documentation says. */
+ Fmake_frame_visible (frame);
+
+ if (frame_raise_lower_hook)
+ (*frame_raise_lower_hook) (XFRAME (frame), 1);
+
+ return Qnil;
+ }
+
+ /* Should we have a corresponding function called Flower_Power? */
+ DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
+ doc: /* Send FRAME to the back, so it is occluded by any frames that
overlap it.
+ If you don't specify a frame, the selected frame is used.
+ If Emacs is displaying on an ordinary terminal or some other device which
+ doesn't support multiple overlapping frames, this function does nothing. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+
+ if (frame_raise_lower_hook)
+ (*frame_raise_lower_hook) (XFRAME (frame), 0);
+
+ return Qnil;
+ }
+
+
+ DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
+ 1, 2, 0,
+ doc: /* Arrange for keystrokes typed at FRAME to be sent to
FOCUS-FRAME.
+ In other words, switch-frame events caused by events in FRAME will
+ request a switch to FOCUS-FRAME, and `last-event-frame' will be
+ FOCUS-FRAME after reading an event typed at FRAME.
+
+ If FOCUS-FRAME is omitted or nil, any existing redirection is
+ cancelled, and the frame again receives its own keystrokes.
+
+ Focus redirection is useful for temporarily redirecting keystrokes to
+ a surrogate minibuffer frame when a frame doesn't have its own
+ minibuffer window.
+
+ A frame's focus redirection can be changed by select-frame. If frame
+ FOO is selected, and then a different frame BAR is selected, any
+ frames redirecting their focus to FOO are shifted to redirect their
+ focus to BAR. This allows focus redirection to work properly when the
+ user switches from one frame to another using `select-window'.
+
+ This means that a frame whose focus is redirected to itself is treated
+ differently from a frame whose focus is redirected to nil; the former
+ is affected by select-frame, while the latter is not.
+
+ The redirection lasts until `redirect-frame-focus' is called to change it.
*/)
+ (frame, focus_frame)
+ Lisp_Object frame, focus_frame;
+ {
+ /* Note that we don't check for a live frame here. It's reasonable
+ to redirect the focus of a frame you're about to delete, if you
+ know what other frame should receive those keystrokes. */
+ CHECK_FRAME (frame);
+
+ if (! NILP (focus_frame))
+ CHECK_LIVE_FRAME (focus_frame);
+
+ XFRAME (frame)->focus_frame = focus_frame;
+
+ if (frame_rehighlight_hook)
+ (*frame_rehighlight_hook) (XFRAME (frame));
+
+ return Qnil;
+ }
+
+
+ DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
+ doc: /* Return the frame to which FRAME's keystrokes are currently
being sent.
+ This returns nil if FRAME's focus is not redirected.
+ See `redirect-frame-focus'. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ CHECK_LIVE_FRAME (frame);
+
+ return FRAME_FOCUS_FRAME (XFRAME (frame));
+ }
+
+
+
+ /* Return the value of frame parameter PROP in frame FRAME. */
+
+ Lisp_Object
+ get_frame_param (frame, prop)
+ register struct frame *frame;
+ Lisp_Object prop;
+ {
+ register Lisp_Object tem;
+
+ tem = Fassq (prop, frame->param_alist);
+ if (EQ (tem, Qnil))
+ return tem;
+ return Fcdr (tem);
+ }
+
+ /* Return the buffer-predicate of the selected frame. */
+
+ Lisp_Object
+ frame_buffer_predicate (frame)
+ Lisp_Object frame;
+ {
+ return XFRAME (frame)->buffer_predicate;
+ }
+
+ /* Return the buffer-list of the selected frame. */
+
+ Lisp_Object
+ frame_buffer_list (frame)
+ Lisp_Object frame;
+ {
+ return XFRAME (frame)->buffer_list;
+ }
+
+ /* Set the buffer-list of the selected frame. */
+
+ void
+ set_frame_buffer_list (frame, list)
+ Lisp_Object frame, list;
+ {
+ XFRAME (frame)->buffer_list = list;
+ }
+
+ /* Discard BUFFER from the buffer-list of each frame. */
+
+ void
+ frames_discard_buffer (buffer)
+ Lisp_Object buffer;
+ {
+ Lisp_Object frame, tail;
+
+ FOR_EACH_FRAME (tail, frame)
+ {
+ XFRAME (frame)->buffer_list
+ = Fdelq (buffer, XFRAME (frame)->buffer_list);
+ }
+ }
+
+ /* Modify the alist in *ALISTPTR to associate PROP with VAL.
+ If the alist already has an element for PROP, we change it. */
+
+ void
+ store_in_alist (alistptr, prop, val)
+ Lisp_Object *alistptr, val;
+ Lisp_Object prop;
+ {
+ register Lisp_Object tem;
+
+ tem = Fassq (prop, *alistptr);
+ if (EQ (tem, Qnil))
+ *alistptr = Fcons (Fcons (prop, val), *alistptr);
+ else
+ Fsetcdr (tem, val);
+ }
+
+ static int
+ frame_name_fnn_p (str, len)
+ char *str;
+ int len;
+ {
+ if (len > 1 && str[0] == 'F')
+ {
+ char *end_ptr;
+
+ strtol (str + 1, &end_ptr, 10);
+
+ if (end_ptr == str + len)
+ return 1;
+ }
+ return 0;
+ }
+
+ /* Set the name of the terminal frame. Also used by MSDOS frames.
+ Modeled after x_set_name which is used for WINDOW frames. */
+
+ void
+ set_term_frame_name (f, name)
+ struct frame *f;
+ Lisp_Object name;
+ {
+ f->explicit_name = ! NILP (name);
+
+ /* If NAME is nil, set the name to F<num>. */
+ if (NILP (name))
+ {
+ char namebuf[20];
+
+ /* Check for no change needed in this very common case
+ before we do any consing. */
+ if (frame_name_fnn_p (SDATA (f->name),
+ SBYTES (f->name)))
+ return;
+
+ terminal_frame_count++;
+ sprintf (namebuf, "F%d", terminal_frame_count);
+ name = build_string (namebuf);
+ }
+ else
+ {
+ CHECK_STRING (name);
+
+ /* Don't change the name if it's already NAME. */
+ if (! NILP (Fstring_equal (name, f->name)))
+ return;
+
+ /* Don't allow the user to set the frame name to F<num>, so it
+ doesn't clash with the names we generate for terminal frames. */
+ if (frame_name_fnn_p (SDATA (name), SBYTES (name)))
+ error ("Frame names of the form F<num> are usurped by Emacs");
+ }
+
+ f->name = name;
+ update_mode_lines = 1;
+ }
+
+ void
+ store_frame_param (f, prop, val)
+ struct frame *f;
+ Lisp_Object prop, val;
+ {
+ register Lisp_Object old_alist_elt;
+
+ /* The buffer-alist parameter is stored in a special place and is
+ not in the alist. */
+ if (EQ (prop, Qbuffer_list))
+ {
+ f->buffer_list = val;
+ return;
+ }
+
+ /* If PROP is a symbol which is supposed to have frame-local values,
+ and it is set up based on this frame, switch to the global
+ binding. That way, we can create or alter the frame-local binding
+ without messing up the symbol's status. */
+ if (SYMBOLP (prop))
+ {
+ Lisp_Object valcontents;
+ valcontents = SYMBOL_VALUE (prop);
+ if ((BUFFER_LOCAL_VALUEP (valcontents)
+ || SOME_BUFFER_LOCAL_VALUEP (valcontents))
+ && XBUFFER_LOCAL_VALUE (valcontents)->check_frame
+ && XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame) == f)
+ swap_in_global_binding (prop);
+ }
+
+ #ifndef WINDOWSNT
+ /* The tty color mode needs to be set before the frame's parameter
+ alist is updated with the new value, because set_tty_color_mode
+ wants to look at the old mode. */
+ if (FRAME_TERMCAP_P (f) && EQ (prop, Qtty_color_mode))
+ set_tty_color_mode (f, val);
+ #endif
+
+ /* Update the frame parameter alist. */
+ old_alist_elt = Fassq (prop, f->param_alist);
+ if (EQ (old_alist_elt, Qnil))
+ f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
+ else
+ Fsetcdr (old_alist_elt, val);
+
+ /* Update some other special parameters in their special places
+ in addition to the alist. */
+
+ if (EQ (prop, Qbuffer_predicate))
+ f->buffer_predicate = val;
+
+ if (! FRAME_WINDOW_P (f))
+ {
+ if (EQ (prop, Qmenu_bar_lines))
+ set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
+ else if (EQ (prop, Qname))
+ set_term_frame_name (f, val);
+ }
+
+ if (EQ (prop, Qminibuffer) && WINDOWP (val))
+ {
+ if (! MINI_WINDOW_P (XWINDOW (val)))
+ error ("Surrogate minibuffer windows must be minibuffer windows.");
+
+ if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
+ && !EQ (val, f->minibuffer_window))
+ error ("Can't change the surrogate minibuffer of a frame with its own
minibuffer");
+
+ /* Install the chosen minibuffer window, with proper buffer. */
+ f->minibuffer_window = val;
+ }
+ }
+
+ DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
+ doc: /* Return the parameters-alist of frame FRAME.
+ It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
+ The meaningful PARMs depend on the kind of frame.
+ If FRAME is omitted, return information on the currently selected frame. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ Lisp_Object alist;
+ FRAME_PTR f;
+ int height, width;
+ struct gcpro gcpro1;
+
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+
+ if (!FRAME_LIVE_P (f))
+ return Qnil;
+
+ alist = Fcopy_alist (f->param_alist);
+ GCPRO1 (alist);
+
+ if (!FRAME_WINDOW_P (f))
+ {
+ int fg = FRAME_FOREGROUND_PIXEL (f);
+ int bg = FRAME_BACKGROUND_PIXEL (f);
+ Lisp_Object elt;
+
+ /* If the frame's parameter alist says the colors are
+ unspecified and reversed, take the frame's background pixel
+ for foreground and vice versa. */
+ elt = Fassq (Qforeground_color, alist);
+ if (!NILP (elt) && CONSP (elt) && STRINGP (XCDR (elt)))
+ {
+ if (strncmp (SDATA (XCDR (elt)),
+ unspecified_bg,
+ SCHARS (XCDR (elt))) == 0)
+ store_in_alist (&alist, Qforeground_color, tty_color_name (f, bg));
+ else if (strncmp (SDATA (XCDR (elt)),
+ unspecified_fg,
+ SCHARS (XCDR (elt))) == 0)
+ store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
+ }
+ else
+ store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
+ elt = Fassq (Qbackground_color, alist);
+ if (!NILP (elt) && CONSP (elt) && STRINGP (XCDR (elt)))
+ {
+ if (strncmp (SDATA (XCDR (elt)),
+ unspecified_fg,
+ SCHARS (XCDR (elt))) == 0)
+ store_in_alist (&alist, Qbackground_color, tty_color_name (f, fg));
+ else if (strncmp (SDATA (XCDR (elt)),
+ unspecified_bg,
+ SCHARS (XCDR (elt))) == 0)
+ store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
+ }
+ else
+ store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
+ store_in_alist (&alist, intern ("font"),
+ build_string (FRAME_MSDOS_P (f)
+ ? "ms-dos"
+ : FRAME_W32_P (f) ? "w32term"
+ :"tty"));
+ }
+ store_in_alist (&alist, Qname, f->name);
+ height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
+ store_in_alist (&alist, Qheight, make_number (height));
+ width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
+ store_in_alist (&alist, Qwidth, make_number (width));
+ store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt :
Qnil));
+ store_in_alist (&alist, Qminibuffer,
+ (! FRAME_HAS_MINIBUF_P (f) ? Qnil
+ : FRAME_MINIBUF_ONLY_P (f) ? Qonly
+ : FRAME_MINIBUF_WINDOW (f)));
+ store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
+ store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ x_report_frame_params (f, &alist);
+ else
+ #endif
+ {
+ /* This ought to be correct in f->param_alist for an X frame. */
+ Lisp_Object lines;
+ XSETFASTINT (lines, FRAME_MENU_BAR_LINES (f));
+ store_in_alist (&alist, Qmenu_bar_lines, lines);
+ }
+
+ UNGCPRO;
+ return alist;
+ }
+
+
+ DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
+ doc: /* Return FRAME's value for parameter PARAMETER.
+ If FRAME is nil, describe the currently selected frame. */)
+ (frame, parameter)
+ Lisp_Object frame, parameter;
+ {
+ struct frame *f;
+ Lisp_Object value;
+
+ if (NILP (frame))
+ frame = selected_frame;
+ else
+ CHECK_FRAME (frame);
+ CHECK_SYMBOL (parameter);
+
+ f = XFRAME (frame);
+ value = Qnil;
+
+ if (FRAME_LIVE_P (f))
+ {
+ /* Avoid consing in frequent cases. */
+ if (EQ (parameter, Qname))
+ value = f->name;
+ #ifdef HAVE_X_WINDOWS
+ else if (EQ (parameter, Qdisplay) && FRAME_X_P (f))
+ value = XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element);
+ #endif /* HAVE_X_WINDOWS */
+ else if (EQ (parameter, Qbackground_color)
+ || EQ (parameter, Qforeground_color))
+ {
+ value = Fassq (parameter, f->param_alist);
+ if (CONSP (value))
+ {
+ value = XCDR (value);
+ /* Fframe_parameters puts the actual fg/bg color names,
+ even if f->param_alist says otherwise. This is
+ important when param_alist's notion of colors is
+ "unspecified". We need to do the same here. */
+ if (STRINGP (value) && !FRAME_WINDOW_P (f))
+ {
+ const char *color_name;
+ EMACS_INT csz;
+
+ if (EQ (parameter, Qbackground_color))
+ {
+ color_name = SDATA (value);
+ csz = SCHARS (value);
+ if (strncmp (color_name, unspecified_bg, csz) == 0)
+ value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
+ else if (strncmp (color_name, unspecified_fg, csz) == 0)
+ value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
+ }
+ else if (EQ (parameter, Qforeground_color))
+ {
+ color_name = SDATA (value);
+ csz = SCHARS (value);
+ if (strncmp (color_name, unspecified_fg, csz) == 0)
+ value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
+ else if (strncmp (color_name, unspecified_bg, csz) == 0)
+ value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
+ }
+ }
+ }
+ else
+ value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
+ }
+ else if (EQ (parameter, Qdisplay_type)
+ || EQ (parameter, Qbackground_mode))
+ value = Fcdr (Fassq (parameter, f->param_alist));
+ else
+ value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
+ }
+
+ return value;
+ }
+
+
+ DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
+ Smodify_frame_parameters, 2, 2, 0,
+ doc: /* Modify the parameters of frame FRAME according to ALIST.
+ If FRAME is nil, it defaults to the selected frame.
+ ALIST is an alist of parameters to change and their new values.
+ Each element of ALIST has the form (PARM . VALUE), where PARM is a symbol.
+ The meaningful PARMs depend on the kind of frame.
+ Undefined PARMs are ignored, but stored in the frame's parameter list
+ so that `frame-parameters' will return them.
+
+ The value of frame parameter FOO can also be accessed
+ as a frame-local binding for the variable FOO, if you have
+ enabled such bindings for that variable with `make-variable-frame-local'. */)
+ (frame, alist)
+ Lisp_Object frame, alist;
+ {
+ FRAME_PTR f;
+ register Lisp_Object tail, prop, val;
+ int count = SPECPDL_INDEX ();
+
+ /* Bind this to t to inhibit initialization of the default face from
+ X resources in face-set-after-frame-default. If we don't inhibit
+ this, modifying the `font' frame parameter, for example, while
+ there is a `default.attributeFont' X resource, won't work,
+ because `default's font is reset to the value of the X resource
+ and that resets the `font' frame parameter. */
+ specbind (Qinhibit_default_face_x_resources, Qt);
+
+ if (EQ (frame, Qnil))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ f = XFRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ x_set_frame_parameters (f, alist);
+ else
+ #endif
+ #ifdef MSDOS
+ if (FRAME_MSDOS_P (f))
+ IT_set_frame_parameters (f, alist);
+ else
+ #endif
+
+ {
+ int length = XINT (Flength (alist));
+ int i;
+ Lisp_Object *parms
+ = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
+ Lisp_Object *values
+ = (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
+
+ /* Extract parm names and values into those vectors. */
+
+ i = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ {
+ Lisp_Object elt;
+
+ elt = Fcar (tail);
+ parms[i] = Fcar (elt);
+ values[i] = Fcdr (elt);
+ i++;
+ }
+
+ /* Now process them in reverse of specified order. */
+ for (i--; i >= 0; i--)
+ {
+ prop = parms[i];
+ val = values[i];
+ store_frame_param (f, prop, val);
+ }
+ }
+
+ return unbind_to (count, Qnil);
+ }
+
+ DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
+ 0, 1, 0,
+ doc: /* Height in pixels of a line in the font in frame FRAME.
+ If FRAME is omitted, the selected frame is used.
+ For a terminal frame, the value is always 1. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ struct frame *f;
+
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ return make_number (x_char_height (f));
+ else
+ #endif
+ return make_number (1);
+ }
+
+
+ DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
+ 0, 1, 0,
+ doc: /* Width in pixels of characters in the font in frame FRAME.
+ If FRAME is omitted, the selected frame is used.
+ The width is the same for all characters, because
+ currently Emacs supports only fixed-width fonts.
+ For a terminal screen, the value is always 1. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ struct frame *f;
+
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ return make_number (x_char_width (f));
+ else
+ #endif
+ return make_number (1);
+ }
+
+ DEFUN ("frame-pixel-height", Fframe_pixel_height,
+ Sframe_pixel_height, 0, 1, 0,
+ doc: /* Return a FRAME's height in pixels.
+ This counts only the height available for text lines,
+ not menu bars on window-system Emacs frames.
+ For a terminal frame, the result really gives the height in characters.
+ If FRAME is omitted, the selected frame is used. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ struct frame *f;
+
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ return make_number (x_pixel_height (f));
+ else
+ #endif
+ return make_number (FRAME_LINES (f));
+ }
+
+ DEFUN ("frame-pixel-width", Fframe_pixel_width,
+ Sframe_pixel_width, 0, 1, 0,
+ doc: /* Return FRAME's width in pixels.
+ For a terminal frame, the result really gives the width in characters.
+ If FRAME is omitted, the selected frame is used. */)
+ (frame)
+ Lisp_Object frame;
+ {
+ struct frame *f;
+
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_FRAME (frame);
+ f = XFRAME (frame);
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ return make_number (x_pixel_width (f));
+ else
+ #endif
+ return make_number (FRAME_COLS (f));
+ }
+
+ DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
+ doc: /* Specify that the frame FRAME has LINES lines.
+ Optional third arg non-nil means that redisplay should use LINES lines
+ but that the idea of the actual height of the frame should not be changed.
*/)
+ (frame, lines, pretend)
+ Lisp_Object frame, lines, pretend;
+ {
+ register struct frame *f;
+
+ CHECK_NUMBER (lines);
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ f = XFRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ {
+ if (XINT (lines) != FRAME_LINES (f))
+ x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
+ do_pending_window_change (0);
+ }
+ else
+ #endif
+ change_frame_size (f, XINT (lines), 0, !NILP (pretend), 0, 0);
+ return Qnil;
+ }
+
+ DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
+ doc: /* Specify that the frame FRAME has COLS columns.
+ Optional third arg non-nil means that redisplay should use COLS columns
+ but that the idea of the actual width of the frame should not be changed. */)
+ (frame, cols, pretend)
+ Lisp_Object frame, cols, pretend;
+ {
+ register struct frame *f;
+ CHECK_NUMBER (cols);
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ f = XFRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ {
+ if (XINT (cols) != FRAME_COLS (f))
+ x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+ else
+ #endif
+ change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0, 0);
+ return Qnil;
+ }
+
+ DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
+ doc: /* Sets size of FRAME to COLS by ROWS, measured in characters.
*/)
+ (frame, cols, rows)
+ Lisp_Object frame, cols, rows;
+ {
+ register struct frame *f;
+
+ CHECK_LIVE_FRAME (frame);
+ CHECK_NUMBER (cols);
+ CHECK_NUMBER (rows);
+ f = XFRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ {
+ if (XINT (rows) != FRAME_LINES (f)
+ || XINT (cols) != FRAME_COLS (f)
+ || f->new_text_lines || f->new_text_cols)
+ x_set_window_size (f, 1, XINT (cols), XINT (rows));
+ do_pending_window_change (0);
+ }
+ else
+ #endif
+ change_frame_size (f, XINT (rows), XINT (cols), 0, 0, 0);
+
+ return Qnil;
+ }
+
+ DEFUN ("set-frame-position", Fset_frame_position,
+ Sset_frame_position, 3, 3, 0,
+ doc: /* Sets position of FRAME in pixels to XOFFSET by YOFFSET.
+ This is actually the position of the upper left corner of the frame.
+ Negative values for XOFFSET or YOFFSET are interpreted relative to
+ the rightmost or bottommost possible position (that stays within the screen).
*/)
+ (frame, xoffset, yoffset)
+ Lisp_Object frame, xoffset, yoffset;
+ {
+ register struct frame *f;
+
+ CHECK_LIVE_FRAME (frame);
+ CHECK_NUMBER (xoffset);
+ CHECK_NUMBER (yoffset);
+ f = XFRAME (frame);
+
+ /* I think this should be done with a hook. */
+ #ifdef HAVE_WINDOW_SYSTEM
+ if (FRAME_WINDOW_P (f))
+ x_set_offset (f, XINT (xoffset), XINT (yoffset), 1);
+ #endif
+
+ return Qt;
+ }
+
+
+ /***********************************************************************
+ Frame Parameters
+ ***********************************************************************/
+
+ /* Connect the frame-parameter names for X frames
+ to the ways of passing the parameter values to the window system.
+
+ The name of a parameter, as a Lisp symbol,
+ has an `x-frame-parameter' property which is an integer in Lisp
+ that is an index in this table. */
+
+ struct frame_parm_table {
+ char *name;
+ Lisp_Object *variable;
+ };
+
+ static struct frame_parm_table frame_parms[] =
+ {
+ {"auto-raise", &Qauto_raise},
+ {"auto-lower", &Qauto_lower},
+ {"background-color", 0},
+ {"border-color", &Qborder_color},
+ {"border-width", &Qborder_width},
+ {"cursor-color", &Qcursor_color},
+ {"cursor-type", &Qcursor_type},
+ {"font", 0},
+ {"foreground-color", 0},
+ {"icon-name", &Qicon_name},
+ {"icon-type", &Qicon_type},
+ {"internal-border-width", &Qinternal_border_width},
+ {"menu-bar-lines", &Qmenu_bar_lines},
+ {"mouse-color", &Qmouse_color},
+ {"name", &Qname},
+ {"scroll-bar-width", &Qscroll_bar_width},
+ {"title", &Qtitle},
+ {"unsplittable", &Qunsplittable},
+ {"vertical-scroll-bars", &Qvertical_scroll_bars},
+ {"visibility", &Qvisibility},
+ {"tool-bar-lines", &Qtool_bar_lines},
+ {"scroll-bar-foreground", &Qscroll_bar_foreground},
+ {"scroll-bar-background", &Qscroll_bar_background},
+ {"screen-gamma", &Qscreen_gamma},
+ {"line-spacing", &Qline_spacing},
+ {"left-fringe", &Qleft_fringe},
+ {"right-fringe", &Qright_fringe},
+ {"wait-for-wm", &Qwait_for_wm},
+ {"fullscreen", &Qfullscreen},
+ };
+
+ #ifdef HAVE_WINDOW_SYSTEM
+
+ extern Lisp_Object Qbox;
+ extern Lisp_Object Qtop;
+
+ /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
+ wanted positions of the WM window (not emacs window).
+ Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
+ window (FRAME_X_WINDOW).
+ */
+
+ void
+ x_fullscreen_adjust (f, width, height, top_pos, left_pos)
+ struct frame *f;
+ int *width;
+ int *height;
+ int *top_pos;
+ int *left_pos;
+ {
+ int newwidth = FRAME_COLS (f);
+ int newheight = FRAME_LINES (f);
+
+ *top_pos = f->top_pos;
+ *left_pos = f->left_pos;
+
+ if (f->want_fullscreen & FULLSCREEN_HEIGHT)
+ {
+ int ph;
+
+ ph = FRAME_X_DISPLAY_INFO (f)->height;
+ newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
+ ph = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, newheight) - f->y_pixels_diff;
+ newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
+ *top_pos = 0;
+ }
+
+ if (f->want_fullscreen & FULLSCREEN_WIDTH)
+ {
+ int pw;
+
+ pw = FRAME_X_DISPLAY_INFO (f)->width;
+ newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
+ pw = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, newwidth) - f->x_pixels_diff;
+ newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
+ *left_pos = 0;
+ }
+
+ *width = newwidth;
+ *height = newheight;
+ }
+
+
+ /* Really try to move where we want to be in case of fullscreen. Some WMs
+ moves the window where we tell them. Some (mwm, twm) moves the outer
+ window manager window there instead.
+ Try to compensate for those WM here. */
+
+ static void
+ x_fullscreen_move (f, new_top, new_left)
+ struct frame *f;
+ int new_top;
+ int new_left;
+ {
+ if (new_top != f->top_pos || new_left != f->left_pos)
+ {
+ int move_x = new_left;
+ int move_y = new_top;
+
+ #ifdef HAVE_X_WINDOWS
+ move_x += FRAME_X_OUTPUT (f)->x_pixels_outer_diff;
+ move_y += FRAME_X_OUTPUT (f)->y_pixels_outer_diff;
+ #endif
+
+ f->want_fullscreen |= FULLSCREEN_MOVE_WAIT;
+ x_set_offset (f, move_x, move_y, 1);
+ }
+ }
+
+ /* Change the parameters of frame F as specified by ALIST.
+ If a parameter is not specially recognized, do nothing special;
+ otherwise call the `x_set_...' function for that parameter.
+ Except for certain geometry properties, always call store_frame_param
+ to store the new value in the parameter alist. */
+
+ void
+ x_set_frame_parameters (f, alist)
+ FRAME_PTR f;
+ Lisp_Object alist;
+ {
+ Lisp_Object tail;
+
+ /* If both of these parameters are present, it's more efficient to
+ set them both at once. So we wait until we've looked at the
+ entire list before we set them. */
+ int width, height;
+
+ /* Same here. */
+ Lisp_Object left, top;
+
+ /* Same with these. */
+ Lisp_Object icon_left, icon_top;
+
+ /* Record in these vectors all the parms specified. */
+ Lisp_Object *parms;
+ Lisp_Object *values;
+ int i, p;
+ int left_no_change = 0, top_no_change = 0;
+ int icon_left_no_change = 0, icon_top_no_change = 0;
+ int fullscreen_is_being_set = 0;
+
+ struct gcpro gcpro1, gcpro2;
+
+ i = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ i++;
+
+ parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
+ values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
+
+ /* Extract parm names and values into those vectors. */
+
+ i = 0;
+ for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ {
+ Lisp_Object elt;
+
+ elt = Fcar (tail);
+ parms[i] = Fcar (elt);
+ values[i] = Fcdr (elt);
+ i++;
+ }
+ /* TAIL and ALIST are not used again below here. */
+ alist = tail = Qnil;
+
+ GCPRO2 (*parms, *values);
+ gcpro1.nvars = i;
+ gcpro2.nvars = i;
+
+ /* There is no need to gcpro LEFT, TOP, ICON_LEFT, or ICON_TOP,
+ because their values appear in VALUES and strings are not valid. */
+ top = left = Qunbound;
+ icon_left = icon_top = Qunbound;
+
+ /* Provide default values for HEIGHT and WIDTH. */
+ width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
+ height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
+
+ /* Process foreground_color and background_color before anything else.
+ They are independent of other properties, but other properties (e.g.,
+ cursor_color) are dependent upon them. */
+ /* Process default font as well, since fringe widths depends on it. */
+ /* Also, process fullscreen, width and height depend upon that */
+ for (p = 0; p < i; p++)
+ {
+ Lisp_Object prop, val;
+
+ prop = parms[p];
+ val = values[p];
+ if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
+ {
+ register Lisp_Object param_index, old_value;
+
+ old_value = get_frame_param (f, prop);
+ fullscreen_is_being_set |= EQ (prop, Qfullscreen);
+
+ if (NILP (Fequal (val, old_value)))
+ {
+ store_frame_param (f, prop, val);
+
+ param_index = Fget (prop, Qx_frame_parameter);
+ if (NATNUMP (param_index)
+ && (XFASTINT (param_index)
+ < sizeof (frame_parms)/sizeof (frame_parms[0]))
+ && rif->frame_parm_handlers[XINT (param_index)])
+ (*(rif->frame_parm_handlers[XINT (param_index)])) (f, val,
old_value);
+ }
+ }
+ }
+
+ /* Now process them in reverse of specified order. */
+ for (i--; i >= 0; i--)
+ {
+ Lisp_Object prop, val;
+
+ prop = parms[i];
+ val = values[i];
+
+ if (EQ (prop, Qwidth) && NUMBERP (val))
+ width = XFASTINT (val);
+ else if (EQ (prop, Qheight) && NUMBERP (val))
+ height = XFASTINT (val);
+ else if (EQ (prop, Qtop))
+ top = val;
+ else if (EQ (prop, Qleft))
+ left = val;
+ else if (EQ (prop, Qicon_top))
+ icon_top = val;
+ else if (EQ (prop, Qicon_left))
+ icon_left = val;
+ else if (EQ (prop, Qforeground_color)
+ || EQ (prop, Qbackground_color)
+ || EQ (prop, Qfont)
+ || EQ (prop, Qfullscreen))
+ /* Processed above. */
+ continue;
+ else
+ {
+ register Lisp_Object param_index, old_value;
+
+ old_value = get_frame_param (f, prop);
+
+ store_frame_param (f, prop, val);
+
+ param_index = Fget (prop, Qx_frame_parameter);
+ if (NATNUMP (param_index)
+ && (XFASTINT (param_index)
+ < sizeof (frame_parms)/sizeof (frame_parms[0]))
+ && rif->frame_parm_handlers[XINT (param_index)])
+ (*(rif->frame_parm_handlers[XINT (param_index)])) (f, val,
old_value);
+ }
+ }
+
+ /* Don't die if just one of these was set. */
+ if (EQ (left, Qunbound))
+ {
+ left_no_change = 1;
+ if (f->left_pos < 0)
+ left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
+ else
+ XSETINT (left, f->left_pos);
+ }
+ if (EQ (top, Qunbound))
+ {
+ top_no_change = 1;
+ if (f->top_pos < 0)
+ top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
+ else
+ XSETINT (top, f->top_pos);
+ }
+
+ /* If one of the icon positions was not set, preserve or default it. */
+ if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
+ {
+ icon_left_no_change = 1;
+ icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
+ if (NILP (icon_left))
+ XSETINT (icon_left, 0);
+ }
+ if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
+ {
+ icon_top_no_change = 1;
+ icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
+ if (NILP (icon_top))
+ XSETINT (icon_top, 0);
+ }
+
+ #ifndef HAVE_CARBON
+ /* MAC_TODO: fullscreen */
+ if (FRAME_VISIBLE_P (f) && fullscreen_is_being_set)
+ {
+ /* If the frame is visible already and the fullscreen parameter is
+ being set, it is too late to set WM manager hints to specify
+ size and position.
+ Here we first get the width, height and position that applies to
+ fullscreen. We then move the frame to the appropriate
+ position. Resize of the frame is taken care of in the code after
+ this if-statement. */
+ int new_left, new_top;
+
+ x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
+ x_fullscreen_move (f, new_top, new_left);
+ }
+ #endif
+
+ /* Don't set these parameters unless they've been explicitly
+ specified. The window might be mapped or resized while we're in
+ this function, and we don't want to override that unless the lisp
+ code has asked for it.
+
+ Don't set these parameters unless they actually differ from the
+ window's current parameters; the window may not actually exist
+ yet. */
+ {
+ Lisp_Object frame;
+
+ check_frame_size (f, &height, &width);
+
+ XSETFRAME (frame, f);
+
+ if (width != FRAME_COLS (f)
+ || height != FRAME_LINES (f)
+ || f->new_text_lines || f->new_text_cols)
+ Fset_frame_size (frame, make_number (width), make_number (height));
+
+ if ((!NILP (left) || !NILP (top))
+ && ! (left_no_change && top_no_change)
+ && ! (NUMBERP (left) && XINT (left) == f->left_pos
+ && NUMBERP (top) && XINT (top) == f->top_pos))
+ {
+ int leftpos = 0;
+ int toppos = 0;
+
+ /* Record the signs. */
+ f->size_hint_flags &= ~ (XNegative | YNegative);
+ if (EQ (left, Qminus))
+ f->size_hint_flags |= XNegative;
+ else if (INTEGERP (left))
+ {
+ leftpos = XINT (left);
+ if (leftpos < 0)
+ f->size_hint_flags |= XNegative;
+ }
+ else if (CONSP (left) && EQ (XCAR (left), Qminus)
+ && CONSP (XCDR (left))
+ && INTEGERP (XCAR (XCDR (left))))
+ {
+ leftpos = - XINT (XCAR (XCDR (left)));
+ f->size_hint_flags |= XNegative;
+ }
+ else if (CONSP (left) && EQ (XCAR (left), Qplus)
+ && CONSP (XCDR (left))
+ && INTEGERP (XCAR (XCDR (left))))
+ {
+ leftpos = XINT (XCAR (XCDR (left)));
+ }
+
+ if (EQ (top, Qminus))
+ f->size_hint_flags |= YNegative;
+ else if (INTEGERP (top))
+ {
+ toppos = XINT (top);
+ if (toppos < 0)
+ f->size_hint_flags |= YNegative;
+ }
+ else if (CONSP (top) && EQ (XCAR (top), Qminus)
+ && CONSP (XCDR (top))
+ && INTEGERP (XCAR (XCDR (top))))
+ {
+ toppos = - XINT (XCAR (XCDR (top)));
+ f->size_hint_flags |= YNegative;
+ }
+ else if (CONSP (top) && EQ (XCAR (top), Qplus)
+ && CONSP (XCDR (top))
+ && INTEGERP (XCAR (XCDR (top))))
+ {
+ toppos = XINT (XCAR (XCDR (top)));
+ }
+
+
+ /* Store the numeric value of the position. */
+ f->top_pos = toppos;
+ f->left_pos = leftpos;
+
+ f->win_gravity = NorthWestGravity;
+
+ /* Actually set that position, and convert to absolute. */
+ x_set_offset (f, leftpos, toppos, -1);
+ }
+
+ if ((!NILP (icon_left) || !NILP (icon_top))
+ && ! (icon_left_no_change && icon_top_no_change))
+ x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
+ }
+
+ UNGCPRO;
+ }
+
+
+ /* Insert a description of internally-recorded parameters of frame X
+ into the parameter alist *ALISTPTR that is to be given to the user.
+ Only parameters that are specific to the X window system
+ and whose values are not correctly recorded in the frame's
+ param_alist need to be considered here. */
+
+ void
+ x_report_frame_params (f, alistptr)
+ struct frame *f;
+ Lisp_Object *alistptr;
+ {
+ char buf[16];
+ Lisp_Object tem;
+
+ /* Represent negative positions (off the top or left screen edge)
+ in a way that Fmodify_frame_parameters will understand correctly. */
+ XSETINT (tem, f->left_pos);
+ if (f->left_pos >= 0)
+ store_in_alist (alistptr, Qleft, tem);
+ else
+ store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
+
+ XSETINT (tem, f->top_pos);
+ if (f->top_pos >= 0)
+ store_in_alist (alistptr, Qtop, tem);
+ else
+ store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
+
+ store_in_alist (alistptr, Qborder_width,
+ make_number (f->border_width));
+ store_in_alist (alistptr, Qinternal_border_width,
+ make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
+ store_in_alist (alistptr, Qleft_fringe,
+ make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
+ store_in_alist (alistptr, Qright_fringe,
+ make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
+ store_in_alist (alistptr, Qscroll_bar_width,
+ (! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
+ ? make_number (0)
+ : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
+ ? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
+ /* nil means "use default width"
+ for non-toolkit scroll bar.
+ ruler-mode.el depends on this. */
+ : Qnil));
+ sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
+ store_in_alist (alistptr, Qwindow_id,
+ build_string (buf));
+ #ifdef HAVE_X_WINDOWS
+ #ifdef USE_X_TOOLKIT
+ /* Tooltip frame may not have this widget. */
+ if (FRAME_X_OUTPUT (f)->widget)
+ #endif
+ sprintf (buf, "%ld", (long) FRAME_OUTER_WINDOW (f));
+ store_in_alist (alistptr, Qouter_window_id,
+ build_string (buf));
+ #endif
+ store_in_alist (alistptr, Qicon_name, f->icon_name);
+ FRAME_SAMPLE_VISIBILITY (f);
+ store_in_alist (alistptr, Qvisibility,
+ (FRAME_VISIBLE_P (f) ? Qt
+ : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
+ store_in_alist (alistptr, Qdisplay,
+ XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element));
+
+ #ifndef HAVE_CARBON
+ /* A Mac Window is identified by a struct, not an integer. */
+ if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO
(f)->root_window)
+ tem = Qnil;
+ else
+ XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
+ store_in_alist (alistptr, Qparent_id, tem);
+ #endif
+ }
+
+
+ /* Change the `fullscreen' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+ void
+ x_set_fullscreen (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+ {
+ #ifndef HAVE_CARBON
+ if (NILP (new_value))
+ f->want_fullscreen = FULLSCREEN_NONE;
+ else if (EQ (new_value, Qfullboth))
+ f->want_fullscreen = FULLSCREEN_BOTH;
+ else if (EQ (new_value, Qfullwidth))
+ f->want_fullscreen = FULLSCREEN_WIDTH;
+ else if (EQ (new_value, Qfullheight))
+ f->want_fullscreen = FULLSCREEN_HEIGHT;
+ #endif
+ }
+
+
+ /* Change the `line-spacing' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+ void
+ x_set_line_spacing (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+ {
+ if (NILP (new_value))
+ f->extra_line_spacing = 0;
+ else if (NATNUMP (new_value))
+ f->extra_line_spacing = XFASTINT (new_value);
+ else
+ Fsignal (Qerror, Fcons (build_string ("Invalid line-spacing"),
+ Fcons (new_value, Qnil)));
+ if (FRAME_VISIBLE_P (f))
+ redraw_frame (f);
+ }
+
+
+ /* Change the `screen-gamma' frame parameter of frame F. OLD_VALUE is
+ the previous value of that parameter, NEW_VALUE is the new value. */
+
+ void
+ x_set_screen_gamma (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+ {
+ if (NILP (new_value))
+ f->gamma = 0;
+ else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
+ /* The value 0.4545 is the normal viewing gamma. */
+ f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
+ else
+ Fsignal (Qerror, Fcons (build_string ("Invalid screen-gamma"),
+ Fcons (new_value, Qnil)));
+
+ clear_face_cache (0);
+ }
+
+
+ void
+ x_set_font (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ Lisp_Object result;
+ Lisp_Object fontset_name;
+ Lisp_Object frame;
+ int old_fontset = FRAME_FONTSET(f);
+
+ CHECK_STRING (arg);
+
+ fontset_name = Fquery_fontset (arg, Qnil);
+
+ BLOCK_INPUT;
+ result = (STRINGP (fontset_name)
+ ? x_new_fontset (f, SDATA (fontset_name))
+ : x_new_font (f, SDATA (arg)));
+ UNBLOCK_INPUT;
+
+ if (EQ (result, Qnil))
+ error ("Font `%s' is not defined", SDATA (arg));
+ else if (EQ (result, Qt))
+ error ("The characters of the given font have varying widths");
+ else if (STRINGP (result))
+ {
+ if (STRINGP (fontset_name))
+ {
+ /* Fontset names are built from ASCII font names, so the
+ names may be equal despite there was a change. */
+ if (old_fontset == FRAME_FONTSET (f))
+ return;
+ }
+ else if (!NILP (Fequal (result, oldval)))
+ return;
+
+ store_frame_param (f, Qfont, result);
+ recompute_basic_faces (f);
+ }
+ else
+ abort ();
+
+ do_pending_window_change (0);
+
+ /* Don't call `face-set-after-frame-default' when faces haven't been
+ initialized yet. This is the case when called from
+ Fx_create_frame. In that case, the X widget or window doesn't
+ exist either, and we can end up in x_report_frame_params with a
+ null widget which gives a segfault. */
+ if (FRAME_FACE_CACHE (f))
+ {
+ XSETFRAME (frame, f);
+ call1 (Qface_set_after_frame_default, frame);
+ }
+ }
+
+
+ void
+ x_set_fringe_width (f, new_value, old_value)
+ struct frame *f;
+ Lisp_Object new_value, old_value;
+ {
+ compute_fringe_widths (f, 1);
+ }
+
+ void
+ x_set_border_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ CHECK_NUMBER (arg);
+
+ if (XINT (arg) == f->border_width)
+ return;
+
+ #ifndef HAVE_CARBON
+ if (FRAME_X_WINDOW (f) != 0)
+ error ("Cannot change the border width of a window");
+ #endif /* MAC_TODO */
+
+ f->border_width = XINT (arg);
+ }
+
+ void
+ x_set_internal_border_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ int old = FRAME_INTERNAL_BORDER_WIDTH (f);
+
+ CHECK_NUMBER (arg);
+ FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
+ if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
+ FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
+
+ #ifdef USE_X_TOOLKIT
+ if (FRAME_X_OUTPUT (f)->edit_widget)
+ widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
+ #endif
+
+ if (FRAME_INTERNAL_BORDER_WIDTH (f) == old)
+ return;
+
+ if (FRAME_X_WINDOW (f) != 0)
+ {
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ SET_FRAME_GARBAGED (f);
+ do_pending_window_change (0);
+ }
+ else
+ SET_FRAME_GARBAGED (f);
+ }
+
+ void
+ x_set_visibility (f, value, oldval)
+ struct frame *f;
+ Lisp_Object value, oldval;
+ {
+ Lisp_Object frame;
+ XSETFRAME (frame, f);
+
+ if (NILP (value))
+ Fmake_frame_invisible (frame, Qt);
+ else if (EQ (value, Qicon))
+ Ficonify_frame (frame);
+ else
+ Fmake_frame_visible (frame);
+ }
+
+ void
+ x_set_autoraise (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ f->auto_raise = !EQ (Qnil, arg);
+ }
+
+ void
+ x_set_autolower (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ f->auto_lower = !EQ (Qnil, arg);
+ }
+
+ void
+ x_set_unsplittable (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ f->no_split = !NILP (arg);
+ }
+
+ void
+ x_set_vertical_scroll_bars (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
+ || (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
+ || (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
+ || (!NILP (arg) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
+ {
+ FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
+ = (NILP (arg)
+ ? vertical_scroll_bar_none
+ : EQ (Qleft, arg)
+ ? vertical_scroll_bar_left
+ : EQ (Qright, arg)
+ ? vertical_scroll_bar_right
+ #ifdef HAVE_NTGUI
+ /* MS-Windows has scroll bars on the right by default. */
+ : vertical_scroll_bar_right
+ #else
+ : vertical_scroll_bar_left
+ #endif
+ );
+
+ /* We set this parameter before creating the X window for the
+ frame, so we can get the geometry right from the start.
+ However, if the window hasn't been created yet, we shouldn't
+ call x_set_window_size. */
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+ }
+
+ void
+ x_set_scroll_bar_width (f, arg, oldval)
+ struct frame *f;
+ Lisp_Object arg, oldval;
+ {
+ int wid = FRAME_COLUMN_WIDTH (f);
+
+ if (NILP (arg))
+ {
+ x_set_scroll_bar_default_width (f);
+
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+ else if (INTEGERP (arg) && XINT (arg) > 0
+ && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
+ {
+ if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
+ XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1);
+
+ FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
+ FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
+ if (FRAME_X_WINDOW (f))
+ x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
+ do_pending_window_change (0);
+ }
+
+ change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
+ XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
+ }
+
+
+
+ /* Return non-nil if frame F wants a bitmap icon. */
+
+ Lisp_Object
+ x_icon_type (f)
+ FRAME_PTR f;
+ {
+ Lisp_Object tem;
+
+ tem = assq_no_quit (Qicon_type, f->param_alist);
+ if (CONSP (tem))
+ return XCDR (tem);
+ else
+ return Qnil;
+ }
+
+
+ /* Subroutines of creating an X frame. */
+
+ /* Make sure that Vx_resource_name is set to a reasonable value.
+ Fix it up, or set it to `emacs' if it is too hopeless. */
+
+ void
+ validate_x_resource_name ()
+ {
+ int len = 0;
+ /* Number of valid characters in the resource name. */
+ int good_count = 0;
+ /* Number of invalid characters in the resource name. */
+ int bad_count = 0;
+ Lisp_Object new;
+ int i;
+
+ if (!STRINGP (Vx_resource_class))
+ Vx_resource_class = build_string (EMACS_CLASS);
+
+ if (STRINGP (Vx_resource_name))
+ {
+ unsigned char *p = SDATA (Vx_resource_name);
+ int i;
+
+ len = SBYTES (Vx_resource_name);
+
+ /* Only letters, digits, - and _ are valid in resource names.
+ Count the valid characters and count the invalid ones. */
+ for (i = 0; i < len; i++)
+ {
+ int c = p[i];
+ if (! ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '-' || c == '_'))
+ bad_count++;
+ else
+ good_count++;
+ }
+ }
+ else
+ /* Not a string => completely invalid. */
+ bad_count = 5, good_count = 0;
+
+ /* If name is valid already, return. */
+ if (bad_count == 0)
+ return;
+
+ /* If name is entirely invalid, or nearly so, use `emacs'. */
+ if (good_count == 0
+ || (good_count == 1 && bad_count > 0))
+ {
+ Vx_resource_name = build_string ("emacs");
+ return;
+ }
+
+ /* Name is partly valid. Copy it and replace the invalid characters
+ with underscores. */
+
+ Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
+
+ for (i = 0; i < len; i++)
+ {
+ int c = SREF (new, i);
+ if (! ((c >= 'a' && c <= 'z')
+ || (c >= 'A' && c <= 'Z')
+ || (c >= '0' && c <= '9')
+ || c == '-' || c == '_'))
+ SSET (new, i, '_');
+ }
+ }
+
+
+ extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
+ extern Display_Info *check_x_display_info P_ ((Lisp_Object));
+
+
+ /* Get specified attribute from resource database RDB.
+ See Fx_get_resource below for other parameters. */
+
+ static Lisp_Object
+ xrdb_get_resource (rdb, attribute, class, component, subclass)
+ XrmDatabase rdb;
+ Lisp_Object attribute, class, component, subclass;
+ {
+ register char *value;
+ char *name_key;
+ char *class_key;
+
+ CHECK_STRING (attribute);
+ CHECK_STRING (class);
+
+ if (!NILP (component))
+ CHECK_STRING (component);
+ if (!NILP (subclass))
+ CHECK_STRING (subclass);
+ if (NILP (component) != NILP (subclass))
+ error ("x-get-resource: must specify both COMPONENT and SUBCLASS or
neither");
+
+ validate_x_resource_name ();
+
+ /* Allocate space for the components, the dots which separate them,
+ and the final '\0'. Make them big enough for the worst case. */
+ name_key = (char *) alloca (SBYTES (Vx_resource_name)
+ + (STRINGP (component)
+ ? SBYTES (component) : 0)
+ + SBYTES (attribute)
+ + 3);
+
+ class_key = (char *) alloca (SBYTES (Vx_resource_class)
+ + SBYTES (class)
+ + (STRINGP (subclass)
+ ? SBYTES (subclass) : 0)
+ + 3);
+
+ /* Start with emacs.FRAMENAME for the name (the specific one)
+ and with `Emacs' for the class key (the general one). */
+ strcpy (name_key, SDATA (Vx_resource_name));
+ strcpy (class_key, SDATA (Vx_resource_class));
+
+ strcat (class_key, ".");
+ strcat (class_key, SDATA (class));
+
+ if (!NILP (component))
+ {
+ strcat (class_key, ".");
+ strcat (class_key, SDATA (subclass));
+
+ strcat (name_key, ".");
+ strcat (name_key, SDATA (component));
+ }
+
+ strcat (name_key, ".");
+ strcat (name_key, SDATA (attribute));
+
+ value = x_get_string_resource (rdb, name_key, class_key);
+
+ if (value != (char *) 0)
+ return build_string (value);
+ else
+ return Qnil;
+ }
+
+
+ DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
+ doc: /* Return the value of ATTRIBUTE, of class CLASS, from the X
defaults database.
+ This uses `INSTANCE.ATTRIBUTE' as the key and `Emacs.CLASS' as the
+ class, where INSTANCE is the name under which Emacs was invoked, or
+ the name specified by the `-name' or `-rn' command-line arguments.
+
+ The optional arguments COMPONENT and SUBCLASS add to the key and the
+ class, respectively. You must specify both of them or neither.
+ If you specify them, the key is `INSTANCE.COMPONENT.ATTRIBUTE'
+ and the class is `Emacs.CLASS.SUBCLASS'. */)
+ (attribute, class, component, subclass)
+ Lisp_Object attribute, class, component, subclass;
+ {
+ #ifdef HAVE_X_WINDOWS
+ check_x ();
+ #endif
+
+ return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
+ attribute, class, component, subclass);
+ }
+
+ /* Get an X resource, like Fx_get_resource, but for display DPYINFO. */
+
+ Lisp_Object
+ display_x_get_resource (dpyinfo, attribute, class, component, subclass)
+ Display_Info *dpyinfo;
+ Lisp_Object attribute, class, component, subclass;
+ {
+ return xrdb_get_resource (dpyinfo->xrdb,
+ attribute, class, component, subclass);
+ }
+
+ /* Used when C code wants a resource value. */
+
+ char *
+ x_get_resource_string (attribute, class)
+ char *attribute, *class;
+ {
+ char *name_key;
+ char *class_key;
+ struct frame *sf = SELECTED_FRAME ();
+
+ /* Allocate space for the components, the dots which separate them,
+ and the final '\0'. */
+ name_key = (char *) alloca (SBYTES (Vinvocation_name)
+ + strlen (attribute) + 2);
+ class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ + strlen (class) + 2);
+
+ sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
+ sprintf (class_key, "%s.%s", EMACS_CLASS, class);
+
+ return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
+ name_key, class_key);
+ }
+
+
+ /* Return the value of parameter PARAM.
+
+ First search ALIST, then Vdefault_frame_alist, then the X defaults
+ database, using ATTRIBUTE as the attribute name and CLASS as its class.
+
+ Convert the resource to the type specified by desired_type.
+
+ If no default is specified, return Qunbound. If you call
+ x_get_arg, make sure you deal with Qunbound in a reasonable way,
+ and don't let it get stored in any Lisp-visible variables! */
+
+ Lisp_Object
+ x_get_arg (dpyinfo, alist, param, attribute, class, type)
+ Display_Info *dpyinfo;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+ {
+ register Lisp_Object tem;
+
+ tem = Fassq (param, alist);
+ if (EQ (tem, Qnil))
+ tem = Fassq (param, Vdefault_frame_alist);
+ if (EQ (tem, Qnil))
+ {
+ if (attribute)
+ {
+ tem = display_x_get_resource (dpyinfo,
+ build_string (attribute),
+ build_string (class),
+ Qnil, Qnil);
+
+ if (NILP (tem))
+ return Qunbound;
+
+ switch (type)
+ {
+ case RES_TYPE_NUMBER:
+ return make_number (atoi (SDATA (tem)));
+
+ case RES_TYPE_FLOAT:
+ return make_float (atof (SDATA (tem)));
+
+ case RES_TYPE_BOOLEAN:
+ tem = Fdowncase (tem);
+ if (!strcmp (SDATA (tem), "on")
+ || !strcmp (SDATA (tem), "true"))
+ return Qt;
+ else
+ return Qnil;
+
+ case RES_TYPE_STRING:
+ return tem;
+
+ case RES_TYPE_SYMBOL:
+ /* As a special case, we map the values `true' and `on'
+ to Qt, and `false' and `off' to Qnil. */
+ {
+ Lisp_Object lower;
+ lower = Fdowncase (tem);
+ if (!strcmp (SDATA (lower), "on")
+ || !strcmp (SDATA (lower), "true"))
+ return Qt;
+ else if (!strcmp (SDATA (lower), "off")
+ || !strcmp (SDATA (lower), "false"))
+ return Qnil;
+ else
+ return Fintern (tem, Qnil);
+ }
+
+ default:
+ abort ();
+ }
+ }
+ else
+ return Qunbound;
+ }
+ return Fcdr (tem);
+ }
+
+ Lisp_Object
+ x_frame_get_arg (f, alist, param, attribute, class, type)
+ struct frame *f;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+ {
+ return x_get_arg (FRAME_X_DISPLAY_INFO (f),
+ alist, param, attribute, class, type);
+ }
+
+ /* Like x_frame_get_arg, but also record the value in f->param_alist. */
+
+ Lisp_Object
+ x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
+ struct frame *f;
+ Lisp_Object alist, param;
+ char *attribute;
+ char *class;
+ enum resource_types type;
+ {
+ Lisp_Object value;
+
+ value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
+ attribute, class, type);
+ if (! NILP (value))
+ store_frame_param (f, param, value);
+
+ return value;
+ }
+
+
+ /* Record in frame F the specified or default value according to ALIST
+ of the parameter named PROP (a Lisp symbol).
+ If no value is specified for PROP, look for an X default for XPROP
+ on the frame named NAME.
+ If that is not found either, use the value DEFLT. */
+
+ Lisp_Object
+ x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
+ struct frame *f;
+ Lisp_Object alist;
+ Lisp_Object prop;
+ Lisp_Object deflt;
+ char *xprop;
+ char *xclass;
+ enum resource_types type;
+ {
+ Lisp_Object tem;
+
+ tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
+ if (EQ (tem, Qunbound))
+ tem = deflt;
+ x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
+ return tem;
+ }
+
+
+
+
+ DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
+ doc: /* Parse an X-style geometry string STRING.
+ Returns an alist of the form ((top . TOP), (left . LEFT) ... ).
+ The properties returned may include `top', `left', `height', and `width'.
+ The value of `left' or `top' may be an integer,
+ or a list (+ N) meaning N pixels relative to top/left corner,
+ or a list (- N) meaning -N pixels relative to bottom/right corner. */)
+ (string)
+ Lisp_Object string;
+ {
+ int geometry, x, y;
+ unsigned int width, height;
+ Lisp_Object result;
+
+ CHECK_STRING (string);
+
+ geometry = XParseGeometry ((char *) SDATA (string),
+ &x, &y, &width, &height);
+
+ #if 0
+ if (!!(geometry & XValue) != !!(geometry & YValue))
+ error ("Must specify both x and y position, or neither");
+ #endif
+
+ result = Qnil;
+ if (geometry & XValue)
+ {
+ Lisp_Object element;
+
+ if (x >= 0 && (geometry & XNegative))
+ element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
+ else if (x < 0 && ! (geometry & XNegative))
+ element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
+ else
+ element = Fcons (Qleft, make_number (x));
+ result = Fcons (element, result);
+ }
+
+ if (geometry & YValue)
+ {
+ Lisp_Object element;
+
+ if (y >= 0 && (geometry & YNegative))
+ element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
+ else if (y < 0 && ! (geometry & YNegative))
+ element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
+ else
+ element = Fcons (Qtop, make_number (y));
+ result = Fcons (element, result);
+ }
+
+ if (geometry & WidthValue)
+ result = Fcons (Fcons (Qwidth, make_number (width)), result);
+ if (geometry & HeightValue)
+ result = Fcons (Fcons (Qheight, make_number (height)), result);
+
+ return result;
+ }
+
+ /* Calculate the desired size and position of frame F.
+ Return the flags saying which aspects were specified.
+
+ Also set the win_gravity and size_hint_flags of F.
+
+ Adjust height for toolbar if TOOLBAR_P is 1.
+
+ This function does not make the coordinates positive. */
+
+ #define DEFAULT_ROWS 40
+ #define DEFAULT_COLS 80
+
+ int
+ x_figure_window_size (f, parms, toolbar_p)
+ struct frame *f;
+ Lisp_Object parms;
+ int toolbar_p;
+ {
+ register Lisp_Object tem0, tem1, tem2;
+ long window_prompting = 0;
+ Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+
+ /* Default values if we fall through.
+ Actually, if that happens we should get
+ window manager prompting. */
+ SET_FRAME_COLS (f, DEFAULT_COLS);
+ FRAME_LINES (f) = DEFAULT_ROWS;
+ /* Window managers expect that if program-specified
+ positions are not (0,0), they're intentional, not defaults. */
+ f->top_pos = 0;
+ f->left_pos = 0;
+
+ /* Ensure that old new_text_cols and new_text_lines will not override the
+ values set here. */
+ /* ++KFS: This was specific to W32, but seems ok for all platforms */
+ f->new_text_cols = f->new_text_lines = 0;
+
+ tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
+ tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
+ tem2 = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
+ if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
+ {
+ if (!EQ (tem0, Qunbound))
+ {
+ CHECK_NUMBER (tem0);
+ FRAME_LINES (f) = XINT (tem0);
+ }
+ if (!EQ (tem1, Qunbound))
+ {
+ CHECK_NUMBER (tem1);
+ SET_FRAME_COLS (f, XINT (tem1));
+ }
+ if (!NILP (tem2) && !EQ (tem2, Qunbound))
+ window_prompting |= USSize;
+ else
+ window_prompting |= PSize;
+ }
+
+ f->scroll_bar_actual_width
+ = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
+
+ /* This used to be done _before_ calling x_figure_window_size, but
+ since the height is reset here, this was really a no-op. I
+ assume that moving it here does what Gerd intended (although he
+ no longer can remember what that was... ++KFS, 2003-03-25. */
+
+ /* Add the tool-bar height to the initial frame height so that the
+ user gets a text display area of the size he specified with -g or
+ via .Xdefaults. Later changes of the tool-bar height don't
+ change the frame size. This is done so that users can create
+ tall Emacs frames without having to guess how tall the tool-bar
+ will get. */
+ if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
+ {
+ int margin, relief, bar_height;
+
+ relief = (tool_bar_button_relief >= 0
+ ? tool_bar_button_relief
+ : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
+
+ if (INTEGERP (Vtool_bar_button_margin)
+ && XINT (Vtool_bar_button_margin) > 0)
+ margin = XFASTINT (Vtool_bar_button_margin);
+ else if (CONSP (Vtool_bar_button_margin)
+ && INTEGERP (XCDR (Vtool_bar_button_margin))
+ && XINT (XCDR (Vtool_bar_button_margin)) > 0)
+ margin = XFASTINT (XCDR (Vtool_bar_button_margin));
+ else
+ margin = 0;
+
+ bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
+ FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) /
FRAME_LINE_HEIGHT (f);
+ }
+
+ compute_fringe_widths (f, 0);
+
+ FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
+ FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES
(f));
+
+ tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
+ tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
+ tem2 = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
+ if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
+ {
+ if (EQ (tem0, Qminus))
+ {
+ f->top_pos = 0;
+ window_prompting |= YNegative;
+ }
+ else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
+ && CONSP (XCDR (tem0))
+ && INTEGERP (XCAR (XCDR (tem0))))
+ {
+ f->top_pos = - XINT (XCAR (XCDR (tem0)));
+ window_prompting |= YNegative;
+ }
+ else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
+ && CONSP (XCDR (tem0))
+ && INTEGERP (XCAR (XCDR (tem0))))
+ {
+ f->top_pos = XINT (XCAR (XCDR (tem0)));
+ }
+ else if (EQ (tem0, Qunbound))
+ f->top_pos = 0;
+ else
+ {
+ CHECK_NUMBER (tem0);
+ f->top_pos = XINT (tem0);
+ if (f->top_pos < 0)
+ window_prompting |= YNegative;
+ }
+
+ if (EQ (tem1, Qminus))
+ {
+ f->left_pos = 0;
+ window_prompting |= XNegative;
+ }
+ else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
+ && CONSP (XCDR (tem1))
+ && INTEGERP (XCAR (XCDR (tem1))))
+ {
+ f->left_pos = - XINT (XCAR (XCDR (tem1)));
+ window_prompting |= XNegative;
+ }
+ else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
+ && CONSP (XCDR (tem1))
+ && INTEGERP (XCAR (XCDR (tem1))))
+ {
+ f->left_pos = XINT (XCAR (XCDR (tem1)));
+ }
+ else if (EQ (tem1, Qunbound))
+ f->left_pos = 0;
+ else
+ {
+ CHECK_NUMBER (tem1);
+ f->left_pos = XINT (tem1);
+ if (f->left_pos < 0)
+ window_prompting |= XNegative;
+ }
+
+ if (!NILP (tem2) && ! EQ (tem2, Qunbound))
+ window_prompting |= USPosition;
+ else
+ window_prompting |= PPosition;
+ }
+
+ if (f->want_fullscreen != FULLSCREEN_NONE)
+ {
+ int left, top;
+ int width, height;
+
+ /* It takes both for some WM:s to place it where we want */
+ window_prompting = USPosition | PPosition;
+ x_fullscreen_adjust (f, &width, &height, &top, &left);
+ FRAME_COLS (f) = width;
+ FRAME_LINES (f) = height;
+ FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
+ FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
+ f->left_pos = left;
+ f->top_pos = top;
+ }
+
+ if (window_prompting & XNegative)
+ {
+ if (window_prompting & YNegative)
+ f->win_gravity = SouthEastGravity;
+ else
+ f->win_gravity = NorthEastGravity;
+ }
+ else
+ {
+ if (window_prompting & YNegative)
+ f->win_gravity = SouthWestGravity;
+ else
+ f->win_gravity = NorthWestGravity;
+ }
+
+ f->size_hint_flags = window_prompting;
+
+ return window_prompting;
+ }
+
+
+
+ #endif /* HAVE_WINDOW_SYSTEM */
+
+
+
+ /***********************************************************************
+ Initialization
+ ***********************************************************************/
+
+ void
+ syms_of_frame ()
+ {
+ Qframep = intern ("framep");
+ staticpro (&Qframep);
+ Qframe_live_p = intern ("frame-live-p");
+ staticpro (&Qframe_live_p);
+ Qheight = intern ("height");
+ staticpro (&Qheight);
+ Qicon = intern ("icon");
+ staticpro (&Qicon);
+ Qminibuffer = intern ("minibuffer");
+ staticpro (&Qminibuffer);
+ Qmodeline = intern ("modeline");
+ staticpro (&Qmodeline);
+ Qonly = intern ("only");
+ staticpro (&Qonly);
+ Qwidth = intern ("width");
+ staticpro (&Qwidth);
+ Qgeometry = intern ("geometry");
+ staticpro (&Qgeometry);
+ Qicon_left = intern ("icon-left");
+ staticpro (&Qicon_left);
+ Qicon_top = intern ("icon-top");
+ staticpro (&Qicon_top);
+ Qleft = intern ("left");
+ staticpro (&Qleft);
+ Qright = intern ("right");
+ staticpro (&Qright);
+ Quser_position = intern ("user-position");
+ staticpro (&Quser_position);
+ Quser_size = intern ("user-size");
+ staticpro (&Quser_size);
+ Qwindow_id = intern ("window-id");
+ staticpro (&Qwindow_id);
+ #ifdef HAVE_X_WINDOWS
+ Qouter_window_id = intern ("outer-window-id");
+ staticpro (&Qouter_window_id);
+ #endif
+ Qparent_id = intern ("parent-id");
+ staticpro (&Qparent_id);
+ Qx = intern ("x");
+ staticpro (&Qx);
+ Qw32 = intern ("w32");
+ staticpro (&Qw32);
+ Qpc = intern ("pc");
+ staticpro (&Qpc);
+ Qmac = intern ("mac");
+ staticpro (&Qmac);
+ Qvisible = intern ("visible");
+ staticpro (&Qvisible);
+ Qbuffer_predicate = intern ("buffer-predicate");
+ staticpro (&Qbuffer_predicate);
+ Qbuffer_list = intern ("buffer-list");
+ staticpro (&Qbuffer_list);
+ Qdisplay_type = intern ("display-type");
+ staticpro (&Qdisplay_type);
+ Qbackground_mode = intern ("background-mode");
+ staticpro (&Qbackground_mode);
+ Qtty_color_mode = intern ("tty-color-mode");
+ staticpro (&Qtty_color_mode);
+
+ Qface_set_after_frame_default = intern ("face-set-after-frame-default");
+ staticpro (&Qface_set_after_frame_default);
+
+ Qfullwidth = intern ("fullwidth");
+ staticpro (&Qfullwidth);
+ Qfullheight = intern ("fullheight");
+ staticpro (&Qfullheight);
+ Qfullboth = intern ("fullboth");
+ staticpro (&Qfullboth);
+ Qx_resource_name = intern ("x-resource-name");
+ staticpro (&Qx_resource_name);
+
+ Qx_frame_parameter = intern ("x-frame-parameter");
+ staticpro (&Qx_frame_parameter);
+
+ {
+ int i;
+
+ for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
+ {
+ Lisp_Object v = intern (frame_parms[i].name);
+ if (frame_parms[i].variable)
+ {
+ *frame_parms[i].variable = v;
+ staticpro (frame_parms[i].variable);
+ }
+ Fput (v, Qx_frame_parameter, make_number (i));
+ }
+ }
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
+ doc: /* The name Emacs uses to look up X resources.
+ `x-get-resource' uses this as the first component of the instance name
+ when requesting resource values.
+ Emacs initially sets `x-resource-name' to the name under which Emacs
+ was invoked, or to the value specified with the `-name' or `-rn'
+ switches, if present.
+
+ It may be useful to bind this variable locally around a call
+ to `x-get-resource'. See also the variable `x-resource-class'. */);
+ Vx_resource_name = Qnil;
+
+ DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
+ doc: /* The class Emacs uses to look up X resources.
+ `x-get-resource' uses this as the first component of the instance class
+ when requesting resource values.
+
+ Emacs initially sets `x-resource-class' to "Emacs".
+
+ Setting this variable permanently is not a reasonable thing to do,
+ but binding this variable locally around a call to `x-get-resource'
+ is a reasonable practice. See also the variable `x-resource-name'. */);
+ Vx_resource_class = build_string (EMACS_CLASS);
+ #endif
+
+ DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
+ doc: /* Alist of default values for frame creation.
+ These may be set in your init file, like this:
+ (setq default-frame-alist '((width . 80) (height . 55) (menu-bar-lines . 1))
+ These override values given in window system configuration data,
+ including X Windows' defaults database.
+ For values specific to the first Emacs frame, see `initial-frame-alist'.
+ For values specific to the separate minibuffer frame, see
+ `minibuffer-frame-alist'.
+ The `menu-bar-lines' element of the list controls whether new frames
+ have menu bars; `menu-bar-mode' works by altering this element.
+ Setting this variable does not affect existing frames, only new ones. */);
+ Vdefault_frame_alist = Qnil;
+
+ Qinhibit_default_face_x_resources
+ = intern ("inhibit-default-face-x-resources");
+ staticpro (&Qinhibit_default_face_x_resources);
+
+ DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
+ doc: /* The initial frame-object, which represents Emacs's
stdout. */);
+
+ DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
+ doc: /* Non-nil if all of emacs is iconified and frame updates
are not needed. */);
+ Vemacs_iconified = Qnil;
+
+ DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
+ doc: /* If non-nil, function to transform normal value of
`mouse-position'.
+ `mouse-position' calls this function, passing its usual return value as
+ argument, and returns whatever this function returns.
+ This abnormal hook exists for the benefit of packages like `xt-mouse.el'
+ which need to do mouse handling at the Lisp level. */);
+ Vmouse_position_function = Qnil;
+
+ DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
+ doc: /* If non-nil, clickable text is highlighted when mouse is
over it.
+ If the value is an integer, highlighting is only shown after moving the
+ mouse, while keyboard input turns off the highlight even when the mouse
+ is over the clickable text. However, the mouse shape still indicates
+ when the mouse is over clickable text. */);
+ Vmouse_highlight = Qt;
+
+ DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
+ doc: /* Functions to be run before deleting a frame.
+ The functions are run with one arg, the frame to be deleted.
+ See `delete-frame'. */);
+ Vdelete_frame_functions = Qnil;
+
+ DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
+ doc: /* Minibufferless frames use this frame's minibuffer.
+
+ Emacs cannot create minibufferless frames unless this is set to an
+ appropriate surrogate.
+
+ Emacs consults this variable only when creating minibufferless
+ frames; once the frame is created, it sticks with its assigned
+ minibuffer, no matter what this variable is set to. This means that
+ this variable doesn't necessarily say anything meaningful about the
+ current set of frames, or where the minibuffer is currently being
+ displayed.
+
+ This variable is local to the current terminal and cannot be buffer-local.
*/);
+
+ staticpro (&Vframe_list);
+
+ defsubr (&Sactive_minibuffer_window);
+ defsubr (&Sframep);
+ defsubr (&Sframe_live_p);
+ defsubr (&Smake_terminal_frame);
+ defsubr (&Shandle_switch_frame);
+ defsubr (&Signore_event);
+ defsubr (&Sselect_frame);
+ defsubr (&Sselected_frame);
+ defsubr (&Swindow_frame);
+ defsubr (&Sframe_root_window);
+ defsubr (&Sframe_first_window);
+ defsubr (&Sframe_selected_window);
+ defsubr (&Sset_frame_selected_window);
+ defsubr (&Sframe_list);
+ defsubr (&Snext_frame);
+ defsubr (&Sprevious_frame);
+ defsubr (&Sdelete_frame);
+ defsubr (&Smouse_position);
+ defsubr (&Smouse_pixel_position);
+ defsubr (&Sset_mouse_position);
+ defsubr (&Sset_mouse_pixel_position);
+ #if 0
+ defsubr (&Sframe_configuration);
+ defsubr (&Srestore_frame_configuration);
+ #endif
+ defsubr (&Smake_frame_visible);
+ defsubr (&Smake_frame_invisible);
+ defsubr (&Siconify_frame);
+ defsubr (&Sframe_visible_p);
+ defsubr (&Svisible_frame_list);
+ defsubr (&Sraise_frame);
+ defsubr (&Slower_frame);
+ defsubr (&Sredirect_frame_focus);
+ defsubr (&Sframe_focus);
+ defsubr (&Sframe_parameters);
+ defsubr (&Sframe_parameter);
+ defsubr (&Smodify_frame_parameters);
+ defsubr (&Sframe_char_height);
+ defsubr (&Sframe_char_width);
+ defsubr (&Sframe_pixel_height);
+ defsubr (&Sframe_pixel_width);
+ defsubr (&Sset_frame_height);
+ defsubr (&Sset_frame_width);
+ defsubr (&Sset_frame_size);
+ defsubr (&Sset_frame_position);
+
+ #ifdef HAVE_WINDOW_SYSTEM
+ defsubr (&Sx_get_resource);
+ defsubr (&Sx_parse_geometry);
+ #endif
+
+ }
[Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] Changes to emacs/src/frame.c [Boehm-GC],
Dave Love <=