/* Generic frame functions.
- Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000, 2001, 2002, 2003,
- 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+
+Copyright (C) 1993-1995, 1997, 1999-2013 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
+#define FRAME_INLINE EXTERN_INLINE
+
#include <stdio.h>
-#include <ctype.h>
-#include <setjmp.h>
+#include <errno.h>
+#include <limits.h>
+
+#include <c-ctype.h>
+
#include "lisp.h"
#include "character.h"
-#ifdef HAVE_X_WINDOWS
-#include "xterm.h"
-#endif
-#ifdef WINDOWSNT
-#include "w32term.h"
-#endif
-#ifdef HAVE_NS
-#include "nsterm.h"
-#endif
+
+#ifdef HAVE_WINDOW_SYSTEM
+#include TERM_HEADER
+#endif /* HAVE_WINDOW_SYSTEM */
+
#include "buffer.h"
/* These help us bind and responding to switch-frame events. */
#include "commands.h"
#include "dosfns.h"
#endif
-
-/* If we shall make pointer invisible when typing or not. */
-Lisp_Object Vmake_pointer_invisible;
-
-#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;
-
-/* Lower limit value of the frame opacity (alpha transparency). */
-
-Lisp_Object Vframe_alpha_lower_limit;
-
-#endif
-
#ifdef HAVE_NS
Lisp_Object Qns_parse_geometry;
#endif
Lisp_Object Qframep, Qframe_live_p;
Lisp_Object Qicon, Qmodeline;
-Lisp_Object Qonly;
-Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
+Lisp_Object Qonly, Qnone;
+Lisp_Object Qx, Qw32, Qpc, Qns;
Lisp_Object Qvisible;
Lisp_Object Qdisplay_type;
-Lisp_Object Qbackground_mode;
+static Lisp_Object Qbackground_mode;
Lisp_Object Qnoelisp;
-Lisp_Object Qx_frame_parameter;
+static Lisp_Object Qx_frame_parameter;
Lisp_Object Qx_resource_name;
Lisp_Object Qterminal;
-Lisp_Object Qterminal_live_p;
/* 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 Qscroll_bar_foreground, Qscroll_bar_background;
Lisp_Object Qscreen_gamma;
Lisp_Object Qline_spacing;
-Lisp_Object Quser_position, Quser_size;
+static Lisp_Object Quser_position, Quser_size;
Lisp_Object Qwait_for_wm;
-Lisp_Object Qwindow_id;
+static Lisp_Object Qwindow_id;
#ifdef HAVE_X_WINDOWS
-Lisp_Object Qouter_window_id;
+static Lisp_Object Qouter_window_id;
#endif
Lisp_Object Qparent_id;
Lisp_Object Qtitle, Qname;
-Lisp_Object Qexplicit_name;
+static Lisp_Object Qexplicit_name;
Lisp_Object Qunsplittable;
-Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
+Lisp_Object Qmenu_bar_lines, Qtool_bar_lines, Qtool_bar_position;
Lisp_Object Qleft_fringe, Qright_fringe;
-Lisp_Object Qbuffer_predicate, Qbuffer_list, Qburied_buffer_list;
+Lisp_Object Qbuffer_predicate;
+static Lisp_Object Qbuffer_list, Qburied_buffer_list;
Lisp_Object Qtty_color_mode;
Lisp_Object Qtty, Qtty_type;
Lisp_Object Qface_set_after_frame_default;
-Lisp_Object Vterminal_frame;
-Lisp_Object Vdefault_frame_alist;
-Lisp_Object Vdefault_frame_scroll_bars;
-Lisp_Object Vmouse_position_function;
-Lisp_Object Vmouse_highlight;
-static Lisp_Object Vdelete_frame_functions, Qdelete_frame_functions;
+static Lisp_Object Qdelete_frame_functions;
-int focus_follows_mouse;
-\f
+static Lisp_Object Qgeometry, Qworkarea, Qmm_size, Qframes, Qsource;
+
+#ifdef HAVE_WINDOW_SYSTEM
+static void x_report_frame_params (struct frame *, Lisp_Object *);
+#endif
+
+/* These setters are used only in this file, so they can be private. */
static void
-set_menu_bar_lines_1 (window, n)
- Lisp_Object window;
- int n;
+fset_buffer_predicate (struct frame *f, Lisp_Object val)
{
- struct window *w = XWINDOW (window);
+ f->buffer_predicate = val;
+}
+static void
+fset_minibuffer_window (struct frame *f, Lisp_Object val)
+{
+ f->minibuffer_window = val;
+}
- XSETFASTINT (w->last_modified, 0);
- XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
- XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
+struct frame *
+decode_live_frame (register Lisp_Object frame)
+{
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ return XFRAME (frame);
+}
- 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);
+struct frame *
+decode_any_frame (register Lisp_Object frame)
+{
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_FRAME (frame);
+ return XFRAME (frame);
+}
- /* Handle just the top child in a vertical split. */
- if (!NILP (w->vchild))
- set_menu_bar_lines_1 (w->vchild, n);
+bool
+window_system_available (struct frame *f)
+{
+ if (f)
+ return FRAME_WINDOW_P (f) || FRAME_MSDOS_P (f);
+ else
+#ifdef HAVE_WINDOW_SYSTEM
+ return x_display_list != NULL;
+#else
+ return 0;
+#endif
+}
- /* 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);
- }
+struct frame *
+decode_window_system_frame (Lisp_Object frame)
+{
+ struct frame *f = decode_live_frame (frame);
+
+ if (!window_system_available (f))
+ error ("Window system frame should be used");
+ return f;
}
void
-set_menu_bar_lines (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+check_window_system (struct frame *f)
+{
+ if (!window_system_available (f))
+ error (f ? "Window system frame should be used"
+ : "Window system is not in use or not initialized");
+}
+
+static void
+set_menu_bar_lines_1 (Lisp_Object window, int n)
+{
+ struct window *w = XWINDOW (window);
+
+ w->top_line += n;
+ w->total_lines -= n;
+
+ /* Handle just the top child in a vertical split. */
+ if (WINDOW_VERTICAL_COMBINATION_P (w))
+ set_menu_bar_lines_1 (w->contents, n);
+ else if (WINDOW_HORIZONTAL_COMBINATION_P (w))
+ /* Adjust all children in a horizontal split. */
+ for (window = w->contents; !NILP (window); window = w->next)
+ {
+ w = XWINDOW (window);
+ set_menu_bar_lines_1 (window, n);
+ }
+}
+
+void
+set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
int nlines;
int olines = FRAME_MENU_BAR_LINES (f);
if (FRAME_MINIBUF_ONLY_P (f))
return;
- if (INTEGERP (value))
+ if (TYPE_RANGED_INTEGERP (int, value))
nlines = XINT (value);
else
nlines = 0;
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);
+ adjust_frame_glyphs (f);
}
}
\f
Lisp_Object Vframe_list;
-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 ();
-extern Lisp_Object QCname, Qfont_param;
-
\f
DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
doc: /* Return non-nil if OBJECT is a frame.
'ns' for an Emacs frame on a GNUstep or Macintosh Cocoa display,
'pc' for a direct-write MS-DOS frame.
See also `frame-live-p'. */)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
if (!FRAMEP (object))
return Qnil;
return Qw32;
case output_msdos_raw:
return Qpc;
- case output_mac:
- return Qmac;
case output_ns:
return Qns;
default:
- abort ();
+ emacs_abort ();
}
}
frame, the return value indicates what sort of terminal device it is
displayed on. See the documentation of `framep' for possible
return values. */)
- (object)
- Lisp_Object object;
+ (Lisp_Object object)
{
return ((FRAMEP (object)
&& FRAME_LIVE_P (XFRAME (object)))
Use of this function as a predicate is deprecated. Instead,
use `display-graphic-p' or any of the other `display-*-p'
predicates which report frame's specific UI-related capabilities. */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
Lisp_Object type;
if (NILP (frame))
}
struct frame *
-make_frame (mini_p)
- int mini_p;
+make_frame (bool mini_p)
{
Lisp_Object frame;
register struct frame *f;
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;
+ /* Initialize Lisp data. Note that allocate_frame initializes all
+ Lisp data to nil, so do it only for slots which should not be nil. */
+ fset_tool_bar_position (f, Qtop);
+
+ /* Initialize non-Lisp data. Note that allocate_frame zeroes out all
+ non-Lisp data, so do it only for slots which should not be zero.
+ To avoid subtle bugs and for the sake of readability, it's better to
+ initialize enum members explicitly even if their values are zero. */
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;
- f->buried_buffer_list = Qnil;
- 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;
- f->font_driver_list = NULL;
- f->font_data_list = NULL;
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;
+ wset_next (XWINDOW (root_window), mini_window);
+ wset_prev (XWINDOW (mini_window), root_window);
+ XWINDOW (mini_window)->mini = 1;
+ wset_frame (XWINDOW (mini_window), frame);
+ fset_minibuffer_window (f, mini_window);
}
else
{
mini_window = Qnil;
- XWINDOW (root_window)->next = Qnil;
- f->minibuffer_window = Qnil;
+ wset_next (XWINDOW (root_window), Qnil);
+ fset_minibuffer_window (f, Qnil);
}
- XWINDOW (root_window)->frame = frame;
+ wset_frame (XWINDOW (root_window), frame);
/* 10 is arbitrary,
just so that there is "something there."
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));
+ XWINDOW (root_window)->total_cols = 10;
+ 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);
+ XWINDOW (mini_window)->total_cols = 10;
+ XWINDOW (mini_window)->top_line = 9;
+ XWINDOW (mini_window)->total_lines = 1;
}
/* Choose a buffer for the frame's root window. */
{
- Lisp_Object buf;
+ Lisp_Object buf = Fcurrent_buffer ();
- 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);
+ /* If current buffer is hidden, try to find another one. */
+ if (BUFFER_HIDDEN_P (XBUFFER (buf)))
+ buf = other_buffer_safely (buf);
/* 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
+ arrangement is not yet fully initialized 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);
+ fset_buffer_list (f, list1 (buf));
}
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;
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)),
+ 0, 0);
+
+ fset_root_window (f, root_window);
+ fset_selected_window (f, root_window);
/* Make sure this window seems more recently used than
a newly-created, never-selected window. */
- ++window_select_count;
- XSETFASTINT (XWINDOW (f->selected_window)->use_time, window_select_count);
-
- f->default_face_done_p = 0;
+ XWINDOW (f->selected_window)->use_time = ++window_select_count;
return f;
}
default (the global minibuffer). */
struct frame *
-make_frame_without_minibuffer (mini_window, kb, display)
- register Lisp_Object mini_window;
- KBOARD *kb;
- Lisp_Object display;
+make_frame_without_minibuffer (register Lisp_Object mini_window, KBOARD *kb, Lisp_Object display)
{
register struct frame *f;
struct gcpro gcpro1;
if (NILP (mini_window))
{
/* Use default-minibuffer-frame if possible. */
- if (!FRAMEP (kb->Vdefault_minibuffer_frame)
- || ! FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame)))
+ if (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
+ || ! FRAME_LIVE_P (XFRAME (KVAR (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);
+ kset_default_minibuffer_frame
+ (kb, call1 (intern ("make-initial-minibuffer-frame"), display));
UNGCPRO;
}
- mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
+ mini_window
+ = XFRAME (KVAR (kb, Vdefault_minibuffer_frame))->minibuffer_window;
}
- f->minibuffer_window = mini_window;
+ fset_minibuffer_window (f, 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);
+ if (NILP (Fmemq (XWINDOW (mini_window)->contents, Vminibuffer_list)))
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), 0, 0);
return f;
}
/* Make a frame containing only a minibuffer window. */
struct frame *
-make_minibuffer_frame ()
+make_minibuffer_frame (void)
{
/* First make a frame containing just a root window, no 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;
+ mini_window = f->root_window;
+ fset_minibuffer_window (f, mini_window);
+ XWINDOW (mini_window)->mini = 1;
+ wset_next (XWINDOW (mini_window), Qnil);
+ wset_prev (XWINDOW (mini_window), Qnil);
+ wset_frame (XWINDOW (mini_window), frame);
/* Put the proper buffer in that window. */
- Fset_window_buffer (mini_window,
- (NILP (Vminibuffer_list)
- ? get_minibuffer (0)
- : Fcar (Vminibuffer_list)), Qnil);
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (mini_window,
+ (NILP (Vminibuffer_list)
+ ? get_minibuffer (0)
+ : Fcar (Vminibuffer_list)), 0, 0);
return f;
}
#endif /* HAVE_WINDOW_SYSTEM */
\f
/* Construct a frame that refers to a terminal. */
-static int tty_frame_count;
+static printmax_t tty_frame_count;
struct frame *
make_initial_frame (void)
Vframe_list = Fcons (frame, Vframe_list);
tty_frame_count = 1;
- f->name = make_pure_c_string ("F1");
+ fset_name (f, build_pure_c_string ("F1"));
- f->visible = 1;
- f->async_visible = 1;
+ SET_FRAME_VISIBLE (f, 1);
f->output_method = terminal->type;
f->terminal = terminal;
FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
- FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
-#ifdef CANNOT_DUMP
+ /* The default value of menu-bar-mode is t. */
+ set_menu_bar_lines (f, make_number (1), Qnil);
+
if (!noninteractive)
init_frame_faces (f);
-#endif
return f;
}
-struct frame *
+static struct frame *
make_terminal_frame (struct terminal *terminal)
{
register struct frame *f;
Lisp_Object frame;
- char name[20];
+ char name[sizeof "F" + INT_STRLEN_BOUND (printmax_t)];
if (!terminal->name)
error ("Terminal is not live, can't create new frames on it");
XSETFRAME (frame, f);
Vframe_list = Fcons (frame, Vframe_list);
- tty_frame_count++;
- sprintf (name, "F%d", tty_frame_count);
- f->name = build_string (name);
+ fset_name (f, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
+
+ SET_FRAME_VISIBLE (f, 1);
- f->visible = 1; /* FRAME_SET_VISIBLE wd set frame_garbaged. */
- f->async_visible = 1; /* Don't let visible be cleared later. */
f->terminal = terminal;
f->terminal->reference_count++;
#ifdef MSDOS
FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
#endif /* not MSDOS */
- FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
+ FRAME_MENU_BAR_LINES(f) = NILP (Vmenu_bar_mode) ? 0 : 1;
/* Set the top frame to the newly created frame. */
if (FRAMEP (FRAME_TTY (f)->top_frame)
&& FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
- XFRAME (FRAME_TTY (f)->top_frame)->async_visible = 2; /* obscured */
+ SET_FRAME_VISIBLE (XFRAME (FRAME_TTY (f)->top_frame), 2); /* obscured */
FRAME_TTY (f)->top_frame = frame;
/* Get a suitable value for frame parameter PARAMETER for a newly
created frame, based on (1) the user-supplied frame parameter
- alist SUPPLIED_PARMS, (2) CURRENT_VALUE, and finally, if all else
- fails, (3) Vdefault_frame_alist. */
+ alist SUPPLIED_PARMS, and (2) CURRENT_VALUE. */
static Lisp_Object
get_future_frame_param (Lisp_Object parameter,
result = Fassq (parameter, XFRAME (selected_frame)->param_alist);
if (NILP (result) && current_value != NULL)
result = build_string (current_value);
- if (NILP (result))
- result = Fassq (parameter, Vdefault_frame_alist);
if (!NILP (result) && !STRINGP (result))
result = XCDR (result);
if (NILP (result) || !STRINGP (result))
doc: /* Create an additional terminal frame, possibly on another terminal.
This function takes one argument, an alist specifying frame parameters.
-You can create multiple frames on a single text-only terminal, but
-only one of them (the selected terminal frame) is actually displayed.
+You can create multiple frames on a single text terminal, but only one
+of them (the selected terminal frame) is actually displayed.
In practice, generally you don't need to specify any parameters,
except when you want to create a new frame on another terminal.
Note that changing the size of one terminal frame automatically
affects all frames on the same terminal device. */)
- (parms)
- Lisp_Object parms;
+ (Lisp_Object parms)
{
struct frame *f;
struct terminal *t = NULL;
#ifdef MSDOS
if (sf->output_method != output_msdos_raw
&& sf->output_method != output_termcap)
- abort ();
+ emacs_abort ();
#else /* not MSDOS */
#ifdef WINDOWSNT /* This should work now! */
Lisp_Object terminal;
terminal = Fassq (Qterminal, parms);
- if (!NILP (terminal))
+ if (CONSP (terminal))
{
terminal = XCDR (terminal);
t = get_terminal (terminal, 1);
? FRAME_TTY (XFRAME (selected_frame))->name
: NULL));
if (!NILP (tty))
- {
- name = (char *) alloca (SBYTES (tty) + 1);
- strncpy (name, SDATA (tty), SBYTES (tty));
- name[SBYTES (tty)] = 0;
- }
+ name = xlispstrdupa (tty);
tty_type = get_future_frame_param
(Qtty_type, parms, (FRAME_TERMCAP_P (XFRAME (selected_frame))
? FRAME_TTY (XFRAME (selected_frame))->type
: NULL));
if (!NILP (tty_type))
- {
- type = (char *) alloca (SBYTES (tty_type) + 1);
- strncpy (type, SDATA (tty_type), SBYTES (tty_type));
- type[SBYTES (tty_type)] = 0;
- }
+ type = xlispstrdupa (tty_type);
- t = init_tty (name, type, 0); /* Errors are not fatal. */
+ t = init_tty (name, type, 0); /* Errors are not fatal. */
}
f = make_terminal_frame (t);
change_frame_size (f, height, width, 0, 0, 0);
}
- adjust_glyphs (f);
+ adjust_frame_glyphs (f);
calculate_costs (f);
XSETFRAME (frame, f);
- Fmodify_frame_parameters (frame, Vdefault_frame_alist);
+
+ store_in_alist (&parms, Qtty_type, build_string (t->display_info.tty->type));
+ store_in_alist (&parms, Qtty,
+ (t->display_info.tty->name
+ ? build_string (t->display_info.tty->name)
+ : Qnil));
Fmodify_frame_parameters (frame, parms);
- Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty_type,
- build_string (t->display_info.tty->type)),
- Qnil));
- if (t->display_info.tty->name != NULL)
- Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty,
- build_string (t->display_info.tty->name)),
- Qnil));
- else
- Fmodify_frame_parameters (frame, Fcons (Fcons (Qtty, Qnil), Qnil));
/* 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);
+ fset_face_alist (f, 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. */
The value of NORECORD is passed as argument to Fselect_window. */
Lisp_Object
-do_switch_frame (frame, track, for_deletion, norecord)
- Lisp_Object frame, norecord;
- int track, for_deletion;
+do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object norecord)
{
struct frame *sf = SELECTED_FRAME ();
Lisp_Object focus;
if (!FRAMEP (XCAR (tail)))
- abort ();
+ emacs_abort ();
focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
if (FRAME_TERMCAP_P (XFRAME (frame)) || FRAME_MSDOS_P (XFRAME (frame)))
{
- if (FRAMEP (FRAME_TTY (XFRAME (frame))->top_frame))
- /* Mark previously displayed frame as now obscured. */
- XFRAME (FRAME_TTY (XFRAME (frame))->top_frame)->async_visible = 2;
- XFRAME (frame)->async_visible = 1;
+ Lisp_Object top_frame = FRAME_TTY (XFRAME (frame))->top_frame;
+
+ /* Don't mark the frame garbaged and/or obscured if we are
+ switching to the frame that is already the top frame of that
+ TTY. */
+ if (!EQ (frame, top_frame))
+ {
+ if (FRAMEP (top_frame))
+ /* Mark previously displayed frame as now obscured. */
+ SET_FRAME_VISIBLE (XFRAME (top_frame), 2);
+ SET_FRAME_VISIBLE (XFRAME (frame), 1);
+ }
FRAME_TTY (XFRAME (frame))->top_frame = frame;
}
this function is called. If you are using a window system, the
previously selected frame may be restored as the selected frame
when returning to the command loop, because it still may have
-the window system's input focus. On a text-only terminal, the
-next redisplay will display FRAME.
+the window system's input focus. On a text terminal, the next
+redisplay will display FRAME.
This function returns FRAME, or nil if FRAME has been deleted. */)
- (frame, norecord)
- Lisp_Object frame, norecord;
+ (Lisp_Object frame, Lisp_Object norecord)
{
return do_switch_frame (frame, 1, 0, norecord);
}
+DEFUN ("handle-focus-in", Fhandle_focus_in, Shandle_focus_in, 1, 1, "e",
+ doc: /* Handle a focus-in event.
+Focus in events are usually bound to this function.
+Focus in events occur when a frame has focus, but a switch-frame event
+is not generated.
+This function checks if blink-cursor timers should be turned on again. */)
+ (Lisp_Object event)
+{
+ return call0 (intern ("blink-cursor-check"));
+}
+
+DEFUN ("handle-focus-out", Fhandle_focus_out, Shandle_focus_out, 1, 1, "e",
+ doc: /* Handle a focus-out event.
+Focus out events are usually bound to this function.
+Focus out events occur when no frame has focus.
+This function checks if blink-cursor timers should be turned off. */)
+ (Lisp_Object event)
+{
+ return call0 (intern ("blink-cursor-suspend"));
+}
DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
doc: /* Handle a switch-frame event EVENT.
If EVENT is frame object, handle it as if it were a switch-frame event
to that frame. */)
- (event)
- Lisp_Object event;
+ (Lisp_Object event)
{
/* Preserve prefix arg that the command loop just cleared. */
- current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
- call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
+ kset_prefix_arg (current_kboard, Vcurrent_prefix_arg);
+ Frun_hooks (1, &Qmouse_leave_buffer_hook);
+ Fhandle_focus_in (event); // switch-frame implies a focus in.
return do_switch_frame (event, 0, 0, Qnil);
}
DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
doc: /* Return the frame that is now selected. */)
- ()
+ (void)
{
return selected_frame;
}
\f
-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.
-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, 3, 0,
- doc: /* Set selected window of FRAME to WINDOW.
-If FRAME is nil, use the selected frame. If FRAME is the
-selected frame, this makes WINDOW the selected window.
-Optional argument NORECORD non-nil means to neither change the
-order of recently selected windows nor the buffer list.
-Return WINDOW. */)
- (frame, window, norecord)
- Lisp_Object frame, window, norecord;
-{
- 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, norecord);
-
- return XFRAME (frame)->selected_window = window;
-}
-
-\f
DEFUN ("frame-list", Fframe_list, Sframe_list,
0, 0, 0,
doc: /* Return a list of all live frames. */)
- ()
+ (void)
{
Lisp_Object frames;
frames = Fcopy_sequence (Vframe_list);
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. */
+/* Return CANDIDATE if it can be used as 'other-than-FRAME' frame on the
+ same tty (for tty frames) or among frames which uses FRAME's keyboard.
+ If MINIBUF is nil, do not consider minibuffer-only candidate.
+ If MINIBUF is `visible', do not consider an invisible candidate.
+ If MINIBUF is a window, consider only its own frame and candidate now
+ using that window as the minibuffer.
+ If MINIBUF is 0, consider candidate if it is visible or iconified.
+ Otherwise consider any candidate and return nil if CANDIDATE is not
+ acceptable. */
static Lisp_Object
-next_frame (frame, minibuf)
- Lisp_Object frame;
- Lisp_Object minibuf;
+candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
{
- Lisp_Object tail;
- int passed = 0;
+ struct frame *c = XFRAME (candidate), *f = XFRAME (frame);
- /* There must always be at least one frame in Vframe_list. */
- if (! CONSP (Vframe_list))
- abort ();
+ if ((!FRAME_TERMCAP_P (c) && !FRAME_TERMCAP_P (f)
+ && FRAME_KBOARD (c) == FRAME_KBOARD (f))
+ || (FRAME_TERMCAP_P (c) && FRAME_TERMCAP_P (f)
+ && FRAME_TTY (c) == FRAME_TTY (f)))
+ {
+ if (NILP (minibuf))
+ {
+ if (!FRAME_MINIBUF_ONLY_P (c))
+ return candidate;
+ }
+ else if (EQ (minibuf, Qvisible))
+ {
+ if (FRAME_VISIBLE_P (c))
+ return candidate;
+ }
+ else if (WINDOWP (minibuf))
+ {
+ if (EQ (FRAME_MINIBUF_WINDOW (c), minibuf)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)), candidate)
+ || EQ (WINDOW_FRAME (XWINDOW (minibuf)),
+ FRAME_FOCUS_FRAME (c)))
+ return candidate;
+ }
+ else if (XFASTINT (minibuf) == 0)
+ {
+ if (FRAME_VISIBLE_P (c) || FRAME_ICONIFIED_P (c))
+ return candidate;
+ }
+ else
+ return candidate;
+ }
+ return Qnil;
+}
- /* If this frame is dead, it won't be in Vframe_list, and we'll loop
- forever. Forestall that. */
- CHECK_LIVE_FRAME (frame);
+/* Return the next frame in the frame list after FRAME. */
- while (1)
- for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
- {
- Lisp_Object f;
+static Lisp_Object
+next_frame (Lisp_Object frame, Lisp_Object minibuf)
+{
+ Lisp_Object f, tail;
+ int passed = 0;
- f = XCAR (tail);
+ /* There must always be at least one frame in Vframe_list. */
+ eassert (CONSP (Vframe_list));
- if (passed
- && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
- && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
- || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
- && FRAME_TTY (XFRAME (f)) == FRAME_TTY (XFRAME (frame)))))
+ while (passed < 2)
+ FOR_EACH_FRAME (tail, f)
+ {
+ if (passed)
{
- /* 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
+ f = candidate_frame (f, frame, minibuf);
+ if (!NILP (f))
return f;
}
-
if (EQ (frame, f))
passed++;
}
+ return frame;
}
-/* 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. */
+/* Return the previous frame in the frame list before FRAME. */
static Lisp_Object
-prev_frame (frame, minibuf)
- Lisp_Object frame;
- Lisp_Object minibuf;
+prev_frame (Lisp_Object frame, Lisp_Object minibuf)
{
- Lisp_Object tail;
- Lisp_Object prev;
+ Lisp_Object f, tail, prev = Qnil;
/* There must always be at least one frame in Vframe_list. */
- if (! CONSP (Vframe_list))
- abort ();
+ eassert (CONSP (Vframe_list));
- prev = Qnil;
- for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+ FOR_EACH_FRAME (tail, f)
{
- Lisp_Object f;
-
- f = XCAR (tail);
- if (!FRAMEP (f))
- abort ();
-
if (EQ (frame, f) && !NILP (prev))
return prev;
-
- if ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
- && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
- || (FRAME_TERMCAP_P (XFRAME (f)) && FRAME_TERMCAP_P (XFRAME (frame))
- && FRAME_TTY (XFRAME (f)) == FRAME_TTY (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;
- }
+ f = candidate_frame (f, frame, minibuf);
+ if (!NILP (f))
+ prev = f;
}
/* We've scanned the entire list. */
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;
+ (Lisp_Object frame, Lisp_Object miniframe)
{
if (NILP (frame))
frame = selected_frame;
-
CHECK_LIVE_FRAME (frame);
return next_frame (frame, miniframe);
}
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;
+ (Lisp_Object frame, Lisp_Object miniframe)
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
return prev_frame (frame, miniframe);
}
+
+DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
+ Slast_nonminibuf_frame, 0, 0, 0,
+ doc: /* Return last non-minibuffer frame selected. */)
+ (void)
+{
+ Lisp_Object frame = Qnil;
+
+ if (last_nonminibuf_frame)
+ XSETFRAME (frame, last_nonminibuf_frame);
+
+ return frame;
+}
\f
/* 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;
+static int
+other_visible_frames (struct frame *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;
+ Lisp_Object frames, this;
- for (frames = Vframe_list;
- CONSP (frames);
- frames = XCDR (frames))
- {
- Lisp_Object this;
+ FOR_EACH_FRAME (frames, this)
+ {
+ if (f == XFRAME (this))
+ continue;
- 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));
- }
+ /* Verify that we can still talk to the frame's X window,
+ and note any recent change in visibility. */
+#ifdef HAVE_X_WINDOWS
+ if (FRAME_WINDOW_P (XFRAME (this)))
+ x_sync (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;
+ 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)))
+ return 1;
}
- return 1;
+ return 0;
}
-/* Error handler for `delete-frame-functions'. */
-static Lisp_Object
-delete_frame_handler (Lisp_Object arg)
+/* Make sure that minibuf_window doesn't refer to FRAME's minibuffer
+ window. Preferably use the selected frame's minibuffer window
+ instead. If the selected frame doesn't have one, get some other
+ frame's minibuffer window. SELECT non-zero means select the new
+ minibuffer window. */
+static void
+check_minibuf_window (Lisp_Object frame, int select)
{
- add_to_log ("Error during `delete-frame': %s", arg, Qnil);
- return Qnil;
+ struct frame *f = decode_live_frame (frame);
+
+ XSETFRAME (frame, f);
+
+ if (WINDOWP (minibuf_window) && EQ (f->minibuffer_window, minibuf_window))
+ {
+ Lisp_Object frames, this, window = make_number (0);
+
+ if (!EQ (frame, selected_frame)
+ && FRAME_HAS_MINIBUF_P (XFRAME (selected_frame)))
+ window = FRAME_MINIBUF_WINDOW (XFRAME (selected_frame));
+ else
+ FOR_EACH_FRAME (frames, this)
+ {
+ if (!EQ (this, frame) && FRAME_HAS_MINIBUF_P (XFRAME (this)))
+ {
+ window = FRAME_MINIBUF_WINDOW (XFRAME (this));
+ break;
+ }
+ }
+
+ /* Don't abort if no window was found (Bug#15247). */
+ if (WINDOWP (window))
+ {
+ /* Use set_window_buffer instead of Fset_window_buffer (see
+ discussion of bug#11984, bug#12025, bug#12026). */
+ set_window_buffer (window, XWINDOW (minibuf_window)->contents, 0, 0);
+ minibuf_window = window;
+
+ /* SELECT non-zero usually means that FRAME's minibuffer
+ window was selected; select the new one. */
+ if (select)
+ Fselect_window (minibuf_window, Qnil);
+ }
+ }
}
-extern Lisp_Object Qrun_hook_with_args;
/* Delete FRAME. When FORCE equals Qnoelisp, delete FRAME
unconditionally. x_connection_closed and delete_terminal use
this. Any other value of FORCE implements the semantics
described for Fdelete_frame. */
Lisp_Object
-delete_frame (frame, force)
- /* If we use `register' here, gcc-4.0.2 on amd64 using
- -DUSE_LISP_UNION_TYPE complains further down that we're getting the
- address of `force'. Go figure. */
- Lisp_Object frame, force;
+delete_frame (Lisp_Object frame, Lisp_Object force)
{
- struct frame *f;
+ struct frame *f = decode_any_frame (frame);
struct frame *sf = SELECTED_FRAME ();
struct kboard *kb;
- int minibuffer_selected, tooltip_frame;
-
- if (EQ (frame, Qnil))
- {
- f = sf;
- XSETFRAME (frame, f);
- }
- else
- {
- CHECK_FRAME (frame);
- f = XFRAME (frame);
- }
+ int minibuffer_selected, is_tooltip_frame;
if (! FRAME_LIVE_P (f))
return Qnil;
if (NILP (XCDR (Vframe_list)) && !EQ (force, Qnoelisp))
error ("Attempt to delete the only frame");
+ XSETFRAME (frame, f);
+
/* Does this frame have a minibuffer, and is it the surrogate
minibuffer for any other frame? */
- if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
+ if (FRAME_HAS_MINIBUF_P (f))
{
- Lisp_Object frames;
+ Lisp_Object frames, this;
- for (frames = Vframe_list;
- CONSP (frames);
- frames = XCDR (frames))
+ FOR_EACH_FRAME (frames, this)
{
- Lisp_Object this;
- this = XCAR (frames);
+ Lisp_Object fminiw;
+
+ if (EQ (this, frame))
+ continue;
+
+ fminiw = FRAME_MINIBUF_WINDOW (XFRAME (this));
- if (! EQ (this, frame)
- && EQ (frame,
- WINDOW_FRAME (XWINDOW
- (FRAME_MINIBUF_WINDOW (XFRAME (this))))))
+ if (WINDOWP (fminiw) && EQ (frame, WINDOW_FRAME (XWINDOW (fminiw))))
{
/* If we MUST delete this frame, delete the other first.
But do this only if FORCE equals `noelisp'. */
}
}
- tooltip_frame = !NILP (Fframe_parameter (frame, intern ("tooltip")));
+ is_tooltip_frame = !NILP (Fframe_parameter (frame, intern ("tooltip")));
/* Run `delete-frame-functions' unless FORCE is `noelisp' or
frame is a tooltip. FORCE is set to `noelisp' when handling
a disconnect from the terminal, so we don't dare call Lisp
code. */
- if (NILP (Vrun_hooks) || tooltip_frame)
+ if (NILP (Vrun_hooks) || is_tooltip_frame)
;
else if (EQ (force, Qnoelisp))
pending_funcalls
= Fcons (list3 (Qrun_hook_with_args, Qdelete_frame_functions, frame),
pending_funcalls);
else
- safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
+ {
+#ifdef HAVE_X_WINDOWS
+ /* Also, save clipboard to the clipboard manager. */
+ x_clipboard_manager_save_frame (frame);
+#endif
+
+ safe_call2 (Qrun_hook_with_args, Qdelete_frame_functions, frame);
+ }
/* The hook may sometimes (indirectly) cause the frame to be deleted. */
if (! FRAME_LIVE_P (f))
/* 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);
+ Lisp_Object tail;
+ Lisp_Object frame1 = Qnil;
+
+ /* Look for another visible frame on the same terminal.
+ Do not call next_frame here because it may loop forever.
+ See http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15025. */
+ FOR_EACH_FRAME (tail, frame1)
+ if (!EQ (frame, frame1)
+ && (FRAME_TERMINAL (XFRAME (frame))
+ == FRAME_TERMINAL (XFRAME (frame1)))
+ && FRAME_VISIBLE_P (XFRAME (frame1)))
+ break;
/* If there is none, find *some* other frame. */
if (NILP (frame1) || EQ (frame1, frame))
FOR_EACH_FRAME (tail, frame1)
{
if (! EQ (frame, frame1) && FRAME_LIVE_P (XFRAME (frame1)))
- break;
+ {
+ /* Do not change a text terminal's top-frame. */
+ struct frame *f1 = XFRAME (frame1);
+ if (FRAME_TERMCAP_P (f1) || FRAME_MSDOS_P (f1))
+ {
+ Lisp_Object top_frame = FRAME_TTY (f1)->top_frame;
+ if (!EQ (top_frame, frame))
+ frame1 = top_frame;
+ }
+ break;
+ }
}
}
#ifdef NS_IMPL_COCOA
}
/* 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);
- }
+ check_minibuf_window (frame, minibuffer_selected);
/* Don't let echo_area_window to remain on a deleted frame. */
if (EQ (f->minibuffer_window, echo_area_window))
/* 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;
+ delete_all_child_windows (f->root_window);
+ fset_root_window (f, Qnil);
Vframe_list = Fdelq (frame, Vframe_list);
- FRAME_SET_VISIBLE (f, 0);
+ SET_FRAME_VISIBLE (f, 0);
/* Allow the vector of menu bar contents to be freed in the next
garbage collection. The frame object itself may not be garbage
collected until much later, because recent_keys and other data
structures can still refer to it. */
- f->menu_bar_vector = Qnil;
+ fset_menu_bar_vector (f, Qnil);
+
+ /* If FRAME's buffer lists contains killed
+ buffers, this helps GC to reclaim them. */
+ fset_buffer_list (f, Qnil);
+ fset_buried_buffer_list (f, Qnil);
free_font_driver_list (f);
xfree (f->namebuf);
xfree (FRAME_DELETEN_COST (f));
xfree (FRAME_INSERTN_COST (f));
xfree (FRAME_DELETE_COST (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 terminal
{
struct terminal *terminal = FRAME_TERMINAL (f);
f->output_data.nothing = 0;
- f->terminal = 0; /* Now the frame is dead. */
+ f->terminal = 0; /* Now the frame is dead. */
/* If needed, delete the terminal that this frame was on.
- (This must be done after the frame is killed.) */
+ (This must be done after the frame is killed.) */
terminal->reference_count--;
+#ifdef USE_GTK
+ /* FIXME: Deleting the terminal crashes emacs because of a GTK
+ bug.
+ http://lists.gnu.org/archive/html/emacs-devel/2011-10/msg00363.html */
+ if (terminal->reference_count == 0 && terminal->type == output_x_window)
+ terminal->reference_count = 1;
+#endif /* USE_GTK */
if (terminal->reference_count == 0)
{
Lisp_Object tmp;
another one. */
if (f == last_nonminibuf_frame)
{
- Lisp_Object frames;
+ Lisp_Object frames, this;
last_nonminibuf_frame = 0;
- for (frames = Vframe_list;
- CONSP (frames);
- frames = XCDR (frames))
+ FOR_EACH_FRAME (frames, this)
{
- f = XFRAME (XCAR (frames));
+ f = XFRAME (this);
if (!FRAME_MINIBUF_ONLY_P (f))
{
last_nonminibuf_frame = f;
single-kboard state if we're in it for this kboard. */
if (kb != NULL)
{
- Lisp_Object frames;
+ Lisp_Object frames, this;
/* Some frame we found on the same kboard, or nil if there are none. */
- Lisp_Object frame_on_same_kboard;
+ Lisp_Object frame_on_same_kboard = Qnil;
- frame_on_same_kboard = 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);
-
- if (kb == FRAME_KBOARD (f1))
- frame_on_same_kboard = this;
- }
+ FOR_EACH_FRAME (frames, this)
+ if (kb == FRAME_KBOARD (XFRAME (this)))
+ frame_on_same_kboard = this;
if (NILP (frame_on_same_kboard))
not_single_kboard_state (kb);
/* 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 (kb != NULL && EQ (frame, kb->Vdefault_minibuffer_frame))
+ if (kb != NULL && EQ (frame, KVAR (kb, Vdefault_minibuffer_frame)))
{
- Lisp_Object frames;
+ Lisp_Object frames, this;
/* The last frame we saw with a minibuffer, minibuffer-only or not. */
- Lisp_Object frame_with_minibuf;
+ Lisp_Object frame_with_minibuf = Qnil;
/* 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;
+ Lisp_Object frame_on_same_kboard = Qnil;
- for (frames = Vframe_list;
- CONSP (frames);
- frames = XCDR (frames))
+ FOR_EACH_FRAME (frames, this)
{
- Lisp_Object this;
- struct frame *f1;
-
- this = XCAR (frames);
- if (!FRAMEP (this))
- abort ();
- f1 = XFRAME (this);
+ struct frame *f1 = XFRAME (this);
/* Consider only frames on the same kboard
and only those with minibuffers. */
that is prohibited at the top; you can't delete surrogate
minibuffer frames. */
if (NILP (frame_with_minibuf))
- abort ();
+ emacs_abort ();
- kb->Vdefault_minibuffer_frame = frame_with_minibuf;
+ kset_default_minibuffer_frame (kb, frame_with_minibuf);
}
else
/* No frames left on this kboard--say no minibuffer either. */
- kb->Vdefault_minibuffer_frame = Qnil;
+ kset_default_minibuffer_frame (kb, Qnil);
}
/* Cause frame titles to update--necessary if we now have just one frame. */
- if (!tooltip_frame)
+ if (!is_tooltip_frame)
update_mode_lines = 1;
return Qnil;
This function runs `delete-frame-functions' before actually
deleting the frame, unless the frame is a tooltip.
The functions are run with one argument, the frame to be deleted. */)
- (frame, force)
- Lisp_Object frame, force;
+ (Lisp_Object frame, Lisp_Object force)
{
return delete_frame (frame, !NILP (force) ? Qt : Qnil);
}
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. */)
- ()
+ (void)
{
- FRAME_PTR f;
+ struct frame *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;
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
/* It's okay for the hook to refrain from storing anything. */
if (FRAME_TERMINAL (f)->mouse_position_hook)
- (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
- &lispy_dummy, &party_dummy,
- &x, &y,
- &long_dummy);
+ {
+ enum scroll_bar_part party_dummy;
+ Time time_dummy;
+ (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
+ &lispy_dummy, &party_dummy,
+ &x, &y,
+ &time_dummy);
+ }
+
if (! NILP (x))
{
- col = XINT (x);
- row = XINT (y);
+ int col = XINT (x);
+ int 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 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. */)
- ()
+ (void)
{
- FRAME_PTR f;
+ struct frame *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;
-#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
/* It's okay for the hook to refrain from storing anything. */
if (FRAME_TERMINAL (f)->mouse_position_hook)
- (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
- &lispy_dummy, &party_dummy,
- &x, &y,
- &long_dummy);
-#endif
+ {
+ enum scroll_bar_part party_dummy;
+ Time time_dummy;
+ (*FRAME_TERMINAL (f)->mouse_position_hook) (&f, -1,
+ &lispy_dummy, &party_dummy,
+ &x, &y,
+ &time_dummy);
+ }
+
XSETFRAME (lispy_dummy, f);
return Fcons (lispy_dummy, Fcons (x, y));
}
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;
+ (Lisp_Object frame, Lisp_Object x, Lisp_Object y)
{
CHECK_LIVE_FRAME (frame);
- CHECK_NUMBER (x);
- CHECK_NUMBER (y);
+ CHECK_TYPE_RANGED_INTEGER (int, x);
+ CHECK_TYPE_RANGED_INTEGER (int, y);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
/* 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 defined (MSDOS)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame, Qnil);
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;
+ (Lisp_Object frame, Lisp_Object x, Lisp_Object y)
{
CHECK_LIVE_FRAME (frame);
- CHECK_NUMBER (x);
- CHECK_NUMBER (y);
+ CHECK_TYPE_RANGED_INTEGER (int, x);
+ CHECK_TYPE_RANGED_INTEGER (int, y);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
/* 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 defined (MSDOS)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame, Qnil);
return Qnil;
}
\f
-static void make_frame_visible_1 P_ ((Lisp_Object));
+static void make_frame_visible_1 (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;
+ (Lisp_Object frame)
{
- if (NILP (frame))
- frame = selected_frame;
-
- CHECK_LIVE_FRAME (frame);
+ struct frame *f = decode_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));
- }
+ if (FRAME_WINDOW_P (f))
+ x_make_frame_visible (f);
#endif
- make_frame_visible_1 (XFRAME (frame)->root_window);
+ make_frame_visible_1 (f->root_window);
/* Make menu bar update for the Buffers and Frames menus. */
windows_or_buffers_changed++;
+ XSETFRAME (frame, f);
return frame;
}
/* Update the display_time slot of the buffers shown in WINDOW
- and all its descendents. */
+ and all its descendants. */
static void
-make_frame_visible_1 (window)
- Lisp_Object window;
+make_frame_visible_1 (Lisp_Object window)
{
struct window *w;
- for (;!NILP (window); window = w->next)
+ 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);
+ if (WINDOWP (w->contents))
+ make_frame_visible_1 (w->contents);
+ else
+ bset_display_time (XBUFFER (w->contents), Fcurrent_time ());
}
}
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.
-This function has no effect on text-only terminal frames. Such frames
-are always considered visible, whether or not they are currently being
+This function has no effect on text terminal frames. Such frames are
+always considered visible, whether or not they are currently being
displayed in the terminal. */)
- (frame, force)
- Lisp_Object frame, force;
+ (Lisp_Object frame, Lisp_Object force)
{
- if (NILP (frame))
- frame = selected_frame;
-
- CHECK_LIVE_FRAME (frame);
+ struct frame *f = decode_live_frame (frame);
- if (NILP (force) && !other_visible_frames (XFRAME (frame)))
+ if (NILP (force) && !other_visible_frames (f))
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, 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;
- }
+ /* Don't allow minibuf_window to remain on an invisible frame. */
+ check_minibuf_window (frame, EQ (minibuf_window, selected_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));
+ if (FRAME_WINDOW_P (f))
+ x_make_frame_invisible (f);
#endif
/* Make menu bar update for the Buffers and Frames menus. */
0, 1, "",
doc: /* Make the frame FRAME into an icon.
If omitted, FRAME defaults to the currently selected frame. */)
- (frame)
- Lisp_Object 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));
-#endif
+ struct frame *f = decode_live_frame (frame);
- /* 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;
- }
+ /* Don't allow minibuf_window to remain on an iconified frame. */
+ check_minibuf_window (frame, EQ (minibuf_window, selected_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));
+ if (FRAME_WINDOW_P (f))
+ x_iconify_frame (f);
#endif
/* Make menu bar update for the Buffers and Frames menus. */
On graphical displays, invisible frames are not updated and are
usually not displayed at all, even in a window system's \"taskbar\".
-If FRAME is a text-only terminal frame, this always returns t.
+If FRAME is a text terminal frame, this always returns t.
Such frames are always considered visible, whether or not they are
currently being displayed on the terminal. */)
- (frame)
- Lisp_Object 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)))
DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
0, 0, 0,
doc: /* Return a list of all frames now \"visible\" (being updated). */)
- ()
+ (void)
{
- Lisp_Object tail, frame;
- struct frame *f;
- Lisp_Object value;
+ Lisp_Object tail, frame, value = Qnil;
+
+ FOR_EACH_FRAME (tail, frame)
+ if (FRAME_VISIBLE_P (XFRAME (frame)))
+ value = Fcons (frame, 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;
}
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 selects FRAME. */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
- struct frame *f;
- if (NILP (frame))
- frame = selected_frame;
-
- CHECK_LIVE_FRAME (frame);
+ struct frame *f = decode_live_frame (frame);
- f = XFRAME (frame);
+ XSETFRAME (frame, f);
if (FRAME_TERMCAP_P (f))
- /* On a text-only terminal select FRAME. */
+ /* On a text terminal select FRAME. */
Fselect_frame (frame, Qnil);
else
/* Do like the documentation says. */
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;
+ (Lisp_Object frame)
{
- struct frame *f;
-
- if (NILP (frame))
- frame = selected_frame;
-
- CHECK_LIVE_FRAME (frame);
-
- f = XFRAME (frame);
+ struct frame *f = decode_live_frame (frame);
if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
(*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
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.
+If FOCUS-FRAME is nil, any existing redirection is canceled, 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
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;
+ (Lisp_Object frame, Lisp_Object focus_frame)
{
- struct frame *f;
-
/* 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);
+ struct frame *f = decode_any_frame (frame);
if (! NILP (focus_frame))
CHECK_LIVE_FRAME (focus_frame);
- f = XFRAME (frame);
-
- f->focus_frame = focus_frame;
+ fset_focus_frame (f, focus_frame);
if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
(*FRAME_TERMINAL (f)->frame_rehighlight_hook) (f);
}
-DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
+DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 0, 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.
+If FRAME is omitted or nil, the selected frame is used.
+Return nil if FRAME's focus is not redirected.
See `redirect-frame-focus'. */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
- CHECK_LIVE_FRAME (frame);
-
- return FRAME_FOCUS_FRAME (XFRAME (frame));
+ return FRAME_FOCUS_FRAME (decode_live_frame (frame));
}
+DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
+ doc: /* Set the input focus to FRAME.
+FRAME nil means use the selected frame.
+If there is no window system support, this function does nothing. */)
+ (Lisp_Object frame)
+{
+#ifdef HAVE_WINDOW_SYSTEM
+ x_focus_frame (decode_window_system_frame (frame));
+#endif
+ return Qnil;
+}
\f
/* Return the value of frame parameter PROP in frame FRAME. */
+#ifdef HAVE_WINDOW_SYSTEM
+#if !HAVE_NS && !defined (WINDOWSNT)
+static
+#endif
Lisp_Object
-get_frame_param (frame, prop)
- register struct frame *frame;
- Lisp_Object prop;
+get_frame_param (register struct frame *frame, Lisp_Object prop)
{
register Lisp_Object tem;
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;
-}
+#endif
/* Discard BUFFER from the buffer-list and buried-buffer-list of each frame. */
void
-frames_discard_buffer (buffer)
- Lisp_Object buffer;
+frames_discard_buffer (Lisp_Object buffer)
{
Lisp_Object frame, tail;
FOR_EACH_FRAME (tail, frame)
{
- XFRAME (frame)->buffer_list
- = Fdelq (buffer, XFRAME (frame)->buffer_list);
- XFRAME (frame)->buried_buffer_list
- = Fdelq (buffer, XFRAME (frame)->buried_buffer_list);
+ fset_buffer_list
+ (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buffer_list));
+ fset_buried_buffer_list
+ (XFRAME (frame), Fdelq (buffer, XFRAME (frame)->buried_buffer_list));
}
}
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;
+store_in_alist (Lisp_Object *alistptr, Lisp_Object prop, Lisp_Object val)
{
register Lisp_Object tem;
}
static int
-frame_name_fnn_p (str, len)
- char *str;
- EMACS_INT len;
+frame_name_fnn_p (char *str, ptrdiff_t len)
{
- if (len > 1 && str[0] == 'F')
+ if (len > 1 && str[0] == 'F' && '0' <= str[1] && str[1] <= '9')
{
- char *end_ptr;
-
- strtol (str + 1, &end_ptr, 10);
-
- if (end_ptr == str + len)
+ char *p = str + 2;
+ while ('0' <= *p && *p <= '9')
+ p++;
+ if (p == str + len)
return 1;
}
return 0;
Modeled after x_set_name which is used for WINDOW frames. */
static void
-set_term_frame_name (f, name)
- struct frame *f;
- Lisp_Object name;
+set_term_frame_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];
+ char namebuf[sizeof "F" + INT_STRLEN_BOUND (printmax_t)];
/* 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)))
+ if (frame_name_fnn_p (SSDATA (f->name), SBYTES (f->name)))
return;
- tty_frame_count++;
- sprintf (namebuf, "F%d", tty_frame_count);
- name = build_string (namebuf);
+ name = make_formatted_string (namebuf, "F%"pMd, ++tty_frame_count);
}
else
{
/* 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)))
+ if (frame_name_fnn_p (SSDATA (name), SBYTES (name)))
error ("Frame names of the form F<num> are usurped by Emacs");
}
- f->name = name;
+ fset_name (f, name);
update_mode_lines = 1;
}
void
-store_frame_param (f, prop, val)
- struct frame *f;
- Lisp_Object prop, val;
+store_frame_param (struct frame *f, Lisp_Object prop, Lisp_Object val)
{
register Lisp_Object old_alist_elt;
/* The buffer-list parameters are stored in a special place and not
- in the alist. */
+ in the alist. All buffers must be live. */
if (EQ (prop, Qbuffer_list))
{
- f->buffer_list = val;
+ Lisp_Object list = Qnil;
+ for (; CONSP (val); val = XCDR (val))
+ if (!NILP (Fbuffer_live_p (XCAR (val))))
+ list = Fcons (XCAR (val), list);
+ fset_buffer_list (f, Fnreverse (list));
return;
}
if (EQ (prop, Qburied_buffer_list))
{
- f->buried_buffer_list = val;
+ Lisp_Object list = Qnil;
+ for (; CONSP (val); val = XCDR (val))
+ if (!NILP (Fbuffer_live_p (XCAR (val))))
+ list = Fcons (XCAR (val), list);
+ fset_buried_buffer_list (f, Fnreverse (list));
return;
}
without messing up the symbol's status. */
if (SYMBOLP (prop))
{
- Lisp_Object valcontents;
- valcontents = SYMBOL_VALUE (prop);
- if ((BUFFER_LOCAL_VALUEP (valcontents))
- && XBUFFER_LOCAL_VALUE (valcontents)->check_frame
- && XBUFFER_LOCAL_VALUE (valcontents)->found_for_frame
- && XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame) == f)
- swap_in_global_binding (prop);
+ struct Lisp_Symbol *sym = XSYMBOL (prop);
+ start:
+ switch (sym->redirect)
+ {
+ case SYMBOL_VARALIAS: sym = indirect_variable (sym); goto start;
+ case SYMBOL_PLAINVAL: case SYMBOL_FORWARDED: break;
+ case SYMBOL_LOCALIZED:
+ { struct Lisp_Buffer_Local_Value *blv = sym->val.blv;
+ if (blv->frame_local && blv_found (blv) && XFRAME (blv->where) == f)
+ swap_in_global_binding (sym);
+ break;
+ }
+ default: emacs_abort ();
+ }
}
/* The tty color needed to be set before the frame's parameter
/* 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);
+ fset_param_alist (f, Fcons (Fcons (prop, val), f->param_alist));
else
Fsetcdr (old_alist_elt, val);
in addition to the alist. */
if (EQ (prop, Qbuffer_predicate))
- f->buffer_predicate = val;
+ fset_buffer_predicate (f, val);
if (! FRAME_WINDOW_P (f))
{
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;
+ fset_minibuffer_window (f, val);
}
}
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;
+If FRAME is omitted or nil, return information on the currently selected frame. */)
+ (Lisp_Object frame)
{
Lisp_Object alist;
- FRAME_PTR f;
+ struct frame *f = decode_any_frame (frame);
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;
elt = Fassq (Qforeground_color, alist);
if (CONSP (elt) && STRINGP (XCDR (elt)))
{
- if (strncmp (SDATA (XCDR (elt)),
+ if (strncmp (SSDATA (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)),
+ else if (strncmp (SSDATA (XCDR (elt)),
unspecified_fg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
elt = Fassq (Qbackground_color, alist);
if (CONSP (elt) && STRINGP (XCDR (elt)))
{
- if (strncmp (SDATA (XCDR (elt)),
+ if (strncmp (SSDATA (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)),
+ else if (strncmp (SSDATA (XCDR (elt)),
unspecified_bg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
: 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));
- store_in_alist (&alist, Qburied_buffer_list, XFRAME (frame)->buried_buffer_list);
+ store_in_alist (&alist, Qbuffer_list, f->buffer_list);
+ store_in_alist (&alist, Qburied_buffer_list, f->buried_buffer_list);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
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;
+ (Lisp_Object frame, Lisp_Object parameter)
{
- struct frame *f;
- Lisp_Object value;
+ struct frame *f = decode_any_frame (frame);
+ Lisp_Object value = Qnil;
- if (NILP (frame))
- frame = selected_frame;
- else
- CHECK_FRAME (frame);
CHECK_SYMBOL (parameter);
- f = XFRAME (frame);
- value = Qnil;
+ XSETFRAME (frame, f);
if (FRAME_LIVE_P (f))
{
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);
+ value = XCAR (FRAME_DISPLAY_INFO (f)->name_list_element);
#endif /* HAVE_X_WINDOWS */
else if (EQ (parameter, Qbackground_color)
|| EQ (parameter, Qforeground_color))
if (STRINGP (value) && !FRAME_WINDOW_P (f))
{
const char *color_name;
- EMACS_INT csz;
+ ptrdiff_t csz;
if (EQ (parameter, Qbackground_color))
{
- color_name = SDATA (value);
+ color_name = SSDATA (value);
csz = SCHARS (value);
if (strncmp (color_name, unspecified_bg, csz) == 0)
value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
}
else if (EQ (parameter, Qforeground_color))
{
- color_name = SDATA (value);
+ color_name = SSDATA (value);
csz = SCHARS (value);
if (strncmp (color_name, unspecified_fg, csz) == 0)
value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
|| EQ (parameter, Qbackground_mode))
value = Fcdr (Fassq (parameter, f->param_alist));
else
+ /* FIXME: Avoid this code path at all (as well as code duplication)
+ by sharing more code with Fframe_parameters. */
value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
}
enabled such bindings for that variable with `make-variable-frame-local'.
Note that this functionality is obsolete as of Emacs 22.2, and its
use is not recommended. Explicitly check for a frame-parameter instead. */)
- (frame, alist)
- Lisp_Object frame, alist;
+ (Lisp_Object frame, Lisp_Object alist)
{
- FRAME_PTR f;
- register Lisp_Object tail, prop, val;
+ struct frame *f = decode_live_frame (frame);
+ register Lisp_Object prop, val;
- if (EQ (frame, Qnil))
- frame = selected_frame;
- CHECK_LIVE_FRAME (frame);
- f = XFRAME (frame);
+ CHECK_LIST (alist);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
#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));
+ EMACS_INT length = XFASTINT (Flength (alist));
+ ptrdiff_t i;
+ Lisp_Object *parms;
+ Lisp_Object *values;
+ USE_SAFE_ALLOCA;
+ SAFE_ALLOCA_LISP (parms, 2 * length);
+ values = parms + length;
/* Extract parm names and values into those vectors. */
- i = 0;
- for (tail = alist; CONSP (tail); tail = XCDR (tail))
+ for (i = 0; CONSP (alist); alist = XCDR (alist))
{
Lisp_Object elt;
- elt = XCAR (tail);
+ elt = XCAR (alist);
parms[i] = Fcar (elt);
values[i] = Fcdr (elt);
i++;
}
/* Now process them in reverse of specified order. */
- for (i--; i >= 0; i--)
+ while (--i >= 0)
{
prop = parms[i];
val = values[i];
|| EQ (prop, Qbackground_color))
update_face_from_frame_parameter (f, prop, val);
}
+
+ SAFE_FREE ();
}
return 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.
+If FRAME is omitted or nil, the selected frame is used.
For a terminal frame, the value is always 1. */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
- struct frame *f;
-
- if (NILP (frame))
- frame = selected_frame;
- CHECK_FRAME (frame);
- f = XFRAME (frame);
-
#ifdef HAVE_WINDOW_SYSTEM
+ struct frame *f = decode_any_frame (frame);
+
if (FRAME_WINDOW_P (f))
- return make_number (x_char_height (f));
+ return make_number (FRAME_LINE_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.
+If FRAME is omitted or nil, the selected frame is used.
On a graphical screen, the width is the standard width of the default font.
For a terminal screen, the value is always 1. */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
- struct frame *f;
-
- if (NILP (frame))
- frame = selected_frame;
- CHECK_FRAME (frame);
- f = XFRAME (frame);
-
#ifdef HAVE_WINDOW_SYSTEM
+ struct frame *f = decode_any_frame (frame);
+
if (FRAME_WINDOW_P (f))
- return make_number (x_char_width (f));
+ return make_number (FRAME_COLUMN_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.
-If FRAME is omitted, the selected frame is used. The exact value
+If FRAME is omitted or nil, the selected frame is used. The exact value
of the result depends on the window-system and toolkit in use:
In the Gtk+ version of Emacs, it includes only any window (including
-the minibuffer or eacho area), mode line, and header line. It does not
+the minibuffer or echo area), mode line, and header line. It does not
include the tool bar or menu bar.
-With the Motif or Lucid toolkits, it also includes the tool bar (but
-not the menu bar).
+With other graphical versions, it also includes the tool bar and the
+menu bar.
-In a graphical version with no toolkit, it includes both the tool bar
-and menu bar.
-
-For a text-only terminal, it includes the menu bar. In this case, the
+For a text terminal, it includes the menu bar. In this case, the
result is really in characters rather than pixels (i.e., is identical
to `frame-height'). */)
- (frame)
- Lisp_Object frame;
+ (Lisp_Object frame)
{
- struct frame *f;
-
- if (NILP (frame))
- frame = selected_frame;
- CHECK_FRAME (frame);
- f = XFRAME (frame);
+ struct frame *f = decode_any_frame (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_pixel_height (f));
+ return make_number (FRAME_PIXEL_HEIGHT (f));
else
#endif
return make_number (FRAME_LINES (f));
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;
+If FRAME is omitted or nil, the selected frame is used. */)
+ (Lisp_Object frame)
{
- struct frame *f;
-
- if (NILP (frame))
- frame = selected_frame;
- CHECK_FRAME (frame);
- f = XFRAME (frame);
+ struct frame *f = decode_any_frame (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
- return make_number (x_pixel_width (f));
+ return make_number (FRAME_PIXEL_WIDTH (f));
else
#endif
return make_number (FRAME_COLS (f));
}
+
+DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
+ Stool_bar_pixel_width, 0, 1, 0,
+ doc: /* Return width in pixels of FRAME's tool bar.
+The result is greater than zero only when the tool bar is on the left
+or right side of FRAME. If FRAME is omitted or nil, the selected frame
+is used. */)
+ (Lisp_Object frame)
+{
+#ifdef FRAME_TOOLBAR_WIDTH
+ struct frame *f = decode_any_frame (frame);
+
+ if (FRAME_WINDOW_P (f))
+ return make_number (FRAME_TOOLBAR_WIDTH (f));
+#endif
+ return make_number (0);
+}
\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;
+If FRAME is nil, the selected frame is used. 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. */)
+ (Lisp_Object frame, Lisp_Object lines, Lisp_Object pretend)
{
- register struct frame *f;
+ register struct frame *f = decode_live_frame (frame);
- CHECK_NUMBER (lines);
- if (NILP (frame))
- frame = selected_frame;
- CHECK_LIVE_FRAME (frame);
- f = XFRAME (frame);
+ CHECK_TYPE_RANGED_INTEGER (int, lines);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
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;
+If FRAME is nil, the selected frame is used. 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. */)
+ (Lisp_Object frame, Lisp_Object cols, Lisp_Object pretend)
{
- register struct frame *f;
- CHECK_NUMBER (cols);
- if (NILP (frame))
- frame = selected_frame;
- CHECK_LIVE_FRAME (frame);
- f = XFRAME (frame);
+ register struct frame *f = decode_live_frame (frame);
+
+ CHECK_TYPE_RANGED_INTEGER (int, cols);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
}
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;
+ doc: /* Sets size of FRAME to COLS by ROWS, measured in characters.
+If FRAME is nil, the selected frame is used. */)
+ (Lisp_Object frame, Lisp_Object cols, Lisp_Object rows)
{
- register struct frame *f;
+ register struct frame *f = decode_live_frame (frame);
- CHECK_LIVE_FRAME (frame);
- CHECK_NUMBER (cols);
- CHECK_NUMBER (rows);
- f = XFRAME (frame);
+ CHECK_TYPE_RANGED_INTEGER (int, cols);
+ CHECK_TYPE_RANGED_INTEGER (int, rows);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
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;
+If FRAME is nil, the selected frame is used. XOFFSET and YOFFSET are
+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). */)
+ (Lisp_Object frame, Lisp_Object xoffset, Lisp_Object yoffset)
{
- register struct frame *f;
+ register struct frame *f = decode_live_frame (frame);
- CHECK_LIVE_FRAME (frame);
- CHECK_NUMBER (xoffset);
- CHECK_NUMBER (yoffset);
- f = XFRAME (frame);
+ CHECK_TYPE_RANGED_INTEGER (int, xoffset);
+ CHECK_TYPE_RANGED_INTEGER (int, yoffset);
/* I think this should be done with a hook. */
#ifdef HAVE_WINDOW_SYSTEM
that is an index in this table. */
struct frame_parm_table {
- char *name;
+ const char *name;
Lisp_Object *variable;
};
-static struct frame_parm_table frame_parms[] =
+static const struct frame_parm_table frame_parms[] =
{
{"auto-raise", &Qauto_raise},
{"auto-lower", &Qauto_lower},
{"font-backend", &Qfont_backend},
{"alpha", &Qalpha},
{"sticky", &Qsticky},
+ {"tool-bar-position", &Qtool_bar_position},
};
-#ifdef HAVE_WINDOW_SYSTEM
-
-extern Lisp_Object Qbox;
-extern Lisp_Object Qtop;
+#ifdef HAVE_NTGUI
/* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
wanted positions of the WM window (not Emacs 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;
+x_fullscreen_adjust (struct frame *f, int *width, int *height, int *top_pos, int *left_pos)
{
int newwidth = FRAME_COLS (f);
int newheight = FRAME_LINES (f);
- Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
*top_pos = f->top_pos;
*left_pos = f->left_pos;
*height = newheight;
}
+#endif /* HAVE_NTGUI */
+
+#ifdef HAVE_WINDOW_SYSTEM
/* Change the parameters of frame F as specified by ALIST.
If a parameter is not specially recognized, do nothing special;
to store the new value in the parameter alist. */
void
-x_set_frame_parameters (f, alist)
- FRAME_PTR f;
- Lisp_Object alist;
+x_set_frame_parameters (struct frame *f, Lisp_Object alist)
{
Lisp_Object tail;
/* 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 size_changed = 0;
+ ptrdiff_t i, p;
+ bool left_no_change = 0, top_no_change = 0;
+ bool icon_left_no_change = 0, icon_top_no_change = 0;
+ bool size_changed = 0;
struct gcpro gcpro1, gcpro2;
i = 0;
- for (tail = alist; CONSP (tail); tail = Fcdr (tail))
+ for (tail = alist; CONSP (tail); tail = XCDR (tail))
i++;
- parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
- values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
+ parms = alloca (i * sizeof *parms);
+ values = alloca (i * sizeof *values);
/* Extract parm names and values into those vectors. */
}
/* Now process them in reverse of specified order. */
- for (i--; i >= 0; i--)
+ while (i-- != 0)
{
Lisp_Object prop, val;
prop = parms[i];
val = values[i];
- if (EQ (prop, Qwidth) && NATNUMP (val))
+ if (EQ (prop, Qwidth) && RANGED_INTEGERP (0, val, INT_MAX))
{
size_changed = 1;
width = XFASTINT (val);
}
- else if (EQ (prop, Qheight) && NATNUMP (val))
+ else if (EQ (prop, Qheight) && RANGED_INTEGERP (0, val, INT_MAX))
{
size_changed = 1;
height = XFASTINT (val);
{
left_no_change = 1;
if (f->left_pos < 0)
- left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
+ left = list2 (Qplus, make_number (f->left_pos));
else
XSETINT (left, f->left_pos);
}
{
top_no_change = 1;
if (f->top_pos < 0)
- top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
+ top = list2 (Qplus, make_number (f->top_pos));
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))
+ if (! TYPE_RANGED_INTEGERP (int, 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))
+ if (! TYPE_RANGED_INTEGERP (int, icon_top))
{
icon_top_no_change = 1;
icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
f->size_hint_flags &= ~ (XNegative | YNegative);
if (EQ (left, Qminus))
f->size_hint_flags |= XNegative;
- else if (INTEGERP (left))
+ else if (TYPE_RANGED_INTEGERP (int, left))
{
leftpos = XINT (left);
if (leftpos < 0)
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
- && INTEGERP (XCAR (XCDR (left))))
+ && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (left)), INT_MAX))
{
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))))
+ && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (left))))
{
leftpos = XINT (XCAR (XCDR (left)));
}
if (EQ (top, Qminus))
f->size_hint_flags |= YNegative;
- else if (INTEGERP (top))
+ else if (TYPE_RANGED_INTEGERP (int, top))
{
toppos = XINT (top);
if (toppos < 0)
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
- && INTEGERP (XCAR (XCDR (top))))
+ && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (top)), INT_MAX))
{
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))))
+ && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (top))))
{
toppos = XINT (XCAR (XCDR (top)));
}
/* Actually set that position, and convert to absolute. */
x_set_offset (f, leftpos, toppos, -1);
}
-
+#ifdef HAVE_X_WINDOWS
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));
+#endif /* HAVE_X_WINDOWS */
}
UNGCPRO;
param_alist need to be considered here. */
void
-x_report_frame_params (f, alistptr)
- struct frame *f;
- Lisp_Object *alistptr;
+x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
{
- char buf[16];
Lisp_Object tem;
+ uprintmax_t w;
+ char buf[INT_BUFSIZE_BOUND (w)];
/* Represent negative positions (off the top or left screen edge)
in a way that Fmodify_frame_parameters will understand correctly. */
if (f->left_pos >= 0)
store_in_alist (alistptr, Qleft, tem);
else
- store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
+ store_in_alist (alistptr, Qleft, list2 (Qplus, tem));
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, Qtop, list2 (Qplus, tem));
store_in_alist (alistptr, Qborder_width,
make_number (f->border_width));
for non-toolkit scroll bar.
ruler-mode.el depends on this. */
: Qnil));
- sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
+ /* FRAME_X_WINDOW is not guaranteed to return an integer. E.g., on
+ MS-Windows it returns a value whose type is HANDLE, which is
+ actually a pointer. Explicit casting avoids compiler
+ warnings. */
+ w = (uintptr_t) FRAME_X_WINDOW (f);
store_in_alist (alistptr, Qwindow_id,
- build_string (buf));
+ make_formatted_string (buf, "%"pMu, w));
#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));
+ w = (uintptr_t) FRAME_OUTER_WINDOW (f);
store_in_alist (alistptr, Qouter_window_id,
- build_string (buf));
+ make_formatted_string (buf, "%"pMu, w));
#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));
+ XCAR (FRAME_DISPLAY_INFO (f)->name_list_element));
- if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO (f)->root_window)
+ if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_DISPLAY_INFO (f)->root_window)
tem = Qnil;
else
- XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
+ tem = make_natnum ((uintptr_t) FRAME_X_OUTPUT (f)->parent_desc);
store_in_alist (alistptr, Qexplicit_name, (f->explicit_name ? Qt : Qnil));
store_in_alist (alistptr, Qparent_id, tem);
+ store_in_alist (alistptr, Qtool_bar_position, f->tool_bar_position);
}
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;
+x_set_fullscreen (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (NILP (new_value))
f->want_fullscreen = FULLSCREEN_NONE;
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;
+x_set_line_spacing (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (NILP (new_value))
f->extra_line_spacing = 0;
- else if (NATNUMP (new_value))
+ else if (RANGED_INTEGERP (0, new_value, INT_MAX))
f->extra_line_spacing = XFASTINT (new_value);
+ else if (FLOATP (new_value))
+ {
+ int new_spacing = XFLOAT_DATA (new_value) * FRAME_LINE_HEIGHT (f) + 0.5;
+
+ if (new_spacing >= 0)
+ f->extra_line_spacing = new_spacing;
+ else
+ signal_error ("Invalid line-spacing", new_value);
+ }
else
signal_error ("Invalid line-spacing", new_value);
if (FRAME_VISIBLE_P (f))
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;
+x_set_screen_gamma (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
Lisp_Object bgcolor;
bgcolor = Fassq (Qbackground_color, f->param_alist);
if (CONSP (bgcolor) && (bgcolor = XCDR (bgcolor), STRINGP (bgcolor)))
{
- Lisp_Object index = Fget (Qbackground_color, Qx_frame_parameter);
- if (NATNUMP (index)
- && (XFASTINT (index)
+ Lisp_Object parm_index = Fget (Qbackground_color, Qx_frame_parameter);
+ if (NATNUMP (parm_index)
+ && (XFASTINT (parm_index)
< sizeof (frame_parms)/sizeof (frame_parms[0]))
- && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
- (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (index)])
+ && FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
+ (*FRAME_RIF (f)->frame_parm_handlers[XFASTINT (parm_index)])
(f, bgcolor, Qnil);
}
void
-x_set_font (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
- Lisp_Object frame, font_object, font_param = Qnil;
+ Lisp_Object font_object;
int fontset = -1;
+#ifdef HAVE_X_WINDOWS
+ Lisp_Object font_param = arg;
+#endif
/* Set the frame parameter back to the old value because we may
fail to use ARG as the new parameter value. */
never fail. */
if (STRINGP (arg))
{
- font_param = arg;
fontset = fs_query_fontset (arg, 0);
if (fontset < 0)
{
- font_object = font_open_by_name (f, SDATA (arg));
+ font_object = font_open_by_name (f, arg);
if (NILP (font_object))
- error ("Font `%s' is not defined", SDATA (arg));
+ error ("Font `%s' is not defined", SSDATA (arg));
arg = AREF (font_object, FONT_NAME_INDEX);
}
else if (fontset > 0)
{
- Lisp_Object ascii_font = fontset_ascii (fontset);
-
- font_object = font_open_by_name (f, SDATA (ascii_font));
+ font_object = font_open_by_name (f, fontset_ascii (fontset));
if (NILP (font_object))
error ("Font `%s' is not defined", SDATA (arg));
arg = AREF (font_object, FONT_NAME_INDEX);
error ("Unknown fontset: %s", SDATA (XCAR (arg)));
font_object = XCDR (arg);
arg = AREF (font_object, FONT_NAME_INDEX);
+#ifdef HAVE_X_WINDOWS
font_param = Ffont_get (font_object, QCname);
+#endif
}
else if (FONT_OBJECT_P (arg))
{
font_object = arg;
+#ifdef HAVE_X_WINDOWS
font_param = Ffont_get (font_object, QCname);
+#endif
/* This is to store the XLFD font name in the frame parameter for
backward compatibility. We should store the font-object
itself in the future. */
Lisp_Object ascii_font = fontset_ascii (fontset);
Lisp_Object spec = font_spec_from_name (ascii_font);
+ if (NILP (spec))
+ signal_error ("Invalid font name", ascii_font);
+
if (! font_match_p (spec, font_object))
fontset = -1;
}
void
-x_set_font_backend (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_font_backend (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
if (! NILP (new_value)
&& !CONSP (new_value))
char *p0, *p1;
CHECK_STRING (new_value);
- p0 = p1 = SDATA (new_value);
+ p0 = p1 = SSDATA (new_value);
new_value = Qnil;
while (*p0)
{
- while (*p1 && ! isspace (*p1) && *p1 != ',') p1++;
+ while (*p1 && ! c_isspace (*p1) && *p1 != ',') p1++;
if (p0 < p1)
new_value = Fcons (Fintern (make_string (p0, p1 - p0), Qnil),
new_value);
{
int c;
- while ((c = *++p1) && isspace (c));
+ while ((c = *++p1) && c_isspace (c));
}
p0 = p1;
}
void
-x_set_fringe_width (f, new_value, old_value)
- struct frame *f;
- Lisp_Object new_value, old_value;
+x_set_fringe_width (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
{
compute_fringe_widths (f, 1);
+#ifdef HAVE_X_WINDOWS
+ /* Must adjust this so window managers report correct number of columns. */
+ if (FRAME_X_WINDOW (f) != 0)
+ x_wm_set_size_hint (f, 0, 0);
+#endif
}
void
-x_set_border_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
- CHECK_NUMBER (arg);
+ CHECK_TYPE_RANGED_INTEGER (int, arg);
if (XINT (arg) == f->border_width)
return;
}
void
-x_set_internal_border_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int old = FRAME_INTERNAL_BORDER_WIDTH (f);
- CHECK_NUMBER (arg);
+ CHECK_TYPE_RANGED_INTEGER (int, arg);
FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
}
void
-x_set_visibility (f, value, oldval)
- struct frame *f;
- Lisp_Object value, oldval;
+x_set_visibility (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{
Lisp_Object frame;
XSETFRAME (frame, f);
}
void
-x_set_autoraise (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_autoraise (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->auto_raise = !EQ (Qnil, arg);
}
void
-x_set_autolower (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_autolower (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->auto_lower = !EQ (Qnil, arg);
}
void
-x_set_unsplittable (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_unsplittable (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
f->no_split = !NILP (arg);
}
void
-x_set_vertical_scroll_bars (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_vertical_scroll_bars (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
|| (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
}
void
-x_set_scroll_bar_width (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
int wid = FRAME_COLUMN_WIDTH (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
+ else if (RANGED_INTEGERP (1, arg, INT_MAX)
&& 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))
/* Return non-nil if frame F wants a bitmap icon. */
Lisp_Object
-x_icon_type (f)
- FRAME_PTR f;
+x_icon_type (struct frame *f)
{
Lisp_Object tem;
}
void
-x_set_alpha (f, arg, oldval)
- struct frame *f;
- Lisp_Object arg, oldval;
+x_set_alpha (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
{
double alpha = 1.0;
double newval[2];
- int i, ialpha;
+ int i;
Lisp_Object item;
for (i = 0; i < 2; i++)
else if (FLOATP (item))
{
alpha = XFLOAT_DATA (item);
- if (alpha < 0.0 || 1.0 < alpha)
+ if (! (0 <= alpha && alpha <= 1.0))
args_out_of_range (make_float (0.0), make_float (1.0));
}
else if (INTEGERP (item))
{
- ialpha = XINT (item);
- if (ialpha < 0 || 100 < ialpha)
+ EMACS_INT ialpha = XINT (item);
+ if (! (0 <= ialpha && alpha <= 100))
args_out_of_range (make_number (0), make_number (100));
- else
- alpha = ialpha / 100.0;
+ alpha = ialpha / 100.0;
}
else
wrong_type_argument (Qnumberp, item);
f->alpha[i] = newval[i];
#if defined (HAVE_X_WINDOWS) || defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA)
- BLOCK_INPUT;
+ block_input ();
x_set_frame_alpha (f);
- UNBLOCK_INPUT;
+ unblock_input ();
#endif
return;
Fix it up, or set it to `emacs' if it is too hopeless. */
void
-validate_x_resource_name ()
+validate_x_resource_name (void)
{
- int len = 0;
+ ptrdiff_t len = 0;
/* Number of valid characters in the resource name. */
- int good_count = 0;
+ ptrdiff_t good_count = 0;
/* Number of invalid characters in the resource name. */
- int bad_count = 0;
+ ptrdiff_t bad_count = 0;
Lisp_Object new;
- int i;
+ ptrdiff_t 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);
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))
+ /* If name is entirely invalid, or nearly so, or is so implausibly
+ large that alloca might not work, use `emacs'. */
+ if (good_count < 2 || MAX_ALLOCA - sizeof ".customization" < len)
{
Vx_resource_name = build_string ("emacs");
return;
}
-extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
-extern Display_Info *check_x_display_info P_ ((Lisp_Object));
+extern char *x_get_string_resource (XrmDatabase, const char *, const char *);
+extern Display_Info *check_x_display_info (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;
+xrdb_get_resource (XrmDatabase rdb, Lisp_Object attribute, Lisp_Object class, Lisp_Object component, Lisp_Object subclass)
{
register char *value;
char *name_key;
/* 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);
+ name_key = alloca (SBYTES (Vx_resource_name)
+ + (STRINGP (component)
+ ? SBYTES (component) : 0)
+ + SBYTES (attribute)
+ + 3);
+
+ class_key = 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));
+ strcpy (name_key, SSDATA (Vx_resource_name));
+ strcpy (class_key, SSDATA (Vx_resource_class));
strcat (class_key, ".");
- strcat (class_key, SDATA (class));
+ strcat (class_key, SSDATA (class));
if (!NILP (component))
{
strcat (class_key, ".");
- strcat (class_key, SDATA (subclass));
+ strcat (class_key, SSDATA (subclass));
strcat (name_key, ".");
- strcat (name_key, SDATA (component));
+ strcat (name_key, SSDATA (component));
}
strcat (name_key, ".");
- strcat (name_key, SDATA (attribute));
+ strcat (name_key, SSDATA (attribute));
value = x_get_string_resource (rdb, name_key, class_key);
- if (value != (char *) 0 && *value)
+ if (value && *value)
return build_string (value);
else
return Qnil;
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;
+ (Lisp_Object attribute, Lisp_Object class, Lisp_Object component,
+ Lisp_Object subclass)
{
-#ifdef HAVE_X_WINDOWS
- check_x ();
-#endif
+ check_window_system (NULL);
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;
+display_x_get_resource (Display_Info *dpyinfo, Lisp_Object attribute,
+ Lisp_Object class, Lisp_Object component,
+ Lisp_Object subclass)
{
return xrdb_get_resource (dpyinfo->xrdb,
attribute, class, component, subclass);
/* Used when C code wants a resource value. */
/* Called from oldXMenu/Create.c. */
char *
-x_get_resource_string (attribute, class)
- char *attribute, *class;
+x_get_resource_string (const char *attribute, const char *class)
{
- char *name_key;
- char *class_key;
+ char *result;
struct frame *sf = SELECTED_FRAME ();
+ ptrdiff_t invocation_namelen = SBYTES (Vinvocation_name);
+ USE_SAFE_ALLOCA;
/* 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);
+ char *name_key = SAFE_ALLOCA (invocation_namelen + strlen (attribute) + 2);
+ char *class_key = alloca ((sizeof (EMACS_CLASS) - 1) + strlen (class) + 2);
- sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
+ esprintf (name_key, "%s.%s", SSDATA (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);
+ result = x_get_string_resource (FRAME_DISPLAY_INFO (sf)->xrdb,
+ name_key, class_key);
+ SAFE_FREE ();
+ return result;
}
#endif
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;
+x_get_arg (Display_Info *dpyinfo, Lisp_Object alist, Lisp_Object param,
+ const char *attribute, const char *class, enum resource_types type)
{
register Lisp_Object tem;
switch (type)
{
case RES_TYPE_NUMBER:
- return make_number (atoi (SDATA (tem)));
+ return make_number (atoi (SSDATA (tem)));
case RES_TYPE_BOOLEAN_NUMBER:
- if (!strcmp (SDATA (tem), "on")
- || !strcmp (SDATA (tem), "true"))
+ if (!strcmp (SSDATA (tem), "on")
+ || !strcmp (SSDATA (tem), "true"))
return make_number (1);
- return make_number (atoi (SDATA (tem)));
+ return make_number (atoi (SSDATA (tem)));
break;
case RES_TYPE_FLOAT:
- return make_float (atof (SDATA (tem)));
+ return make_float (atof (SSDATA (tem)));
case RES_TYPE_BOOLEAN:
tem = Fdowncase (tem);
- if (!strcmp (SDATA (tem), "on")
+ if (!strcmp (SSDATA (tem), "on")
#ifdef HAVE_NS
- || !strcmp(SDATA(tem), "yes")
+ || !strcmp (SSDATA (tem), "yes")
#endif
- || !strcmp (SDATA (tem), "true"))
+ || !strcmp (SSDATA (tem), "true"))
return Qt;
else
return Qnil;
{
Lisp_Object lower;
lower = Fdowncase (tem);
- if (!strcmp (SDATA (lower), "on")
+ if (!strcmp (SSDATA (lower), "on")
#ifdef HAVE_NS
- || !strcmp(SDATA(lower), "yes")
+ || !strcmp (SSDATA (lower), "yes")
#endif
- || !strcmp (SDATA (lower), "true"))
+ || !strcmp (SSDATA (lower), "true"))
return Qt;
- else if (!strcmp (SDATA (lower), "off")
+ else if (!strcmp (SSDATA (lower), "off")
#ifdef HAVE_NS
- || !strcmp(SDATA(lower), "no")
+ || !strcmp (SSDATA (lower), "no")
#endif
- || !strcmp (SDATA (lower), "false"))
+ || !strcmp (SSDATA (lower), "false"))
return Qnil;
else
return Fintern (tem, Qnil);
}
default:
- abort ();
+ emacs_abort ();
}
}
else
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;
+static Lisp_Object
+x_frame_get_arg (struct frame *f, Lisp_Object alist, Lisp_Object param,
+ const char *attribute, const char *class,
+ enum resource_types type)
{
- return x_get_arg (FRAME_X_DISPLAY_INFO (f),
+ return x_get_arg (FRAME_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;
+x_frame_get_and_record_arg (struct frame *f, Lisp_Object alist,
+ Lisp_Object param,
+ const char *attribute, const char *class,
+ enum resource_types type)
{
Lisp_Object value;
- value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
+ value = x_get_arg (FRAME_DISPLAY_INFO (f), alist, param,
attribute, class, type);
if (! NILP (value) && ! EQ (value, Qunbound))
store_frame_param (f, param, value);
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;
+x_default_parameter (struct frame *f, Lisp_Object alist, Lisp_Object prop,
+ Lisp_Object deflt, const char *xprop, const 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));
+ x_set_frame_parameters (f, list1 (Fcons (prop, tem)));
return tem;
}
+#if !defined (HAVE_X_WINDOWS) && defined (NoValue)
+
+/*
+ * XParseGeometry parses strings of the form
+ * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
+ * width, height, xoffset, and yoffset are unsigned integers.
+ * Example: "=80x24+300-49"
+ * The equal sign is optional.
+ * It returns a bitmask that indicates which of the four values
+ * were actually found in the string. For each value found,
+ * the corresponding argument is updated; for each value
+ * not found, the corresponding argument is left unchanged.
+ */
+
+static int
+XParseGeometry (char *string,
+ int *x, int *y,
+ unsigned int *width, unsigned int *height)
+{
+ int mask = NoValue;
+ char *strind;
+ unsigned long int tempWidth, tempHeight;
+ long int tempX, tempY;
+ char *nextCharacter;
+
+ if (string == NULL || *string == '\0')
+ return mask;
+ if (*string == '=')
+ string++; /* ignore possible '=' at beg of geometry spec */
+
+ strind = string;
+ if (*strind != '+' && *strind != '-' && *strind != 'x')
+ {
+ tempWidth = strtoul (strind, &nextCharacter, 10);
+ if (strind == nextCharacter)
+ return 0;
+ strind = nextCharacter;
+ mask |= WidthValue;
+ }
+
+ if (*strind == 'x' || *strind == 'X')
+ {
+ strind++;
+ tempHeight = strtoul (strind, &nextCharacter, 10);
+ if (strind == nextCharacter)
+ return 0;
+ strind = nextCharacter;
+ mask |= HeightValue;
+ }
+
+ if (*strind == '+' || *strind == '-')
+ {
+ if (*strind == '-')
+ mask |= XNegative;
+ tempX = strtol (strind, &nextCharacter, 10);
+ if (strind == nextCharacter)
+ return 0;
+ strind = nextCharacter;
+ mask |= XValue;
+ if (*strind == '+' || *strind == '-')
+ {
+ if (*strind == '-')
+ mask |= YNegative;
+ tempY = strtol (strind, &nextCharacter, 10);
+ if (strind == nextCharacter)
+ return 0;
+ strind = nextCharacter;
+ mask |= YValue;
+ }
+ }
+
+ /* If strind isn't at the end of the string then it's an invalid
+ geometry specification. */
+
+ if (*strind != '\0')
+ return 0;
+
+ if (mask & XValue)
+ *x = clip_to_bounds (INT_MIN, tempX, INT_MAX);
+ if (mask & YValue)
+ *y = clip_to_bounds (INT_MIN, tempY, INT_MAX);
+ if (mask & WidthValue)
+ *width = min (tempWidth, UINT_MAX);
+ if (mask & HeightValue)
+ *height = min (tempHeight, UINT_MAX);
+ return mask;
+}
+
+#endif /* !defined (HAVE_X_WINDOWS) && defined (NoValue) */
\f
/* NS used to define x-parse-geometry in ns-win.el, but that confused
or a list (+ N) meaning N pixels relative to top/left corner,
or a list (- N) meaning -N pixels relative to bottom/right corner.
On Nextstep, this just calls `ns-parse-geometry'. */)
- (string)
- Lisp_Object string;
+ (Lisp_Object string)
{
-#ifdef HAVE_NS
- call1 (Qns_parse_geometry, string);
-#else
int geometry, x, y;
unsigned int width, height;
Lisp_Object result;
CHECK_STRING (string);
- geometry = XParseGeometry ((char *) SDATA (string),
+#ifdef HAVE_NS
+ if (strchr (SSDATA (string), ' ') != NULL)
+ return call1 (Qns_parse_geometry, string);
+#endif
+ geometry = XParseGeometry (SSDATA (string),
&x, &y, &width, &height);
result = Qnil;
if (geometry & XValue)
Lisp_Object element;
if (x >= 0 && (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
+ element = list3 (Qleft, Qminus, make_number (-x));
else if (x < 0 && ! (geometry & XNegative))
- element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
+ element = list3 (Qleft, Qplus, make_number (x));
else
element = Fcons (Qleft, make_number (x));
result = Fcons (element, result);
Lisp_Object element;
if (y >= 0 && (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
+ element = list3 (Qtop, Qminus, make_number (-y));
else if (y < 0 && ! (geometry & YNegative))
- element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
+ element = list3 (Qtop, Qplus, make_number (y));
else
element = Fcons (Qtop, make_number (y));
result = Fcons (element, result);
result = Fcons (Fcons (Qheight, make_number (height)), result);
return result;
-#endif /* HAVE_NS */
}
#define DEFAULT_ROWS 35
#define DEFAULT_COLS 80
-int
-x_figure_window_size (f, parms, toolbar_p)
- struct frame *f;
- Lisp_Object parms;
- int toolbar_p;
+long
+x_figure_window_size (struct frame *f, Lisp_Object parms, bool toolbar_p)
{
register Lisp_Object tem0, tem1, tem2;
long window_prompting = 0;
- Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
+ Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
/* Default values if we fall through.
Actually, if that happens we should get
if (!EQ (tem0, Qunbound))
{
CHECK_NUMBER (tem0);
+ if (! (0 <= XINT (tem0) && XINT (tem0) <= INT_MAX))
+ xsignal1 (Qargs_out_of_range, tem0);
FRAME_LINES (f) = XINT (tem0);
}
if (!EQ (tem1, Qunbound))
{
CHECK_NUMBER (tem1);
+ if (! (0 <= XINT (tem1) && XINT (tem1) <= INT_MAX))
+ xsignal1 (Qargs_out_of_range, tem1);
SET_FRAME_COLS (f, XINT (tem1));
}
if (!NILP (tem2) && !EQ (tem2, Qunbound))
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
- if (INTEGERP (Vtool_bar_button_margin)
- && XINT (Vtool_bar_button_margin) > 0)
+ if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
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)
+ && RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin), INT_MAX))
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
margin = 0;
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
&& CONSP (XCDR (tem0))
- && INTEGERP (XCAR (XCDR (tem0))))
+ && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (tem0)), INT_MAX))
{
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))))
+ && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (tem0))))
{
f->top_pos = XINT (XCAR (XCDR (tem0)));
}
f->top_pos = 0;
else
{
- CHECK_NUMBER (tem0);
+ CHECK_TYPE_RANGED_INTEGER (int, tem0);
f->top_pos = XINT (tem0);
if (f->top_pos < 0)
window_prompting |= YNegative;
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
&& CONSP (XCDR (tem1))
- && INTEGERP (XCAR (XCDR (tem1))))
+ && RANGED_INTEGERP (-INT_MAX, XCAR (XCDR (tem1)), INT_MAX))
{
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))))
+ && TYPE_RANGED_INTEGERP (int, XCAR (XCDR (tem1))))
{
f->left_pos = XINT (XCAR (XCDR (tem1)));
}
f->left_pos = 0;
else
{
- CHECK_NUMBER (tem1);
+ CHECK_TYPE_RANGED_INTEGER (int, tem1);
f->left_pos = XINT (tem1);
if (f->left_pos < 0)
window_prompting |= XNegative;
#endif /* HAVE_WINDOW_SYSTEM */
void
-frame_make_pointer_invisible ()
+frame_make_pointer_invisible (void)
{
if (! NILP (Vmake_pointer_invisible))
{
}
void
-frame_make_pointer_visible ()
+frame_make_pointer_visible (void)
{
/* We don't check Vmake_pointer_invisible here in case the
pointer was invisible when Vmake_pointer_invisible was set to nil. */
}
}
+DEFUN ("frame-pointer-visible-p", Fframe_pointer_visible_p,
+ Sframe_pointer_visible_p, 0, 1, 0,
+ doc: /* Return t if the mouse pointer displayed on FRAME is visible.
+Otherwise it returns nil. FRAME omitted or nil means the
+selected frame. This is useful when `make-pointer-invisible' is set. */)
+ (Lisp_Object frame)
+{
+ return decode_any_frame (frame)->pointer_invisible ? Qnil : Qt;
+}
+
+
+\f
+/***********************************************************************
+ Multimonitor data
+ ***********************************************************************/
+
+#ifdef HAVE_WINDOW_SYSTEM
+
+# if (defined HAVE_NS \
+ || (!defined USE_GTK && (defined HAVE_XINERAMA || defined HAVE_XRANDR)))
+void
+free_monitors (struct MonitorInfo *monitors, int n_monitors)
+{
+ int i;
+ for (i = 0; i < n_monitors; ++i)
+ xfree (monitors[i].name);
+ xfree (monitors);
+}
+# endif
+
+Lisp_Object
+make_monitor_attribute_list (struct MonitorInfo *monitors,
+ int n_monitors,
+ int primary_monitor,
+ Lisp_Object monitor_frames,
+ const char *source)
+{
+ Lisp_Object attributes_list = Qnil;
+ Lisp_Object primary_monitor_attributes = Qnil;
+ int i;
+
+ for (i = 0; i < n_monitors; ++i)
+ {
+ Lisp_Object geometry, workarea, attributes = Qnil;
+ struct MonitorInfo *mi = &monitors[i];
+
+ if (mi->geom.width == 0) continue;
+
+ workarea = list4i (mi->work.x, mi->work.y,
+ mi->work.width, mi->work.height);
+ geometry = list4i (mi->geom.x, mi->geom.y,
+ mi->geom.width, mi->geom.height);
+ attributes = Fcons (Fcons (Qsource, build_string (source)),
+ attributes);
+ attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
+ attributes);
+ attributes = Fcons (Fcons (Qmm_size,
+ list2i (mi->mm_width, mi->mm_height)),
+ attributes);
+ attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
+ attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
+ if (mi->name)
+ attributes = Fcons (Fcons (Qname, make_string (mi->name,
+ strlen (mi->name))),
+ attributes);
+
+ if (i == primary_monitor)
+ primary_monitor_attributes = attributes;
+ else
+ attributes_list = Fcons (attributes, attributes_list);
+ }
+
+ if (!NILP (primary_monitor_attributes))
+ attributes_list = Fcons (primary_monitor_attributes, attributes_list);
+ return attributes_list;
+}
+
+#endif /* HAVE_WINDOW_SYSTEM */
\f
/***********************************************************************
***********************************************************************/
void
-syms_of_frame ()
+syms_of_frame (void)
{
- Qframep = intern_c_string ("framep");
- staticpro (&Qframep);
- Qframe_live_p = intern_c_string ("frame-live-p");
- staticpro (&Qframe_live_p);
- Qexplicit_name = intern_c_string ("explicit-name");
- staticpro (&Qexplicit_name);
- Qheight = intern_c_string ("height");
- staticpro (&Qheight);
- Qicon = intern_c_string ("icon");
- staticpro (&Qicon);
- Qminibuffer = intern_c_string ("minibuffer");
- staticpro (&Qminibuffer);
- Qmodeline = intern_c_string ("modeline");
- staticpro (&Qmodeline);
- Qonly = intern_c_string ("only");
- staticpro (&Qonly);
- Qwidth = intern_c_string ("width");
- staticpro (&Qwidth);
- Qgeometry = intern_c_string ("geometry");
- staticpro (&Qgeometry);
- Qicon_left = intern_c_string ("icon-left");
- staticpro (&Qicon_left);
- Qicon_top = intern_c_string ("icon-top");
- staticpro (&Qicon_top);
- Qtooltip = intern_c_string ("tooltip");
- staticpro (&Qtooltip);
- Qleft = intern_c_string ("left");
- staticpro (&Qleft);
- Qright = intern_c_string ("right");
- staticpro (&Qright);
- Quser_position = intern_c_string ("user-position");
- staticpro (&Quser_position);
- Quser_size = intern_c_string ("user-size");
- staticpro (&Quser_size);
- Qwindow_id = intern_c_string ("window-id");
- staticpro (&Qwindow_id);
+ DEFSYM (Qframep, "framep");
+ DEFSYM (Qframe_live_p, "frame-live-p");
+ DEFSYM (Qexplicit_name, "explicit-name");
+ DEFSYM (Qheight, "height");
+ DEFSYM (Qicon, "icon");
+ DEFSYM (Qminibuffer, "minibuffer");
+ DEFSYM (Qmodeline, "modeline");
+ DEFSYM (Qonly, "only");
+ DEFSYM (Qnone, "none");
+ DEFSYM (Qwidth, "width");
+ DEFSYM (Qgeometry, "geometry");
+ DEFSYM (Qicon_left, "icon-left");
+ DEFSYM (Qicon_top, "icon-top");
+ DEFSYM (Qtooltip, "tooltip");
+ DEFSYM (Qleft, "left");
+ DEFSYM (Qright, "right");
+ DEFSYM (Quser_position, "user-position");
+ DEFSYM (Quser_size, "user-size");
+ DEFSYM (Qwindow_id, "window-id");
#ifdef HAVE_X_WINDOWS
- Qouter_window_id = intern_c_string ("outer-window-id");
- staticpro (&Qouter_window_id);
+ DEFSYM (Qouter_window_id, "outer-window-id");
#endif
- Qparent_id = intern_c_string ("parent-id");
- staticpro (&Qparent_id);
- Qx = intern_c_string ("x");
- staticpro (&Qx);
- Qw32 = intern_c_string ("w32");
- staticpro (&Qw32);
- Qpc = intern_c_string ("pc");
- staticpro (&Qpc);
- Qmac = intern_c_string ("mac");
- staticpro (&Qmac);
- Qns = intern_c_string ("ns");
- staticpro (&Qns);
- Qvisible = intern_c_string ("visible");
- staticpro (&Qvisible);
- Qbuffer_predicate = intern_c_string ("buffer-predicate");
- staticpro (&Qbuffer_predicate);
- Qbuffer_list = intern_c_string ("buffer-list");
- staticpro (&Qbuffer_list);
- Qburied_buffer_list = intern_c_string ("buried-buffer-list");
- staticpro (&Qburied_buffer_list);
- Qdisplay_type = intern_c_string ("display-type");
- staticpro (&Qdisplay_type);
- Qbackground_mode = intern_c_string ("background-mode");
- staticpro (&Qbackground_mode);
- Qnoelisp = intern_c_string ("noelisp");
- staticpro (&Qnoelisp);
- Qtty_color_mode = intern_c_string ("tty-color-mode");
- staticpro (&Qtty_color_mode);
- Qtty = intern_c_string ("tty");
- staticpro (&Qtty);
- Qtty_type = intern_c_string ("tty-type");
- staticpro (&Qtty_type);
-
- Qface_set_after_frame_default = intern_c_string ("face-set-after-frame-default");
- staticpro (&Qface_set_after_frame_default);
-
- Qfullwidth = intern_c_string ("fullwidth");
- staticpro (&Qfullwidth);
- Qfullheight = intern_c_string ("fullheight");
- staticpro (&Qfullheight);
- Qfullboth = intern_c_string ("fullboth");
- staticpro (&Qfullboth);
- Qmaximized = intern_c_string ("maximized");
- staticpro (&Qmaximized);
- Qx_resource_name = intern_c_string ("x-resource-name");
- staticpro (&Qx_resource_name);
-
- Qx_frame_parameter = intern_c_string ("x-frame-parameter");
- staticpro (&Qx_frame_parameter);
-
- Qterminal = intern_c_string ("terminal");
- staticpro (&Qterminal);
- Qterminal_live_p = intern_c_string ("terminal-live-p");
- staticpro (&Qterminal_live_p);
+ DEFSYM (Qparent_id, "parent-id");
+ DEFSYM (Qx, "x");
+ DEFSYM (Qw32, "w32");
+ DEFSYM (Qpc, "pc");
+ DEFSYM (Qns, "ns");
+ DEFSYM (Qvisible, "visible");
+ DEFSYM (Qbuffer_predicate, "buffer-predicate");
+ DEFSYM (Qbuffer_list, "buffer-list");
+ DEFSYM (Qburied_buffer_list, "buried-buffer-list");
+ DEFSYM (Qdisplay_type, "display-type");
+ DEFSYM (Qbackground_mode, "background-mode");
+ DEFSYM (Qnoelisp, "noelisp");
+ DEFSYM (Qtty_color_mode, "tty-color-mode");
+ DEFSYM (Qtty, "tty");
+ DEFSYM (Qtty_type, "tty-type");
+
+ DEFSYM (Qface_set_after_frame_default, "face-set-after-frame-default");
+
+ DEFSYM (Qfullwidth, "fullwidth");
+ DEFSYM (Qfullheight, "fullheight");
+ DEFSYM (Qfullboth, "fullboth");
+ DEFSYM (Qmaximized, "maximized");
+ DEFSYM (Qx_resource_name, "x-resource-name");
+ DEFSYM (Qx_frame_parameter, "x-frame-parameter");
+
+ DEFSYM (Qterminal, "terminal");
+
+ DEFSYM (Qgeometry, "geometry");
+ DEFSYM (Qworkarea, "workarea");
+ DEFSYM (Qmm_size, "mm-size");
+ DEFSYM (Qframes, "frames");
+ DEFSYM (Qsource, "source");
#ifdef HAVE_NS
- Qns_parse_geometry = intern_c_string ("ns-parse-geometry");
- staticpro (&Qns_parse_geometry);
+ DEFSYM (Qns_parse_geometry, "ns-parse-geometry");
#endif
{
}
#ifdef HAVE_WINDOW_SYSTEM
- DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
+ 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.
to `x-get-resource'. See also the variable `x-resource-class'. */);
Vx_resource_name = Qnil;
- DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
+ 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.
is a reasonable practice. See also the variable `x-resource-name'. */);
Vx_resource_class = build_string (EMACS_CLASS);
- DEFVAR_LISP ("frame-alpha-lower-limit", &Vframe_alpha_lower_limit,
+ DEFVAR_LISP ("frame-alpha-lower-limit", Vframe_alpha_lower_limit,
doc: /* The lower limit of the frame opacity (alpha transparency).
The value should range from 0 (invisible) to 100 (completely opaque).
You can also use a floating number between 0.0 and 1.0.
Vframe_alpha_lower_limit = make_number (20);
#endif
- DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
+ 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)))
Setting this variable does not affect existing frames, only new ones. */);
Vdefault_frame_alist = Qnil;
- DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars,
+ DEFVAR_LISP ("default-frame-scroll-bars", Vdefault_frame_scroll_bars,
doc: /* Default position of scroll bars on this window-system. */);
#ifdef HAVE_WINDOW_SYSTEM
-#if defined(HAVE_NTGUI) || defined(NS_IMPL_COCOA)
- /* MS-Windows and Mac OS X have scroll bars on the right by default. */
+#if defined (HAVE_NTGUI) || defined (NS_IMPL_COCOA) || (defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS))
+ /* MS-Windows, Mac OS X, and GTK have scroll bars on the right by
+ default. */
Vdefault_frame_scroll_bars = Qright;
#else
Vdefault_frame_scroll_bars = Qleft;
Vdefault_frame_scroll_bars = Qnil;
#endif
- DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
+ DEFVAR_BOOL ("scroll-bar-adjust-thumb-portion",
+ scroll_bar_adjust_thumb_portion_p,
+ doc: /* Adjust thumb for overscrolling for Gtk+ and MOTIF.
+Non-nil means adjust the thumb in the scroll bar so it can be dragged downwards
+even if the end of the buffer is shown (i.e. overscrolling).
+Set to nil if you want the thumb to be at the bottom when the end of the buffer
+is shown. Also, the thumb fills the whole scroll bar when the entire buffer
+is visible. In this case you can not overscroll. */);
+ scroll_bar_adjust_thumb_portion_p = 1;
+
+ DEFVAR_LISP ("terminal-frame", Vterminal_frame,
doc: /* The initial frame-object, which represents Emacs's stdout. */);
- DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
+ 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.
which need to do mouse handling at the Lisp level. */);
Vmouse_position_function = Qnil;
- DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
+ 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
when the mouse is over clickable text. */);
Vmouse_highlight = Qt;
- DEFVAR_LISP ("make-pointer-invisible", &Vmake_pointer_invisible,
+ DEFVAR_LISP ("make-pointer-invisible", Vmake_pointer_invisible,
doc: /* If non-nil, make pointer invisible while typing.
The pointer becomes visible again when the mouse is moved. */);
Vmake_pointer_invisible = Qt;
- DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
- doc: /* Functions to be run before deleting a frame.
+ DEFVAR_LISP ("delete-frame-functions", Vdelete_frame_functions,
+ doc: /* Functions run before deleting a frame.
The functions are run with one arg, the frame to be deleted.
See `delete-frame'.
in `delete-frame-functions' (indirectly) calls `delete-frame'
recursively). */);
Vdelete_frame_functions = Qnil;
- Qdelete_frame_functions = intern_c_string ("delete-frame-functions");
- staticpro (&Qdelete_frame_functions);
+ DEFSYM (Qdelete_frame_functions, "delete-frame-functions");
+
+ DEFVAR_LISP ("menu-bar-mode", Vmenu_bar_mode,
+ doc: /* Non-nil if Menu-Bar mode is enabled.
+See the command `menu-bar-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `menu-bar-mode'. */);
+ Vmenu_bar_mode = Qt;
+
+ DEFVAR_LISP ("tool-bar-mode", Vtool_bar_mode,
+ doc: /* Non-nil if Tool-Bar mode is enabled.
+See the command `tool-bar-mode' for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `tool-bar-mode'. */);
+#ifdef HAVE_WINDOW_SYSTEM
+ Vtool_bar_mode = Qt;
+#else
+ Vtool_bar_mode = Qnil;
+#endif
DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
doc: /* Minibufferless frames use this frame's minibuffer.
This variable is local to the current terminal and cannot be buffer-local. */);
- DEFVAR_BOOL ("focus-follows-mouse", &focus_follows_mouse,
+ DEFVAR_BOOL ("focus-follows-mouse", focus_follows_mouse,
doc: /* Non-nil if window system changes focus when you move the mouse.
You should set this variable to tell Emacs how your window manager
handles focus, since there is no way in general for Emacs to find out
automatically. See also `mouse-autoselect-window'. */);
-#ifdef HAVE_WINDOW_SYSTEM
-#if defined(HAVE_NTGUI) || defined(HAVE_NS)
- focus_follows_mouse = 0;
-#else
- focus_follows_mouse = 1;
-#endif
-#else
focus_follows_mouse = 0;
-#endif
staticpro (&Vframe_list);
- defsubr (&Sactive_minibuffer_window);
defsubr (&Sframep);
defsubr (&Sframe_live_p);
defsubr (&Swindow_system);
defsubr (&Smake_terminal_frame);
defsubr (&Shandle_switch_frame);
+ defsubr (&Shandle_focus_in);
+ defsubr (&Shandle_focus_out);
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 (&Slast_nonminibuf_frame);
defsubr (&Sdelete_frame);
defsubr (&Smouse_position);
defsubr (&Smouse_pixel_position);
defsubr (&Svisible_frame_list);
defsubr (&Sraise_frame);
defsubr (&Slower_frame);
+ defsubr (&Sx_focus_frame);
defsubr (&Sredirect_frame_focus);
defsubr (&Sframe_focus);
defsubr (&Sframe_parameters);
defsubr (&Sframe_char_width);
defsubr (&Sframe_pixel_height);
defsubr (&Sframe_pixel_width);
+ defsubr (&Stool_bar_pixel_width);
defsubr (&Sset_frame_height);
defsubr (&Sset_frame_width);
defsubr (&Sset_frame_size);
defsubr (&Sset_frame_position);
+ defsubr (&Sframe_pointer_visible_p);
#ifdef HAVE_WINDOW_SYSTEM
defsubr (&Sx_get_resource);
#endif
}
-
-/* arch-tag: 7dbf2c69-9aad-45f8-8296-db893d6dd039
- (do not change this comment) */
HCoop / bpt / emacs.git / blobdiff