#include <config.h>
#include <stdio.h>
#include "lisp.h"
#include "charset.h"
#ifdef HAVE_X_WINDOWS
#include "xterm.h"
#endif
#ifdef WINDOWSNT
#include "w32term.h"
#endif
#ifdef MAC_OS
#include "macterm.h"
#endif
#include "buffer.h"
#include "commands.h"
#include "keyboard.h"
#include "frame.h"
#ifdef HAVE_WINDOW_SYSTEM
#include "fontset.h"
#endif
#include "blockinput.h"
#include "termhooks.h"
#include "dispextern.h"
#include "window.h"
#ifdef MSDOS
#include "msdos.h"
#include "dosfns.h"
#endif
#ifdef HAVE_WINDOW_SYSTEM
Lisp_Object Vx_resource_name;
Lisp_Object Vx_resource_class;
#endif
Lisp_Object Qframep, Qframe_live_p;
Lisp_Object Qicon, Qmodeline;
Lisp_Object Qonly;
Lisp_Object Qx, Qw32, Qmac, Qpc;
Lisp_Object Qvisible;
Lisp_Object Qdisplay_type;
Lisp_Object Qbackground_mode;
Lisp_Object Qx_frame_parameter;
Lisp_Object Qx_resource_name;
Lisp_Object Qauto_raise, Qauto_lower;
Lisp_Object Qborder_color, Qborder_width;
Lisp_Object Qcursor_color, Qcursor_type;
Lisp_Object Qgeometry;
Lisp_Object Qheight, Qwidth;
Lisp_Object Qleft, Qright;
Lisp_Object Qicon_left, Qicon_top, Qicon_type, Qicon_name;
Lisp_Object Qinternal_border_width;
Lisp_Object Qmouse_color;
Lisp_Object Qminibuffer;
Lisp_Object Qscroll_bar_width, Qvertical_scroll_bars;
Lisp_Object Qvisibility;
Lisp_Object Qscroll_bar_foreground, Qscroll_bar_background;
Lisp_Object Qscreen_gamma;
Lisp_Object Qline_spacing;
Lisp_Object Quser_position, Quser_size;
Lisp_Object Qwait_for_wm;
Lisp_Object Qwindow_id;
#ifdef HAVE_X_WINDOWS
Lisp_Object Qouter_window_id;
#endif
Lisp_Object Qparent_id;
Lisp_Object Qtitle, Qname;
Lisp_Object Qunsplittable;
Lisp_Object Qmenu_bar_lines, Qtool_bar_lines;
Lisp_Object Qleft_fringe, Qright_fringe;
Lisp_Object Qbuffer_predicate, Qbuffer_list;
Lisp_Object Qtty_color_mode;
Lisp_Object Qfullscreen, Qfullwidth, Qfullheight, Qfullboth;
Lisp_Object Qinhibit_face_set_after_frame_default;
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;
Lisp_Object Vdelete_frame_functions;
static void
set_menu_bar_lines_1 (window, n)
Lisp_Object window;
int n;
{
struct window *w = XWINDOW (window);
XSETFASTINT (w->last_modified, 0);
XSETFASTINT (w->top_line, XFASTINT (w->top_line) + n);
XSETFASTINT (w->total_lines, XFASTINT (w->total_lines) - n);
if (INTEGERP (w->orig_top_line))
XSETFASTINT (w->orig_top_line, XFASTINT (w->orig_top_line) + n);
if (INTEGERP (w->orig_total_lines))
XSETFASTINT (w->orig_total_lines, XFASTINT (w->orig_total_lines) - n);
if (!NILP (w->vchild))
set_menu_bar_lines_1 (w->vchild, n);
for (window = w->hchild; !NILP (window); window = w->next)
{
w = XWINDOW (window);
set_menu_bar_lines_1 (window, n);
}
}
void
set_menu_bar_lines (f, value, oldval)
struct frame *f;
Lisp_Object value, oldval;
{
int nlines;
int olines = FRAME_MENU_BAR_LINES (f);
if (FRAME_MINIBUF_ONLY_P (f))
return;
if (INTEGERP (value))
nlines = XINT (value);
else
nlines = 0;
if (nlines != olines)
{
windows_or_buffers_changed++;
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
FRAME_MENU_BAR_LINES (f) = nlines;
set_menu_bar_lines_1 (f->root_window, nlines - olines);
adjust_glyphs (f);
}
}
Lisp_Object Vemacs_iconified;
Lisp_Object Vframe_list;
struct x_output tty_display;
extern Lisp_Object Vminibuffer_list;
extern Lisp_Object get_minibuffer ();
extern Lisp_Object Fhandle_switch_frame ();
extern Lisp_Object Fredirect_frame_focus ();
extern Lisp_Object x_get_focus_frame ();
DEFUN ("framep", Fframep, Sframep, 1, 1, 0,
doc: )
(object)
Lisp_Object object;
{
if (!FRAMEP (object))
return Qnil;
switch (XFRAME (object)->output_method)
{
case output_termcap:
return Qt;
case output_x_window:
return Qx;
case output_w32:
return Qw32;
case output_msdos_raw:
return Qpc;
case output_mac:
return Qmac;
default:
abort ();
}
}
DEFUN ("frame-live-p", Fframe_live_p, Sframe_live_p, 1, 1, 0,
doc: )
(object)
Lisp_Object object;
{
return ((FRAMEP (object)
&& FRAME_LIVE_P (XFRAME (object)))
? Fframep (object)
: Qnil);
}
struct frame *
make_frame (mini_p)
int mini_p;
{
Lisp_Object frame;
register struct frame *f;
register Lisp_Object root_window;
register Lisp_Object mini_window;
f = allocate_frame ();
XSETFRAME (frame, f);
f->desired_matrix = 0;
f->current_matrix = 0;
f->desired_pool = 0;
f->current_pool = 0;
f->glyphs_initialized_p = 0;
f->decode_mode_spec_buffer = 0;
f->visible = 0;
f->async_visible = 0;
f->output_data.nothing = 0;
f->iconified = 0;
f->async_iconified = 0;
f->wants_modeline = 1;
f->auto_raise = 0;
f->auto_lower = 0;
f->no_split = 0;
f->garbaged = 1;
f->has_minibuffer = mini_p;
f->focus_frame = Qnil;
f->explicit_name = 0;
f->can_have_scroll_bars = 0;
f->vertical_scroll_bar_type = vertical_scroll_bar_none;
f->param_alist = Qnil;
f->scroll_bars = Qnil;
f->condemned_scroll_bars = Qnil;
f->face_alist = Qnil;
f->face_cache = NULL;
f->menu_bar_items = Qnil;
f->menu_bar_vector = Qnil;
f->menu_bar_items_used = 0;
f->buffer_predicate = Qnil;
f->buffer_list = Qnil;
#ifdef MULTI_KBOARD
f->kboard = initial_kboard;
#endif
f->namebuf = 0;
f->title = Qnil;
f->menu_bar_window = Qnil;
f->tool_bar_window = Qnil;
f->tool_bar_items = Qnil;
f->desired_tool_bar_string = f->current_tool_bar_string = Qnil;
f->n_tool_bar_items = 0;
f->left_fringe_width = f->right_fringe_width = 0;
f->fringe_cols = 0;
f->scroll_bar_actual_width = 0;
f->border_width = 0;
f->internal_border_width = 0;
f->column_width = 1;
f->line_height = 1;
f->x_pixels_diff = f->y_pixels_diff = 0;
#ifdef HAVE_WINDOW_SYSTEM
f->want_fullscreen = FULLSCREEN_NONE;
#endif
f->size_hint_flags = 0;
f->win_gravity = 0;
root_window = make_window ();
if (mini_p)
{
mini_window = make_window ();
XWINDOW (root_window)->next = mini_window;
XWINDOW (mini_window)->prev = root_window;
XWINDOW (mini_window)->mini_p = Qt;
XWINDOW (mini_window)->frame = frame;
f->minibuffer_window = mini_window;
}
else
{
mini_window = Qnil;
XWINDOW (root_window)->next = Qnil;
f->minibuffer_window = Qnil;
}
XWINDOW (root_window)->frame = frame;
SET_FRAME_COLS (f, 10);
FRAME_LINES (f) = 10;
XSETFASTINT (XWINDOW (root_window)->total_cols, 10);
XSETFASTINT (XWINDOW (root_window)->total_lines, (mini_p ? 9 : 10));
if (mini_p)
{
XSETFASTINT (XWINDOW (mini_window)->total_cols, 10);
XSETFASTINT (XWINDOW (mini_window)->top_line, 9);
XSETFASTINT (XWINDOW (mini_window)->total_lines, 1);
}
{
Lisp_Object buf;
XWINDOW (root_window)->buffer = Qt;
buf = Fcurrent_buffer ();
if (SREF (Fbuffer_name (buf), 0) == ' ')
buf = Fother_buffer (buf, Qnil, Qnil);
set_window_buffer (root_window, buf, 0, 0);
f->buffer_list = Fcons (buf, Qnil);
}
if (mini_p)
{
XWINDOW (mini_window)->buffer = Qt;
set_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
: Fcar (Vminibuffer_list)),
0, 0);
}
f->root_window = root_window;
f->selected_window = root_window;
++window_select_count;
XSETFASTINT (XWINDOW (f->selected_window)->use_time, window_select_count);
f->default_face_done_p = 0;
return f;
}
#ifdef HAVE_WINDOW_SYSTEM
struct frame *
make_frame_without_minibuffer (mini_window, kb, display)
register Lisp_Object mini_window;
KBOARD *kb;
Lisp_Object display;
{
register struct frame *f;
struct gcpro gcpro1;
if (!NILP (mini_window))
CHECK_LIVE_WINDOW (mini_window);
#ifdef MULTI_KBOARD
if (!NILP (mini_window)
&& XFRAME (XWINDOW (mini_window)->frame)->kboard != kb)
error ("Frame and minibuffer must be on the same display");
#endif
f = make_frame (0);
if (NILP (mini_window))
{
if (!FRAMEP (kb->Vdefault_minibuffer_frame)
|| ! FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame)))
{
Lisp_Object frame_dummy;
XSETFRAME (frame_dummy, f);
GCPRO1 (frame_dummy);
kb->Vdefault_minibuffer_frame =
call1 (intern ("make-initial-minibuffer-frame"), display);
UNGCPRO;
}
mini_window = XFRAME (kb->Vdefault_minibuffer_frame)->minibuffer_window;
}
f->minibuffer_window = mini_window;
if (NILP (Fmemq (XWINDOW (mini_window)->buffer, Vminibuffer_list)))
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
: Fcar (Vminibuffer_list)), Qnil);
return f;
}
struct frame *
make_minibuffer_frame ()
{
register struct frame *f = make_frame (0);
register Lisp_Object mini_window;
register Lisp_Object frame;
XSETFRAME (frame, f);
f->auto_raise = 0;
f->auto_lower = 0;
f->no_split = 1;
f->wants_modeline = 0;
f->has_minibuffer = 1;
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;
Fset_window_buffer (mini_window,
(NILP (Vminibuffer_list)
? get_minibuffer (0)
: Fcar (Vminibuffer_list)), Qnil);
return f;
}
#endif
static int terminal_frame_count;
struct frame *
make_terminal_frame ()
{
register struct frame *f;
Lisp_Object frame;
char name[20];
#ifdef MULTI_KBOARD
if (!initial_kboard)
{
initial_kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
init_kboard (initial_kboard);
initial_kboard->next_kboard = all_kboards;
all_kboards = initial_kboard;
}
#endif
if (! (NILP (Vframe_list) || CONSP (Vframe_list)))
Vframe_list = Qnil;
f = make_frame (1);
XSETFRAME (frame, f);
Vframe_list = Fcons (frame, Vframe_list);
terminal_frame_count++;
sprintf (name, "F%d", terminal_frame_count);
f->name = build_string (name);
f->visible = 1;
f->async_visible = 1;
#ifdef MSDOS
f->output_data.x = &the_only_x_display;
if (!inhibit_window_system
&& (!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame))
|| XFRAME (selected_frame)->output_method == output_msdos_raw))
{
f->output_method = output_msdos_raw;
if ((!FRAMEP (selected_frame) || !FRAME_LIVE_P (XFRAME (selected_frame)))
&& f->output_data.x->background_pixel == 0
&& f->output_data.x->foreground_pixel == 0)
{
f->output_data.x->background_pixel = FACE_TTY_DEFAULT_BG_COLOR;
f->output_data.x->foreground_pixel = FACE_TTY_DEFAULT_FG_COLOR;
}
}
else
f->output_method = output_termcap;
#else
#ifdef WINDOWSNT
f->output_method = output_termcap;
f->output_data.x = &tty_display;
#else
#ifdef MAC_OS8
make_mac_terminal_frame (f);
#else
f->output_data.x = &tty_display;
#ifdef CANNOT_DUMP
FRAME_FOREGROUND_PIXEL(f) = FACE_TTY_DEFAULT_FG_COLOR;
FRAME_BACKGROUND_PIXEL(f) = FACE_TTY_DEFAULT_BG_COLOR;
#endif
#endif
#endif
#endif
if (!noninteractive)
init_frame_faces (f);
return f;
}
DEFUN ("make-terminal-frame", Fmake_terminal_frame, Smake_terminal_frame,
1, 1, 0,
doc: )
(parms)
Lisp_Object parms;
{
struct frame *f;
Lisp_Object frame, tem;
struct frame *sf = SELECTED_FRAME ();
#ifdef MSDOS
if (sf->output_method != output_msdos_raw
&& sf->output_method != output_termcap)
abort ();
#else
#ifdef MAC_OS
if (sf->output_method != output_mac)
error ("Not running on a Macintosh screen; cannot make a new Macintosh frame");
#else
if (sf->output_method != output_termcap)
error ("Not using an ASCII terminal now; cannot make a new ASCII frame");
#endif
#endif
f = make_terminal_frame ();
change_frame_size (f, FRAME_LINES (sf),
FRAME_COLS (sf), 0, 0, 0);
adjust_glyphs (f);
calculate_costs (f);
XSETFRAME (frame, f);
Fmodify_frame_parameters (frame, Vdefault_frame_alist);
Fmodify_frame_parameters (frame, parms);
f->face_alist = Fcopy_alist (sf->face_alist);
for (tem = f->face_alist; CONSP (tem); tem = XCDR (tem))
XSETCDR (XCAR (tem), Fcopy_sequence (XCDR (XCAR (tem))));
return frame;
}
Lisp_Object
do_switch_frame (frame, track, for_deletion)
Lisp_Object frame;
int track, for_deletion;
{
struct frame *sf = SELECTED_FRAME ();
if (CONSP (frame)
&& EQ (XCAR (frame), Qswitch_frame)
&& CONSP (XCDR (frame)))
frame = XCAR (XCDR (frame));
CHECK_FRAME (frame);
if (! FRAME_LIVE_P (XFRAME (frame)))
return Qnil;
if (sf == XFRAME (frame))
return frame;
#if 0
if (track)
{
Lisp_Object tail;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object focus;
if (!FRAMEP (XCAR (tail)))
abort ();
focus = FRAME_FOCUS_FRAME (XFRAME (XCAR (tail)));
if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
Fredirect_frame_focus (XCAR (tail), frame);
}
}
#else
#ifdef HAVE_WINDOW_SYSTEM
if (track && FRAME_WINDOW_P (XFRAME (frame)))
{
Lisp_Object focus, xfocus;
xfocus = x_get_focus_frame (XFRAME (frame));
if (FRAMEP (xfocus))
{
focus = FRAME_FOCUS_FRAME (XFRAME (xfocus));
if (FRAMEP (focus) && XFRAME (focus) == SELECTED_FRAME ())
Fredirect_frame_focus (xfocus, frame);
}
}
#endif
#endif
if (!for_deletion && FRAME_HAS_MINIBUF_P (sf))
resize_mini_window (XWINDOW (FRAME_MINIBUF_WINDOW (sf)), 1);
selected_frame = frame;
if (! FRAME_MINIBUF_ONLY_P (XFRAME (selected_frame)))
last_nonminibuf_frame = XFRAME (selected_frame);
Fselect_window (XFRAME (frame)->selected_window, Qnil);
#ifndef WINDOWSNT
sf = SELECTED_FRAME ();
if (FRAME_TERMCAP_P (sf))
{
Lisp_Object color_mode_spec, color_mode;
color_mode_spec = assq_no_quit (Qtty_color_mode, sf->param_alist);
if (CONSP (color_mode_spec))
color_mode = XCDR (color_mode_spec);
else
color_mode = make_number (0);
set_tty_color_mode (sf, color_mode);
}
#endif
internal_last_event_frame = Qnil;
return frame;
}
DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 1, "e",
doc: )
(frame)
Lisp_Object frame;
{
return do_switch_frame (frame, 1, 0);
}
DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
doc: )
(event)
Lisp_Object event;
{
current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
call1 (Vrun_hooks, Qmouse_leave_buffer_hook);
return do_switch_frame (event, 0, 0);
}
DEFUN ("selected-frame", Fselected_frame, Sselected_frame, 0, 0, 0,
doc: )
()
{
return selected_frame;
}
DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
doc: )
(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: )
(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 minibuf_level ? minibuf_window : Qnil;
}
DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
doc: )
(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: )
(frame)
Lisp_Object frame;
{
Lisp_Object window;
if (NILP (frame))
window = SELECTED_FRAME ()->selected_window;
else
{
CHECK_LIVE_FRAME (frame);
window = XFRAME (frame)->selected_window;
}
return window;
}
DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
Sset_frame_selected_window, 2, 2, 0,
doc: )
(frame, window)
Lisp_Object frame, window;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
CHECK_LIVE_WINDOW (window);
if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
error ("In `set-frame-selected-window', WINDOW is not on FRAME");
if (EQ (frame, selected_frame))
return Fselect_window (window, Qnil);
return XFRAME (frame)->selected_window = window;
}
DEFUN ("frame-list", Fframe_list, Sframe_list,
0, 0, 0,
doc: )
()
{
Lisp_Object frames;
frames = Fcopy_sequence (Vframe_list);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAMEP (tip_frame))
frames = Fdelq (tip_frame, frames);
#endif
return frames;
}
static Lisp_Object
next_frame (frame, minibuf)
Lisp_Object frame;
Lisp_Object minibuf;
{
Lisp_Object tail;
int passed = 0;
if (! CONSP (Vframe_list))
abort ();
CHECK_LIVE_FRAME (frame);
while (1)
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object f;
f = XCAR (tail);
if (passed
&& FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
{
if (EQ (f, frame))
return f;
if (NILP (minibuf))
{
if (! FRAME_MINIBUF_ONLY_P (XFRAME (f)))
return f;
}
else if (EQ (minibuf, Qvisible))
{
FRAME_SAMPLE_VISIBILITY (XFRAME (f));
if (FRAME_VISIBLE_P (XFRAME (f)))
return f;
}
else if (INTEGERP (minibuf) && XINT (minibuf) == 0)
{
FRAME_SAMPLE_VISIBILITY (XFRAME (f));
if (FRAME_VISIBLE_P (XFRAME (f))
|| FRAME_ICONIFIED_P (XFRAME (f)))
return f;
}
else if (WINDOWP (minibuf))
{
if (EQ (FRAME_MINIBUF_WINDOW (XFRAME (f)), minibuf)
|| EQ (WINDOW_FRAME (XWINDOW (minibuf)), f)
|| EQ (WINDOW_FRAME (XWINDOW (minibuf)),
FRAME_FOCUS_FRAME (XFRAME (f))))
return f;
}
else
return f;
}
if (EQ (frame, f))
passed++;
}
}
static Lisp_Object
prev_frame (frame, minibuf)
Lisp_Object frame;
Lisp_Object minibuf;
{
Lisp_Object tail;
Lisp_Object prev;
if (! CONSP (Vframe_list))
abort ();
prev = Qnil;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
Lisp_Object f;
f = XCAR (tail);
if (!FRAMEP (f))
abort ();
if (EQ (frame, f) && !NILP (prev))
return prev;
if (FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
{
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;
}
}
if (NILP (prev))
return frame;
else
return prev;
}
DEFUN ("next-frame", Fnext_frame, Snext_frame, 0, 2, 0,
doc: )
(frame, miniframe)
Lisp_Object frame, miniframe;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
return next_frame (frame, miniframe);
}
DEFUN ("previous-frame", Fprevious_frame, Sprevious_frame, 0, 2, 0,
doc: )
(frame, miniframe)
Lisp_Object frame, miniframe;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
return prev_frame (frame, miniframe);
}
int
other_visible_frames (f)
FRAME_PTR f;
{
if (f == SELECTED_FRAME ())
{
Lisp_Object frames;
int count = 0;
for (frames = Vframe_list;
CONSP (frames);
frames = XCDR (frames))
{
Lisp_Object this;
this = XCAR (frames);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (this)))
{
x_sync (XFRAME (this));
FRAME_SAMPLE_VISIBILITY (XFRAME (this));
}
#endif
if (FRAME_VISIBLE_P (XFRAME (this))
|| FRAME_ICONIFIED_P (XFRAME (this))
|| (FRAME_WINDOW_P (XFRAME (this)) && !FRAME_WINDOW_P (f)))
count++;
}
return count > 1;
}
return 1;
}
DEFUN ("delete-frame", Fdelete_frame, Sdelete_frame, 0, 2, "",
doc: )
(frame, force)
Lisp_Object frame, force;
{
struct frame *f;
struct frame *sf = SELECTED_FRAME ();
int minibuffer_selected;
if (EQ (frame, Qnil))
{
f = sf;
XSETFRAME (frame, f);
}
else
{
CHECK_FRAME (frame);
f = XFRAME (frame);
}
if (! FRAME_LIVE_P (f))
return Qnil;
if (NILP (force) && !other_visible_frames (f)
#ifdef MAC_OS8
&& strcmp (SDATA (f->name), "F1") != 0
#endif
)
error ("Attempt to delete the sole visible or iconified frame");
#if 0
if (NILP (XCDR (Vframe_list)))
error ("Attempt to delete the only frame");
#endif
if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
{
Lisp_Object frames;
for (frames = Vframe_list;
CONSP (frames);
frames = XCDR (frames))
{
Lisp_Object this;
this = XCAR (frames);
if (! EQ (this, frame)
&& EQ (frame,
WINDOW_FRAME (XWINDOW
(FRAME_MINIBUF_WINDOW (XFRAME (this))))))
error ("Attempt to delete a surrogate minibuffer frame");
}
}
if (!NILP (Vrun_hooks)
&& NILP (Fframe_parameter (frame, intern ("tooltip"))))
{
Lisp_Object args[2];
args[0] = intern ("delete-frame-functions");
args[1] = frame;
Frun_hook_with_args (2, args);
}
minibuffer_selected = EQ (minibuf_window, selected_window);
if (f == sf)
{
Lisp_Object tail, frame1;
frame1 = next_frame (frame, Qvisible);
if (NILP (frame1) || EQ (frame1, frame))
{
FOR_EACH_FRAME (tail, frame1)
{
if (! EQ (frame, frame1))
break;
}
}
do_switch_frame (frame1, 0, 1);
sf = SELECTED_FRAME ();
}
if (EQ (f->minibuffer_window, minibuf_window))
{
Fset_window_buffer (sf->minibuffer_window,
XWINDOW (minibuf_window)->buffer, Qnil);
minibuf_window = sf->minibuffer_window;
if (minibuffer_selected)
Fselect_window (minibuf_window, Qnil);
}
if (EQ (f->minibuffer_window, echo_area_window))
echo_area_window = sf->minibuffer_window;
#ifdef HAVE_X_WINDOWS
if (FRAME_X_P (f))
x_clear_frame_selections (f);
#endif
#ifdef MAC_OS
if (FRAME_MAC_P (f))
x_clear_frame_selections (f);
#endif
free_glyphs (f);
delete_all_subwindows (XWINDOW (f->root_window));
f->root_window = Qnil;
Vframe_list = Fdelq (frame, Vframe_list);
FRAME_SET_VISIBLE (f, 0);
if (f->namebuf)
xfree (f->namebuf);
if (f->decode_mode_spec_buffer)
xfree (f->decode_mode_spec_buffer);
if (FRAME_INSERT_COST (f))
xfree (FRAME_INSERT_COST (f));
if (FRAME_DELETEN_COST (f))
xfree (FRAME_DELETEN_COST (f));
if (FRAME_INSERTN_COST (f))
xfree (FRAME_INSERTN_COST (f));
if (FRAME_DELETE_COST (f))
xfree (FRAME_DELETE_COST (f));
if (FRAME_MESSAGE_BUF (f))
xfree (FRAME_MESSAGE_BUF (f));
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_destroy_window (f);
#endif
f->output_data.nothing = 0;
if (f == last_nonminibuf_frame)
{
Lisp_Object frames;
last_nonminibuf_frame = 0;
for (frames = Vframe_list;
CONSP (frames);
frames = XCDR (frames))
{
f = XFRAME (XCAR (frames));
if (!FRAME_MINIBUF_ONLY_P (f))
{
last_nonminibuf_frame = f;
break;
}
}
}
{
Lisp_Object frames;
Lisp_Object frame_on_same_kboard;
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 (FRAME_KBOARD (f) == FRAME_KBOARD (f1))
frame_on_same_kboard = this;
}
if (NILP (frame_on_same_kboard))
not_single_kboard_state (FRAME_KBOARD (f));
}
if (EQ (frame, FRAME_KBOARD (f)->Vdefault_minibuffer_frame))
{
Lisp_Object frames;
Lisp_Object frame_with_minibuf;
Lisp_Object frame_on_same_kboard;
frame_on_same_kboard = Qnil;
frame_with_minibuf = Qnil;
for (frames = Vframe_list;
CONSP (frames);
frames = XCDR (frames))
{
Lisp_Object this;
struct frame *f1;
this = XCAR (frames);
if (!FRAMEP (this))
abort ();
f1 = XFRAME (this);
if (FRAME_KBOARD (f) == FRAME_KBOARD (f1)
&& FRAME_HAS_MINIBUF_P (f1))
{
frame_with_minibuf = this;
if (FRAME_MINIBUF_ONLY_P (f1))
break;
}
if (FRAME_KBOARD (f) == FRAME_KBOARD (f1))
frame_on_same_kboard = this;
}
if (!NILP (frame_on_same_kboard))
{
if (NILP (frame_with_minibuf))
abort ();
FRAME_KBOARD (f)->Vdefault_minibuffer_frame = frame_with_minibuf;
}
else
FRAME_KBOARD (f)->Vdefault_minibuffer_frame = Qnil;
}
update_mode_lines = 1;
return Qnil;
}
DEFUN ("mouse-position", Fmouse_position, Smouse_position, 0, 0, 0,
doc: )
()
{
FRAME_PTR f;
Lisp_Object lispy_dummy;
enum scroll_bar_part party_dummy;
Lisp_Object x, y, retval;
int col, row;
unsigned long long_dummy;
struct gcpro gcpro1;
f = SELECTED_FRAME ();
x = y = Qnil;
#ifdef HAVE_MOUSE
if (mouse_position_hook)
(*mouse_position_hook) (&f, -1,
&lispy_dummy, &party_dummy,
&x, &y,
&long_dummy);
if (! NILP (x))
{
col = XINT (x);
row = XINT (y);
pixel_to_glyph_coords (f, col, row, &col, &row, NULL, 1);
XSETINT (x, col);
XSETINT (y, row);
}
#endif
XSETFRAME (lispy_dummy, f);
retval = Fcons (lispy_dummy, Fcons (x, y));
GCPRO1 (retval);
if (!NILP (Vmouse_position_function))
retval = call1 (Vmouse_position_function, retval);
RETURN_UNGCPRO (retval);
}
DEFUN ("mouse-pixel-position", Fmouse_pixel_position,
Smouse_pixel_position, 0, 0, 0,
doc: )
()
{
FRAME_PTR f;
Lisp_Object lispy_dummy;
enum scroll_bar_part party_dummy;
Lisp_Object x, y;
unsigned long long_dummy;
f = SELECTED_FRAME ();
x = y = Qnil;
#ifdef HAVE_MOUSE
if (mouse_position_hook)
(*mouse_position_hook) (&f, -1,
&lispy_dummy, &party_dummy,
&x, &y,
&long_dummy);
#endif
XSETFRAME (lispy_dummy, f);
return Fcons (lispy_dummy, Fcons (x, y));
}
DEFUN ("set-mouse-position", Fset_mouse_position, Sset_mouse_position, 3, 3, 0,
doc: )
(frame, x, y)
Lisp_Object frame, x, y;
{
CHECK_LIVE_FRAME (frame);
CHECK_NUMBER (x);
CHECK_NUMBER (y);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
x_set_mouse_position (XFRAME (frame), XINT (x), XINT (y));
#else
#if defined (MSDOS) && defined (HAVE_MOUSE)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame);
mouse_moveto (XINT (x), XINT (y));
}
#endif
#endif
return Qnil;
}
DEFUN ("set-mouse-pixel-position", Fset_mouse_pixel_position,
Sset_mouse_pixel_position, 3, 3, 0,
doc: )
(frame, x, y)
Lisp_Object frame, x, y;
{
CHECK_LIVE_FRAME (frame);
CHECK_NUMBER (x);
CHECK_NUMBER (y);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
x_set_mouse_pixel_position (XFRAME (frame), XINT (x), XINT (y));
#else
#if defined (MSDOS) && defined (HAVE_MOUSE)
if (FRAME_MSDOS_P (XFRAME (frame)))
{
Fselect_frame (frame);
mouse_moveto (XINT (x), XINT (y));
}
#endif
#endif
return Qnil;
}
static void make_frame_visible_1 P_ ((Lisp_Object));
DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
0, 1, "",
doc: )
(frame)
Lisp_Object frame;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
{
FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
x_make_frame_visible (XFRAME (frame));
}
#endif
make_frame_visible_1 (XFRAME (frame)->root_window);
windows_or_buffers_changed++;
return frame;
}
static void
make_frame_visible_1 (window)
Lisp_Object window;
{
struct window *w;
for (;!NILP (window); window = w->next)
{
w = XWINDOW (window);
if (!NILP (w->buffer))
XBUFFER (w->buffer)->display_time = Fcurrent_time ();
if (!NILP (w->vchild))
make_frame_visible_1 (w->vchild);
if (!NILP (w->hchild))
make_frame_visible_1 (w->hchild);
}
}
DEFUN ("make-frame-invisible", Fmake_frame_invisible, Smake_frame_invisible,
0, 2, "",
doc: )
(frame, force)
Lisp_Object frame, force;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
if (NILP (force) && !other_visible_frames (XFRAME (frame)))
error ("Attempt to make invisible the sole visible or iconified frame");
#if 0
if (EQ (frame, selected_frame))
do_switch_frame (next_frame (frame, Qt), 0, 0)
#endif
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;
}
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
x_make_frame_invisible (XFRAME (frame));
#endif
windows_or_buffers_changed++;
return Qnil;
}
DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
0, 1, "",
doc: )
(frame)
Lisp_Object frame;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
#if 0
if (EQ (frame, selected_frame))
Fhandle_switch_frame (next_frame (frame, Qt));
#endif
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;
}
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (XFRAME (frame)))
x_iconify_frame (XFRAME (frame));
#endif
windows_or_buffers_changed++;
return Qnil;
}
DEFUN ("frame-visible-p", Fframe_visible_p, Sframe_visible_p,
1, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
CHECK_LIVE_FRAME (frame);
FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
if (FRAME_VISIBLE_P (XFRAME (frame)))
return Qt;
if (FRAME_ICONIFIED_P (XFRAME (frame)))
return Qicon;
return Qnil;
}
DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
0, 0, 0,
doc: )
()
{
Lisp_Object tail, frame;
struct frame *f;
Lisp_Object value;
value = Qnil;
for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
{
frame = XCAR (tail);
if (!FRAMEP (frame))
continue;
f = XFRAME (frame);
if (FRAME_VISIBLE_P (f))
value = Fcons (frame, value);
}
return value;
}
DEFUN ("raise-frame", Fraise_frame, Sraise_frame, 0, 1, "",
doc: )
(frame)
Lisp_Object frame;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
Fmake_frame_visible (frame);
if (frame_raise_lower_hook)
(*frame_raise_lower_hook) (XFRAME (frame), 1);
return Qnil;
}
DEFUN ("lower-frame", Flower_frame, Slower_frame, 0, 1, "",
doc: )
(frame)
Lisp_Object frame;
{
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
if (frame_raise_lower_hook)
(*frame_raise_lower_hook) (XFRAME (frame), 0);
return Qnil;
}
DEFUN ("redirect-frame-focus", Fredirect_frame_focus, Sredirect_frame_focus,
1, 2, 0,
doc: )
(frame, focus_frame)
Lisp_Object frame, focus_frame;
{
CHECK_FRAME (frame);
if (! NILP (focus_frame))
CHECK_LIVE_FRAME (focus_frame);
XFRAME (frame)->focus_frame = focus_frame;
if (frame_rehighlight_hook)
(*frame_rehighlight_hook) (XFRAME (frame));
return Qnil;
}
DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
CHECK_LIVE_FRAME (frame);
return FRAME_FOCUS_FRAME (XFRAME (frame));
}
Lisp_Object
get_frame_param (frame, prop)
register struct frame *frame;
Lisp_Object prop;
{
register Lisp_Object tem;
tem = Fassq (prop, frame->param_alist);
if (EQ (tem, Qnil))
return tem;
return Fcdr (tem);
}
Lisp_Object
frame_buffer_predicate (frame)
Lisp_Object frame;
{
return XFRAME (frame)->buffer_predicate;
}
Lisp_Object
frame_buffer_list (frame)
Lisp_Object frame;
{
return XFRAME (frame)->buffer_list;
}
void
set_frame_buffer_list (frame, list)
Lisp_Object frame, list;
{
XFRAME (frame)->buffer_list = list;
}
void
frames_discard_buffer (buffer)
Lisp_Object buffer;
{
Lisp_Object frame, tail;
FOR_EACH_FRAME (tail, frame)
{
XFRAME (frame)->buffer_list
= Fdelq (buffer, XFRAME (frame)->buffer_list);
}
}
void
store_in_alist (alistptr, prop, val)
Lisp_Object *alistptr, val;
Lisp_Object prop;
{
register Lisp_Object tem;
tem = Fassq (prop, *alistptr);
if (EQ (tem, Qnil))
*alistptr = Fcons (Fcons (prop, val), *alistptr);
else
Fsetcdr (tem, val);
}
static int
frame_name_fnn_p (str, len)
char *str;
int len;
{
if (len > 1 && str[0] == 'F')
{
char *end_ptr;
strtol (str + 1, &end_ptr, 10);
if (end_ptr == str + len)
return 1;
}
return 0;
}
static void
set_term_frame_name (f, name)
struct frame *f;
Lisp_Object name;
{
f->explicit_name = ! NILP (name);
if (NILP (name))
{
char namebuf[20];
if (frame_name_fnn_p (SDATA (f->name),
SBYTES (f->name)))
return;
terminal_frame_count++;
sprintf (namebuf, "F%d", terminal_frame_count);
name = build_string (namebuf);
}
else
{
CHECK_STRING (name);
if (! NILP (Fstring_equal (name, f->name)))
return;
if (frame_name_fnn_p (SDATA (name), SBYTES (name)))
error ("Frame names of the form F<num> are usurped by Emacs");
}
f->name = name;
update_mode_lines = 1;
}
void
store_frame_param (f, prop, val)
struct frame *f;
Lisp_Object prop, val;
{
register Lisp_Object old_alist_elt;
if (EQ (prop, Qbuffer_list))
{
f->buffer_list = val;
return;
}
if (SYMBOLP (prop))
{
Lisp_Object valcontents;
valcontents = SYMBOL_VALUE (prop);
if ((BUFFER_LOCAL_VALUEP (valcontents)
|| SOME_BUFFER_LOCAL_VALUEP (valcontents))
&& XBUFFER_LOCAL_VALUE (valcontents)->check_frame
&& XFRAME (XBUFFER_LOCAL_VALUE (valcontents)->frame) == f)
swap_in_global_binding (prop);
}
#ifndef WINDOWSNT
if (FRAME_TERMCAP_P (f) && EQ (prop, Qtty_color_mode))
set_tty_color_mode (f, val);
#endif
old_alist_elt = Fassq (prop, f->param_alist);
if (EQ (old_alist_elt, Qnil))
f->param_alist = Fcons (Fcons (prop, val), f->param_alist);
else
Fsetcdr (old_alist_elt, val);
if (EQ (prop, Qbuffer_predicate))
f->buffer_predicate = val;
if (! FRAME_WINDOW_P (f))
{
if (EQ (prop, Qmenu_bar_lines))
set_menu_bar_lines (f, val, make_number (FRAME_MENU_BAR_LINES (f)));
else if (EQ (prop, Qname))
set_term_frame_name (f, val);
}
if (EQ (prop, Qminibuffer) && WINDOWP (val))
{
if (! MINI_WINDOW_P (XWINDOW (val)))
error ("Surrogate minibuffer windows must be minibuffer windows");
if ((FRAME_HAS_MINIBUF_P (f) || FRAME_MINIBUF_ONLY_P (f))
&& !EQ (val, f->minibuffer_window))
error ("Can't change the surrogate minibuffer of a frame with its own minibuffer");
f->minibuffer_window = val;
}
}
DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
Lisp_Object alist;
FRAME_PTR f;
int height, width;
struct gcpro gcpro1;
if (NILP (frame))
frame = selected_frame;
CHECK_FRAME (frame);
f = XFRAME (frame);
if (!FRAME_LIVE_P (f))
return Qnil;
alist = Fcopy_alist (f->param_alist);
GCPRO1 (alist);
if (!FRAME_WINDOW_P (f))
{
int fg = FRAME_FOREGROUND_PIXEL (f);
int bg = FRAME_BACKGROUND_PIXEL (f);
Lisp_Object elt;
elt = Fassq (Qforeground_color, alist);
if (!NILP (elt) && CONSP (elt) && STRINGP (XCDR (elt)))
{
if (strncmp (SDATA (XCDR (elt)),
unspecified_bg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qforeground_color, tty_color_name (f, bg));
else if (strncmp (SDATA (XCDR (elt)),
unspecified_fg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
}
else
store_in_alist (&alist, Qforeground_color, tty_color_name (f, fg));
elt = Fassq (Qbackground_color, alist);
if (!NILP (elt) && CONSP (elt) && STRINGP (XCDR (elt)))
{
if (strncmp (SDATA (XCDR (elt)),
unspecified_fg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qbackground_color, tty_color_name (f, fg));
else if (strncmp (SDATA (XCDR (elt)),
unspecified_bg,
SCHARS (XCDR (elt))) == 0)
store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
}
else
store_in_alist (&alist, Qbackground_color, tty_color_name (f, bg));
store_in_alist (&alist, intern ("font"),
build_string (FRAME_MSDOS_P (f)
? "ms-dos"
: FRAME_W32_P (f) ? "w32term"
:"tty"));
}
store_in_alist (&alist, Qname, f->name);
height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
store_in_alist (&alist, Qheight, make_number (height));
width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
store_in_alist (&alist, Qwidth, make_number (width));
store_in_alist (&alist, Qmodeline, (FRAME_WANTS_MODELINE_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qminibuffer,
(! FRAME_HAS_MINIBUF_P (f) ? Qnil
: FRAME_MINIBUF_ONLY_P (f) ? Qonly
: FRAME_MINIBUF_WINDOW (f)));
store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_report_frame_params (f, &alist);
else
#endif
{
Lisp_Object lines;
XSETFASTINT (lines, FRAME_MENU_BAR_LINES (f));
store_in_alist (&alist, Qmenu_bar_lines, lines);
}
UNGCPRO;
return alist;
}
DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
doc: )
(frame, parameter)
Lisp_Object frame, parameter;
{
struct frame *f;
Lisp_Object value;
if (NILP (frame))
frame = selected_frame;
else
CHECK_FRAME (frame);
CHECK_SYMBOL (parameter);
f = XFRAME (frame);
value = Qnil;
if (FRAME_LIVE_P (f))
{
if (EQ (parameter, Qname))
value = f->name;
#ifdef HAVE_X_WINDOWS
else if (EQ (parameter, Qdisplay) && FRAME_X_P (f))
value = XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element);
#endif
else if (EQ (parameter, Qbackground_color)
|| EQ (parameter, Qforeground_color))
{
value = Fassq (parameter, f->param_alist);
if (CONSP (value))
{
value = XCDR (value);
if (STRINGP (value) && !FRAME_WINDOW_P (f))
{
const char *color_name;
EMACS_INT csz;
if (EQ (parameter, Qbackground_color))
{
color_name = SDATA (value);
csz = SCHARS (value);
if (strncmp (color_name, unspecified_bg, csz) == 0)
value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
else if (strncmp (color_name, unspecified_fg, csz) == 0)
value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
}
else if (EQ (parameter, Qforeground_color))
{
color_name = SDATA (value);
csz = SCHARS (value);
if (strncmp (color_name, unspecified_fg, csz) == 0)
value = tty_color_name (f, FRAME_FOREGROUND_PIXEL (f));
else if (strncmp (color_name, unspecified_bg, csz) == 0)
value = tty_color_name (f, FRAME_BACKGROUND_PIXEL (f));
}
}
}
else
value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
}
else if (EQ (parameter, Qdisplay_type)
|| EQ (parameter, Qbackground_mode))
value = Fcdr (Fassq (parameter, f->param_alist));
else
value = Fcdr (Fassq (parameter, Fframe_parameters (frame)));
}
return value;
}
DEFUN ("modify-frame-parameters", Fmodify_frame_parameters,
Smodify_frame_parameters, 2, 2, 0,
doc: )
(frame, alist)
Lisp_Object frame, alist;
{
FRAME_PTR f;
register Lisp_Object tail, prop, val;
if (EQ (frame, Qnil))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_set_frame_parameters (f, alist);
else
#endif
#ifdef MSDOS
if (FRAME_MSDOS_P (f))
IT_set_frame_parameters (f, alist);
else
#endif
{
int length = XINT (Flength (alist));
int i;
Lisp_Object *parms
= (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
Lisp_Object *values
= (Lisp_Object *) alloca (length * sizeof (Lisp_Object));
i = 0;
for (tail = alist; CONSP (tail); tail = Fcdr (tail))
{
Lisp_Object elt;
elt = Fcar (tail);
parms[i] = Fcar (elt);
values[i] = Fcdr (elt);
i++;
}
for (i--; i >= 0; i--)
{
prop = parms[i];
val = values[i];
store_frame_param (f, prop, val);
if (EQ (prop, Qbackground_color))
call1 (Qframe_set_background_mode, frame);
}
}
return Qnil;
}
DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
struct frame *f;
if (NILP (frame))
frame = selected_frame;
CHECK_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (x_char_height (f));
else
#endif
return make_number (1);
}
DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
struct frame *f;
if (NILP (frame))
frame = selected_frame;
CHECK_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (x_char_width (f));
else
#endif
return make_number (1);
}
DEFUN ("frame-pixel-height", Fframe_pixel_height,
Sframe_pixel_height, 0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
struct frame *f;
if (NILP (frame))
frame = selected_frame;
CHECK_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (x_pixel_height (f));
else
#endif
return make_number (FRAME_LINES (f));
}
DEFUN ("frame-pixel-width", Fframe_pixel_width,
Sframe_pixel_width, 0, 1, 0,
doc: )
(frame)
Lisp_Object frame;
{
struct frame *f;
if (NILP (frame))
frame = selected_frame;
CHECK_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
return make_number (x_pixel_width (f));
else
#endif
return make_number (FRAME_COLS (f));
}
DEFUN ("set-frame-height", Fset_frame_height, Sset_frame_height, 2, 3, 0,
doc: )
(frame, lines, pretend)
Lisp_Object frame, lines, pretend;
{
register struct frame *f;
CHECK_NUMBER (lines);
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
if (XINT (lines) != FRAME_LINES (f))
x_set_window_size (f, 1, FRAME_COLS (f), XINT (lines));
do_pending_window_change (0);
}
else
#endif
change_frame_size (f, XINT (lines), 0, !NILP (pretend), 0, 0);
return Qnil;
}
DEFUN ("set-frame-width", Fset_frame_width, Sset_frame_width, 2, 3, 0,
doc: )
(frame, cols, pretend)
Lisp_Object frame, cols, pretend;
{
register struct frame *f;
CHECK_NUMBER (cols);
if (NILP (frame))
frame = selected_frame;
CHECK_LIVE_FRAME (frame);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
if (XINT (cols) != FRAME_COLS (f))
x_set_window_size (f, 1, XINT (cols), FRAME_LINES (f));
do_pending_window_change (0);
}
else
#endif
change_frame_size (f, 0, XINT (cols), !NILP (pretend), 0, 0);
return Qnil;
}
DEFUN ("set-frame-size", Fset_frame_size, Sset_frame_size, 3, 3, 0,
doc: )
(frame, cols, rows)
Lisp_Object frame, cols, rows;
{
register struct frame *f;
CHECK_LIVE_FRAME (frame);
CHECK_NUMBER (cols);
CHECK_NUMBER (rows);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
if (XINT (rows) != FRAME_LINES (f)
|| XINT (cols) != FRAME_COLS (f)
|| f->new_text_lines || f->new_text_cols)
x_set_window_size (f, 1, XINT (cols), XINT (rows));
do_pending_window_change (0);
}
else
#endif
change_frame_size (f, XINT (rows), XINT (cols), 0, 0, 0);
return Qnil;
}
DEFUN ("set-frame-position", Fset_frame_position,
Sset_frame_position, 3, 3, 0,
doc: )
(frame, xoffset, yoffset)
Lisp_Object frame, xoffset, yoffset;
{
register struct frame *f;
CHECK_LIVE_FRAME (frame);
CHECK_NUMBER (xoffset);
CHECK_NUMBER (yoffset);
f = XFRAME (frame);
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_set_offset (f, XINT (xoffset), XINT (yoffset), 1);
#endif
return Qt;
}
struct frame_parm_table {
char *name;
Lisp_Object *variable;
};
static struct frame_parm_table frame_parms[] =
{
{"auto-raise", &Qauto_raise},
{"auto-lower", &Qauto_lower},
{"background-color", 0},
{"border-color", &Qborder_color},
{"border-width", &Qborder_width},
{"cursor-color", &Qcursor_color},
{"cursor-type", &Qcursor_type},
{"font", 0},
{"foreground-color", 0},
{"icon-name", &Qicon_name},
{"icon-type", &Qicon_type},
{"internal-border-width", &Qinternal_border_width},
{"menu-bar-lines", &Qmenu_bar_lines},
{"mouse-color", &Qmouse_color},
{"name", &Qname},
{"scroll-bar-width", &Qscroll_bar_width},
{"title", &Qtitle},
{"unsplittable", &Qunsplittable},
{"vertical-scroll-bars", &Qvertical_scroll_bars},
{"visibility", &Qvisibility},
{"tool-bar-lines", &Qtool_bar_lines},
{"scroll-bar-foreground", &Qscroll_bar_foreground},
{"scroll-bar-background", &Qscroll_bar_background},
{"screen-gamma", &Qscreen_gamma},
{"line-spacing", &Qline_spacing},
{"left-fringe", &Qleft_fringe},
{"right-fringe", &Qright_fringe},
{"wait-for-wm", &Qwait_for_wm},
{"fullscreen", &Qfullscreen},
};
#ifdef HAVE_WINDOW_SYSTEM
extern Lisp_Object Qbox;
extern Lisp_Object Qtop;
void
x_fullscreen_adjust (f, width, height, top_pos, left_pos)
struct frame *f;
int *width;
int *height;
int *top_pos;
int *left_pos;
{
int newwidth = FRAME_COLS (f);
int newheight = FRAME_LINES (f);
*top_pos = f->top_pos;
*left_pos = f->left_pos;
if (f->want_fullscreen & FULLSCREEN_HEIGHT)
{
int ph;
ph = FRAME_X_DISPLAY_INFO (f)->height;
newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
ph = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, newheight) - f->y_pixels_diff;
newheight = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, ph);
*top_pos = 0;
}
if (f->want_fullscreen & FULLSCREEN_WIDTH)
{
int pw;
pw = FRAME_X_DISPLAY_INFO (f)->width;
newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
pw = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, newwidth) - f->x_pixels_diff;
newwidth = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pw);
*left_pos = 0;
}
*width = newwidth;
*height = newheight;
}
void
x_set_frame_parameters (f, alist)
FRAME_PTR f;
Lisp_Object alist;
{
Lisp_Object tail;
int width, height;
Lisp_Object left, top;
Lisp_Object icon_left, icon_top;
Lisp_Object *parms;
Lisp_Object *values;
int i, p;
int left_no_change = 0, top_no_change = 0;
int icon_left_no_change = 0, icon_top_no_change = 0;
int fullscreen_is_being_set = 0;
struct gcpro gcpro1, gcpro2;
i = 0;
for (tail = alist; CONSP (tail); tail = Fcdr (tail))
i++;
parms = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
values = (Lisp_Object *) alloca (i * sizeof (Lisp_Object));
i = 0;
for (tail = alist; CONSP (tail); tail = Fcdr (tail))
{
Lisp_Object elt;
elt = Fcar (tail);
parms[i] = Fcar (elt);
values[i] = Fcdr (elt);
i++;
}
alist = tail = Qnil;
GCPRO2 (*parms, *values);
gcpro1.nvars = i;
gcpro2.nvars = i;
top = left = Qunbound;
icon_left = icon_top = Qunbound;
width = (f->new_text_cols ? f->new_text_cols : FRAME_COLS (f));
height = (f->new_text_lines ? f->new_text_lines : FRAME_LINES (f));
for (p = 0; p < i; p++)
{
Lisp_Object prop, val;
prop = parms[p];
val = values[p];
if (EQ (prop, Qforeground_color)
|| EQ (prop, Qbackground_color)
|| EQ (prop, Qfont)
|| EQ (prop, Qfullscreen))
{
register Lisp_Object param_index, old_value;
int count = SPECPDL_INDEX ();
old_value = get_frame_param (f, prop);
fullscreen_is_being_set |= EQ (prop, Qfullscreen);
if (NILP (Fequal (val, old_value)))
{
specbind (Qinhibit_face_set_after_frame_default, Qt);
store_frame_param (f, prop, val);
param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& (XFASTINT (param_index)
< sizeof (frame_parms)/sizeof (frame_parms[0]))
&& rif->frame_parm_handlers[XINT (param_index)])
(*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
unbind_to (count, Qnil);
}
}
}
for (i--; i >= 0; i--)
{
Lisp_Object prop, val;
prop = parms[i];
val = values[i];
if (EQ (prop, Qwidth) && NUMBERP (val))
width = XFASTINT (val);
else if (EQ (prop, Qheight) && NUMBERP (val))
height = XFASTINT (val);
else if (EQ (prop, Qtop))
top = val;
else if (EQ (prop, Qleft))
left = val;
else if (EQ (prop, Qicon_top))
icon_top = val;
else if (EQ (prop, Qicon_left))
icon_left = val;
else if (EQ (prop, Qforeground_color)
|| EQ (prop, Qbackground_color)
|| EQ (prop, Qfont)
|| EQ (prop, Qfullscreen))
continue;
else
{
register Lisp_Object param_index, old_value;
old_value = get_frame_param (f, prop);
store_frame_param (f, prop, val);
param_index = Fget (prop, Qx_frame_parameter);
if (NATNUMP (param_index)
&& (XFASTINT (param_index)
< sizeof (frame_parms)/sizeof (frame_parms[0]))
&& rif->frame_parm_handlers[XINT (param_index)])
(*(rif->frame_parm_handlers[XINT (param_index)])) (f, val, old_value);
}
}
if (EQ (left, Qunbound))
{
left_no_change = 1;
if (f->left_pos < 0)
left = Fcons (Qplus, Fcons (make_number (f->left_pos), Qnil));
else
XSETINT (left, f->left_pos);
}
if (EQ (top, Qunbound))
{
top_no_change = 1;
if (f->top_pos < 0)
top = Fcons (Qplus, Fcons (make_number (f->top_pos), Qnil));
else
XSETINT (top, f->top_pos);
}
if (EQ (icon_left, Qunbound) || ! INTEGERP (icon_left))
{
icon_left_no_change = 1;
icon_left = Fcdr (Fassq (Qicon_left, f->param_alist));
if (NILP (icon_left))
XSETINT (icon_left, 0);
}
if (EQ (icon_top, Qunbound) || ! INTEGERP (icon_top))
{
icon_top_no_change = 1;
icon_top = Fcdr (Fassq (Qicon_top, f->param_alist));
if (NILP (icon_top))
XSETINT (icon_top, 0);
}
if (FRAME_VISIBLE_P (f) && fullscreen_is_being_set)
{
int new_left, new_top;
x_fullscreen_adjust (f, &width, &height, &new_top, &new_left);
if (new_top != f->top_pos || new_left != f->left_pos)
x_set_offset (f, new_left, new_top, 1);
}
{
Lisp_Object frame;
check_frame_size (f, &height, &width);
XSETFRAME (frame, f);
if (width != FRAME_COLS (f)
|| height != FRAME_LINES (f)
|| f->new_text_lines || f->new_text_cols)
Fset_frame_size (frame, make_number (width), make_number (height));
if ((!NILP (left) || !NILP (top))
&& ! (left_no_change && top_no_change)
&& ! (NUMBERP (left) && XINT (left) == f->left_pos
&& NUMBERP (top) && XINT (top) == f->top_pos))
{
int leftpos = 0;
int toppos = 0;
f->size_hint_flags &= ~ (XNegative | YNegative);
if (EQ (left, Qminus))
f->size_hint_flags |= XNegative;
else if (INTEGERP (left))
{
leftpos = XINT (left);
if (leftpos < 0)
f->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qminus)
&& CONSP (XCDR (left))
&& INTEGERP (XCAR (XCDR (left))))
{
leftpos = - XINT (XCAR (XCDR (left)));
f->size_hint_flags |= XNegative;
}
else if (CONSP (left) && EQ (XCAR (left), Qplus)
&& CONSP (XCDR (left))
&& INTEGERP (XCAR (XCDR (left))))
{
leftpos = XINT (XCAR (XCDR (left)));
}
if (EQ (top, Qminus))
f->size_hint_flags |= YNegative;
else if (INTEGERP (top))
{
toppos = XINT (top);
if (toppos < 0)
f->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qminus)
&& CONSP (XCDR (top))
&& INTEGERP (XCAR (XCDR (top))))
{
toppos = - XINT (XCAR (XCDR (top)));
f->size_hint_flags |= YNegative;
}
else if (CONSP (top) && EQ (XCAR (top), Qplus)
&& CONSP (XCDR (top))
&& INTEGERP (XCAR (XCDR (top))))
{
toppos = XINT (XCAR (XCDR (top)));
}
f->top_pos = toppos;
f->left_pos = leftpos;
f->win_gravity = NorthWestGravity;
x_set_offset (f, leftpos, toppos, -1);
}
if ((!NILP (icon_left) || !NILP (icon_top))
&& ! (icon_left_no_change && icon_top_no_change))
x_wm_set_icon_position (f, XINT (icon_left), XINT (icon_top));
}
UNGCPRO;
}
void
x_report_frame_params (f, alistptr)
struct frame *f;
Lisp_Object *alistptr;
{
char buf[16];
Lisp_Object tem;
XSETINT (tem, f->left_pos);
if (f->left_pos >= 0)
store_in_alist (alistptr, Qleft, tem);
else
store_in_alist (alistptr, Qleft, Fcons (Qplus, Fcons (tem, Qnil)));
XSETINT (tem, f->top_pos);
if (f->top_pos >= 0)
store_in_alist (alistptr, Qtop, tem);
else
store_in_alist (alistptr, Qtop, Fcons (Qplus, Fcons (tem, Qnil)));
store_in_alist (alistptr, Qborder_width,
make_number (f->border_width));
store_in_alist (alistptr, Qinternal_border_width,
make_number (FRAME_INTERNAL_BORDER_WIDTH (f)));
store_in_alist (alistptr, Qleft_fringe,
make_number (FRAME_LEFT_FRINGE_WIDTH (f)));
store_in_alist (alistptr, Qright_fringe,
make_number (FRAME_RIGHT_FRINGE_WIDTH (f)));
store_in_alist (alistptr, Qscroll_bar_width,
(! FRAME_HAS_VERTICAL_SCROLL_BARS (f)
? make_number (0)
: FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
? make_number (FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
: Qnil));
sprintf (buf, "%ld", (long) FRAME_X_WINDOW (f));
store_in_alist (alistptr, Qwindow_id,
build_string (buf));
#ifdef HAVE_X_WINDOWS
#ifdef USE_X_TOOLKIT
if (FRAME_X_OUTPUT (f)->widget)
#endif
sprintf (buf, "%ld", (long) FRAME_OUTER_WINDOW (f));
store_in_alist (alistptr, Qouter_window_id,
build_string (buf));
#endif
store_in_alist (alistptr, Qicon_name, f->icon_name);
FRAME_SAMPLE_VISIBILITY (f);
store_in_alist (alistptr, Qvisibility,
(FRAME_VISIBLE_P (f) ? Qt
: FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
store_in_alist (alistptr, Qdisplay,
XCAR (FRAME_X_DISPLAY_INFO (f)->name_list_element));
if (FRAME_X_OUTPUT (f)->parent_desc == FRAME_X_DISPLAY_INFO (f)->root_window)
tem = Qnil;
else
XSETFASTINT (tem, FRAME_X_OUTPUT (f)->parent_desc);
store_in_alist (alistptr, Qparent_id, tem);
}
void
x_set_fullscreen (f, new_value, old_value)
struct frame *f;
Lisp_Object new_value, old_value;
{
if (NILP (new_value))
f->want_fullscreen = FULLSCREEN_NONE;
else if (EQ (new_value, Qfullboth))
f->want_fullscreen = FULLSCREEN_BOTH;
else if (EQ (new_value, Qfullwidth))
f->want_fullscreen = FULLSCREEN_WIDTH;
else if (EQ (new_value, Qfullheight))
f->want_fullscreen = FULLSCREEN_HEIGHT;
if (fullscreen_hook != NULL)
fullscreen_hook (f);
}
void
x_set_line_spacing (f, new_value, old_value)
struct frame *f;
Lisp_Object new_value, old_value;
{
if (NILP (new_value))
f->extra_line_spacing = 0;
else if (NATNUMP (new_value))
f->extra_line_spacing = XFASTINT (new_value);
else
signal_error ("Invalid line-spacing", new_value);
if (FRAME_VISIBLE_P (f))
redraw_frame (f);
}
void
x_set_screen_gamma (f, new_value, old_value)
struct frame *f;
Lisp_Object new_value, old_value;
{
Lisp_Object bgcolor;
if (NILP (new_value))
f->gamma = 0;
else if (NUMBERP (new_value) && XFLOATINT (new_value) > 0)
f->gamma = 1.0 / (0.4545 * XFLOATINT (new_value));
else
signal_error ("Invalid screen-gamma", new_value);
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)
< sizeof (frame_parms)/sizeof (frame_parms[0]))
&& rif->frame_parm_handlers[XFASTINT (index)])
(*(rif->frame_parm_handlers[XFASTINT (index)]))
(f, bgcolor, Qnil);
}
Fclear_face_cache (Qnil);
}
void
x_set_font (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
Lisp_Object result;
Lisp_Object fontset_name;
Lisp_Object frame;
int old_fontset = FRAME_FONTSET(f);
CHECK_STRING (arg);
fontset_name = Fquery_fontset (arg, Qnil);
BLOCK_INPUT;
result = (STRINGP (fontset_name)
? x_new_fontset (f, SDATA (fontset_name))
: x_new_font (f, SDATA (arg)));
UNBLOCK_INPUT;
if (EQ (result, Qnil))
error ("Font `%s' is not defined", SDATA (arg));
else if (EQ (result, Qt))
error ("The characters of the given font have varying widths");
else if (STRINGP (result))
{
set_default_ascii_font (result);
if (STRINGP (fontset_name))
{
if (old_fontset == FRAME_FONTSET (f))
return;
}
else if (!NILP (Fequal (result, oldval)))
return;
f->n_tool_bar_rows = 0;
clear_current_matrices (f);
store_frame_param (f, Qfont, result);
recompute_basic_faces (f);
}
else
abort ();
do_pending_window_change (0);
if (FRAME_FACE_CACHE (f))
{
XSETFRAME (frame, f);
call1 (Qface_set_after_frame_default, frame);
}
}
void
x_set_fringe_width (f, new_value, old_value)
struct frame *f;
Lisp_Object new_value, old_value;
{
compute_fringe_widths (f, 1);
}
void
x_set_border_width (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
CHECK_NUMBER (arg);
if (XINT (arg) == f->border_width)
return;
if (FRAME_X_WINDOW (f) != 0)
error ("Cannot change the border width of a frame");
f->border_width = XINT (arg);
}
void
x_set_internal_border_width (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
int old = FRAME_INTERNAL_BORDER_WIDTH (f);
CHECK_NUMBER (arg);
FRAME_INTERNAL_BORDER_WIDTH (f) = XINT (arg);
if (FRAME_INTERNAL_BORDER_WIDTH (f) < 0)
FRAME_INTERNAL_BORDER_WIDTH (f) = 0;
#ifdef USE_X_TOOLKIT
if (FRAME_X_OUTPUT (f)->edit_widget)
widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
#endif
if (FRAME_INTERNAL_BORDER_WIDTH (f) == old)
return;
if (FRAME_X_WINDOW (f) != 0)
{
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
SET_FRAME_GARBAGED (f);
do_pending_window_change (0);
}
else
SET_FRAME_GARBAGED (f);
}
void
x_set_visibility (f, value, oldval)
struct frame *f;
Lisp_Object value, oldval;
{
Lisp_Object frame;
XSETFRAME (frame, f);
if (NILP (value))
Fmake_frame_invisible (frame, Qt);
else if (EQ (value, Qicon))
Ficonify_frame (frame);
else
Fmake_frame_visible (frame);
}
void
x_set_autoraise (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
f->auto_raise = !EQ (Qnil, arg);
}
void
x_set_autolower (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
f->auto_lower = !EQ (Qnil, arg);
}
void
x_set_unsplittable (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
f->no_split = !NILP (arg);
}
void
x_set_vertical_scroll_bars (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
if ((EQ (arg, Qleft) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
|| (EQ (arg, Qright) && FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (f))
|| (NILP (arg) && FRAME_HAS_VERTICAL_SCROLL_BARS (f))
|| (!NILP (arg) && ! FRAME_HAS_VERTICAL_SCROLL_BARS (f)))
{
FRAME_VERTICAL_SCROLL_BAR_TYPE (f)
= (NILP (arg)
? vertical_scroll_bar_none
: EQ (Qleft, arg)
? vertical_scroll_bar_left
: EQ (Qright, arg)
? vertical_scroll_bar_right
: EQ (Qleft, Vdefault_frame_scroll_bars)
? vertical_scroll_bar_left
: EQ (Qright, Vdefault_frame_scroll_bars)
? vertical_scroll_bar_right
: vertical_scroll_bar_none);
if (FRAME_X_WINDOW (f))
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
do_pending_window_change (0);
}
}
void
x_set_scroll_bar_width (f, arg, oldval)
struct frame *f;
Lisp_Object arg, oldval;
{
int wid = FRAME_COLUMN_WIDTH (f);
if (NILP (arg))
{
x_set_scroll_bar_default_width (f);
if (FRAME_X_WINDOW (f))
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
do_pending_window_change (0);
}
else if (INTEGERP (arg) && XINT (arg) > 0
&& XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f))
{
if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM)
XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1);
FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg);
FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid;
if (FRAME_X_WINDOW (f))
x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
do_pending_window_change (0);
}
change_frame_size (f, 0, FRAME_COLS (f), 0, 0, 0);
XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.hpos = 0;
XWINDOW (FRAME_SELECTED_WINDOW (f))->cursor.x = 0;
}
Lisp_Object
x_icon_type (f)
FRAME_PTR f;
{
Lisp_Object tem;
tem = assq_no_quit (Qicon_type, f->param_alist);
if (CONSP (tem))
return XCDR (tem);
else
return Qnil;
}
void
validate_x_resource_name ()
{
int len = 0;
int good_count = 0;
int bad_count = 0;
Lisp_Object new;
int i;
if (!STRINGP (Vx_resource_class))
Vx_resource_class = build_string (EMACS_CLASS);
if (STRINGP (Vx_resource_name))
{
unsigned char *p = SDATA (Vx_resource_name);
int i;
len = SBYTES (Vx_resource_name);
for (i = 0; i < len; i++)
{
int c = p[i];
if (! ((c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9')
|| c == '-' || c == '_'))
bad_count++;
else
good_count++;
}
}
else
bad_count = 5, good_count = 0;
if (bad_count == 0)
return;
if (good_count == 0
|| (good_count == 1 && bad_count > 0))
{
Vx_resource_name = build_string ("emacs");
return;
}
Vx_resource_name = new = Fcopy_sequence (Vx_resource_name);
for (i = 0; i < len; i++)
{
int c = SREF (new, i);
if (! ((c >= 'a' && c <= 'z')
|| (c >= 'A' && c <= 'Z')
|| (c >= '0' && c <= '9')
|| c == '-' || c == '_'))
SSET (new, i, '_');
}
}
extern char *x_get_string_resource P_ ((XrmDatabase, char *, char *));
extern Display_Info *check_x_display_info P_ ((Lisp_Object));
static Lisp_Object
xrdb_get_resource (rdb, attribute, class, component, subclass)
XrmDatabase rdb;
Lisp_Object attribute, class, component, subclass;
{
register char *value;
char *name_key;
char *class_key;
CHECK_STRING (attribute);
CHECK_STRING (class);
if (!NILP (component))
CHECK_STRING (component);
if (!NILP (subclass))
CHECK_STRING (subclass);
if (NILP (component) != NILP (subclass))
error ("x-get-resource: must specify both COMPONENT and SUBCLASS or neither");
validate_x_resource_name ();
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);
strcpy (name_key, SDATA (Vx_resource_name));
strcpy (class_key, SDATA (Vx_resource_class));
strcat (class_key, ".");
strcat (class_key, SDATA (class));
if (!NILP (component))
{
strcat (class_key, ".");
strcat (class_key, SDATA (subclass));
strcat (name_key, ".");
strcat (name_key, SDATA (component));
}
strcat (name_key, ".");
strcat (name_key, SDATA (attribute));
value = x_get_string_resource (rdb, name_key, class_key);
if (value != (char *) 0)
return build_string (value);
else
return Qnil;
}
DEFUN ("x-get-resource", Fx_get_resource, Sx_get_resource, 2, 4, 0,
doc: )
(attribute, class, component, subclass)
Lisp_Object attribute, class, component, subclass;
{
#ifdef HAVE_X_WINDOWS
check_x ();
#endif
return xrdb_get_resource (check_x_display_info (Qnil)->xrdb,
attribute, class, component, subclass);
}
Lisp_Object
display_x_get_resource (dpyinfo, attribute, class, component, subclass)
Display_Info *dpyinfo;
Lisp_Object attribute, class, component, subclass;
{
return xrdb_get_resource (dpyinfo->xrdb,
attribute, class, component, subclass);
}
char *
x_get_resource_string (attribute, class)
char *attribute, *class;
{
char *name_key;
char *class_key;
struct frame *sf = SELECTED_FRAME ();
name_key = (char *) alloca (SBYTES (Vinvocation_name)
+ strlen (attribute) + 2);
class_key = (char *) alloca ((sizeof (EMACS_CLASS) - 1)
+ strlen (class) + 2);
sprintf (name_key, "%s.%s", SDATA (Vinvocation_name), attribute);
sprintf (class_key, "%s.%s", EMACS_CLASS, class);
return x_get_string_resource (FRAME_X_DISPLAY_INFO (sf)->xrdb,
name_key, class_key);
}
Lisp_Object
x_get_arg (dpyinfo, alist, param, attribute, class, type)
Display_Info *dpyinfo;
Lisp_Object alist, param;
char *attribute;
char *class;
enum resource_types type;
{
register Lisp_Object tem;
tem = Fassq (param, alist);
if (!NILP (tem))
{
#ifndef WINDOWSNT
Lisp_Object tail;
XSETCAR (tem, Qnil);
for (tail = alist; CONSP (tail); tail = XCDR (tail))
if (CONSP (XCAR (tail))
&& EQ (XCAR (XCAR (tail)), param))
XSETCAR (XCAR (tail), Qnil);
#endif
}
else
tem = Fassq (param, Vdefault_frame_alist);
if (EQ (tem, Qnil))
{
if (attribute)
{
tem = display_x_get_resource (dpyinfo,
build_string (attribute),
build_string (class),
Qnil, Qnil);
if (NILP (tem))
return Qunbound;
switch (type)
{
case RES_TYPE_NUMBER:
return make_number (atoi (SDATA (tem)));
case RES_TYPE_FLOAT:
return make_float (atof (SDATA (tem)));
case RES_TYPE_BOOLEAN:
tem = Fdowncase (tem);
if (!strcmp (SDATA (tem), "on")
|| !strcmp (SDATA (tem), "true"))
return Qt;
else
return Qnil;
case RES_TYPE_STRING:
return tem;
case RES_TYPE_SYMBOL:
{
Lisp_Object lower;
lower = Fdowncase (tem);
if (!strcmp (SDATA (lower), "on")
|| !strcmp (SDATA (lower), "true"))
return Qt;
else if (!strcmp (SDATA (lower), "off")
|| !strcmp (SDATA (lower), "false"))
return Qnil;
else
return Fintern (tem, Qnil);
}
default:
abort ();
}
}
else
return Qunbound;
}
return Fcdr (tem);
}
Lisp_Object
x_frame_get_arg (f, alist, param, attribute, class, type)
struct frame *f;
Lisp_Object alist, param;
char *attribute;
char *class;
enum resource_types type;
{
return x_get_arg (FRAME_X_DISPLAY_INFO (f),
alist, param, attribute, class, type);
}
Lisp_Object
x_frame_get_and_record_arg (f, alist, param, attribute, class, type)
struct frame *f;
Lisp_Object alist, param;
char *attribute;
char *class;
enum resource_types type;
{
Lisp_Object value;
value = x_get_arg (FRAME_X_DISPLAY_INFO (f), alist, param,
attribute, class, type);
if (! NILP (value) && ! EQ (value, Qunbound))
store_frame_param (f, param, value);
return value;
}
Lisp_Object
x_default_parameter (f, alist, prop, deflt, xprop, xclass, type)
struct frame *f;
Lisp_Object alist;
Lisp_Object prop;
Lisp_Object deflt;
char *xprop;
char *xclass;
enum resource_types type;
{
Lisp_Object tem;
tem = x_frame_get_arg (f, alist, prop, xprop, xclass, type);
if (EQ (tem, Qunbound))
tem = deflt;
x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
return tem;
}
DEFUN ("x-parse-geometry", Fx_parse_geometry, Sx_parse_geometry, 1, 1, 0,
doc: )
(string)
Lisp_Object string;
{
int geometry, x, y;
unsigned int width, height;
Lisp_Object result;
CHECK_STRING (string);
geometry = XParseGeometry ((char *) SDATA (string),
&x, &y, &width, &height);
#if 0
if (!!(geometry & XValue) != !!(geometry & YValue))
error ("Must specify both x and y position, or neither");
#endif
result = Qnil;
if (geometry & XValue)
{
Lisp_Object element;
if (x >= 0 && (geometry & XNegative))
element = Fcons (Qleft, Fcons (Qminus, Fcons (make_number (-x), Qnil)));
else if (x < 0 && ! (geometry & XNegative))
element = Fcons (Qleft, Fcons (Qplus, Fcons (make_number (x), Qnil)));
else
element = Fcons (Qleft, make_number (x));
result = Fcons (element, result);
}
if (geometry & YValue)
{
Lisp_Object element;
if (y >= 0 && (geometry & YNegative))
element = Fcons (Qtop, Fcons (Qminus, Fcons (make_number (-y), Qnil)));
else if (y < 0 && ! (geometry & YNegative))
element = Fcons (Qtop, Fcons (Qplus, Fcons (make_number (y), Qnil)));
else
element = Fcons (Qtop, make_number (y));
result = Fcons (element, result);
}
if (geometry & WidthValue)
result = Fcons (Fcons (Qwidth, make_number (width)), result);
if (geometry & HeightValue)
result = Fcons (Fcons (Qheight, make_number (height)), result);
return result;
}
#define DEFAULT_ROWS 40
#define DEFAULT_COLS 80
int
x_figure_window_size (f, parms, toolbar_p)
struct frame *f;
Lisp_Object parms;
int toolbar_p;
{
register Lisp_Object tem0, tem1, tem2;
long window_prompting = 0;
Display_Info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
SET_FRAME_COLS (f, DEFAULT_COLS);
FRAME_LINES (f) = DEFAULT_ROWS;
f->top_pos = 0;
f->left_pos = 0;
f->new_text_cols = f->new_text_lines = 0;
tem0 = x_get_arg (dpyinfo, parms, Qheight, 0, 0, RES_TYPE_NUMBER);
tem1 = x_get_arg (dpyinfo, parms, Qwidth, 0, 0, RES_TYPE_NUMBER);
tem2 = x_get_arg (dpyinfo, parms, Quser_size, 0, 0, RES_TYPE_NUMBER);
if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
{
if (!EQ (tem0, Qunbound))
{
CHECK_NUMBER (tem0);
FRAME_LINES (f) = XINT (tem0);
}
if (!EQ (tem1, Qunbound))
{
CHECK_NUMBER (tem1);
SET_FRAME_COLS (f, XINT (tem1));
}
if (!NILP (tem2) && !EQ (tem2, Qunbound))
window_prompting |= USSize;
else
window_prompting |= PSize;
}
f->scroll_bar_actual_width
= FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
if (toolbar_p && FRAME_TOOL_BAR_LINES (f))
{
int margin, relief, bar_height;
relief = (tool_bar_button_relief >= 0
? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF);
if (INTEGERP (Vtool_bar_button_margin)
&& XINT (Vtool_bar_button_margin) > 0)
margin = XFASTINT (Vtool_bar_button_margin);
else if (CONSP (Vtool_bar_button_margin)
&& INTEGERP (XCDR (Vtool_bar_button_margin))
&& XINT (XCDR (Vtool_bar_button_margin)) > 0)
margin = XFASTINT (XCDR (Vtool_bar_button_margin));
else
margin = 0;
bar_height = DEFAULT_TOOL_BAR_IMAGE_HEIGHT + 2 * margin + 2 * relief;
FRAME_LINES (f) += (bar_height + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
}
compute_fringe_widths (f, 0);
FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, FRAME_COLS (f));
FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
tem0 = x_get_arg (dpyinfo, parms, Qtop, 0, 0, RES_TYPE_NUMBER);
tem1 = x_get_arg (dpyinfo, parms, Qleft, 0, 0, RES_TYPE_NUMBER);
tem2 = x_get_arg (dpyinfo, parms, Quser_position, 0, 0, RES_TYPE_NUMBER);
if (! EQ (tem0, Qunbound) || ! EQ (tem1, Qunbound))
{
if (EQ (tem0, Qminus))
{
f->top_pos = 0;
window_prompting |= YNegative;
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qminus)
&& CONSP (XCDR (tem0))
&& INTEGERP (XCAR (XCDR (tem0))))
{
f->top_pos = - XINT (XCAR (XCDR (tem0)));
window_prompting |= YNegative;
}
else if (CONSP (tem0) && EQ (XCAR (tem0), Qplus)
&& CONSP (XCDR (tem0))
&& INTEGERP (XCAR (XCDR (tem0))))
{
f->top_pos = XINT (XCAR (XCDR (tem0)));
}
else if (EQ (tem0, Qunbound))
f->top_pos = 0;
else
{
CHECK_NUMBER (tem0);
f->top_pos = XINT (tem0);
if (f->top_pos < 0)
window_prompting |= YNegative;
}
if (EQ (tem1, Qminus))
{
f->left_pos = 0;
window_prompting |= XNegative;
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qminus)
&& CONSP (XCDR (tem1))
&& INTEGERP (XCAR (XCDR (tem1))))
{
f->left_pos = - XINT (XCAR (XCDR (tem1)));
window_prompting |= XNegative;
}
else if (CONSP (tem1) && EQ (XCAR (tem1), Qplus)
&& CONSP (XCDR (tem1))
&& INTEGERP (XCAR (XCDR (tem1))))
{
f->left_pos = XINT (XCAR (XCDR (tem1)));
}
else if (EQ (tem1, Qunbound))
f->left_pos = 0;
else
{
CHECK_NUMBER (tem1);
f->left_pos = XINT (tem1);
if (f->left_pos < 0)
window_prompting |= XNegative;
}
if (!NILP (tem2) && ! EQ (tem2, Qunbound))
window_prompting |= USPosition;
else
window_prompting |= PPosition;
}
if (f->want_fullscreen != FULLSCREEN_NONE)
{
int left, top;
int width, height;
window_prompting = USPosition | PPosition;
x_fullscreen_adjust (f, &width, &height, &top, &left);
FRAME_COLS (f) = width;
FRAME_LINES (f) = height;
FRAME_PIXEL_WIDTH (f) = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
FRAME_PIXEL_HEIGHT (f) = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
f->left_pos = left;
f->top_pos = top;
}
if (window_prompting & XNegative)
{
if (window_prompting & YNegative)
f->win_gravity = SouthEastGravity;
else
f->win_gravity = NorthEastGravity;
}
else
{
if (window_prompting & YNegative)
f->win_gravity = SouthWestGravity;
else
f->win_gravity = NorthWestGravity;
}
f->size_hint_flags = window_prompting;
return window_prompting;
}
#endif
void
syms_of_frame ()
{
Qframep = intern ("framep");
staticpro (&Qframep);
Qframe_live_p = intern ("frame-live-p");
staticpro (&Qframe_live_p);
Qheight = intern ("height");
staticpro (&Qheight);
Qicon = intern ("icon");
staticpro (&Qicon);
Qminibuffer = intern ("minibuffer");
staticpro (&Qminibuffer);
Qmodeline = intern ("modeline");
staticpro (&Qmodeline);
Qonly = intern ("only");
staticpro (&Qonly);
Qwidth = intern ("width");
staticpro (&Qwidth);
Qgeometry = intern ("geometry");
staticpro (&Qgeometry);
Qicon_left = intern ("icon-left");
staticpro (&Qicon_left);
Qicon_top = intern ("icon-top");
staticpro (&Qicon_top);
Qleft = intern ("left");
staticpro (&Qleft);
Qright = intern ("right");
staticpro (&Qright);
Quser_position = intern ("user-position");
staticpro (&Quser_position);
Quser_size = intern ("user-size");
staticpro (&Quser_size);
Qwindow_id = intern ("window-id");
staticpro (&Qwindow_id);
#ifdef HAVE_X_WINDOWS
Qouter_window_id = intern ("outer-window-id");
staticpro (&Qouter_window_id);
#endif
Qparent_id = intern ("parent-id");
staticpro (&Qparent_id);
Qx = intern ("x");
staticpro (&Qx);
Qw32 = intern ("w32");
staticpro (&Qw32);
Qpc = intern ("pc");
staticpro (&Qpc);
Qmac = intern ("mac");
staticpro (&Qmac);
Qvisible = intern ("visible");
staticpro (&Qvisible);
Qbuffer_predicate = intern ("buffer-predicate");
staticpro (&Qbuffer_predicate);
Qbuffer_list = intern ("buffer-list");
staticpro (&Qbuffer_list);
Qdisplay_type = intern ("display-type");
staticpro (&Qdisplay_type);
Qbackground_mode = intern ("background-mode");
staticpro (&Qbackground_mode);
Qtty_color_mode = intern ("tty-color-mode");
staticpro (&Qtty_color_mode);
Qface_set_after_frame_default = intern ("face-set-after-frame-default");
staticpro (&Qface_set_after_frame_default);
Qinhibit_face_set_after_frame_default
= intern ("inhibit-face-set-after-frame-default");
staticpro (&Qinhibit_face_set_after_frame_default);
Qfullwidth = intern ("fullwidth");
staticpro (&Qfullwidth);
Qfullheight = intern ("fullheight");
staticpro (&Qfullheight);
Qfullboth = intern ("fullboth");
staticpro (&Qfullboth);
Qx_resource_name = intern ("x-resource-name");
staticpro (&Qx_resource_name);
Qx_frame_parameter = intern ("x-frame-parameter");
staticpro (&Qx_frame_parameter);
{
int i;
for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
{
Lisp_Object v = intern (frame_parms[i].name);
if (frame_parms[i].variable)
{
*frame_parms[i].variable = v;
staticpro (frame_parms[i].variable);
}
Fput (v, Qx_frame_parameter, make_number (i));
}
}
#ifdef HAVE_WINDOW_SYSTEM
DEFVAR_LISP ("x-resource-name", &Vx_resource_name,
doc: );
Vx_resource_name = Qnil;
DEFVAR_LISP ("x-resource-class", &Vx_resource_class,
doc: );
Vx_resource_class = build_string (EMACS_CLASS);
#endif
DEFVAR_LISP ("default-frame-alist", &Vdefault_frame_alist,
doc: );
Vdefault_frame_alist = Qnil;
DEFVAR_LISP ("default-frame-scroll-bars", &Vdefault_frame_scroll_bars,
doc: );
#ifdef HAVE_WINDOW_SYSTEM
#if defined(HAVE_NTGUI) || defined(MAC_OS)
Vdefault_frame_scroll_bars = Qright;
#else
Vdefault_frame_scroll_bars = Qleft;
#endif
#else
Vdefault_frame_scroll_bars = Qnil;
#endif
DEFVAR_LISP ("terminal-frame", &Vterminal_frame,
doc: );
DEFVAR_LISP ("emacs-iconified", &Vemacs_iconified,
doc: );
Vemacs_iconified = Qnil;
DEFVAR_LISP ("mouse-position-function", &Vmouse_position_function,
doc: );
Vmouse_position_function = Qnil;
DEFVAR_LISP ("mouse-highlight", &Vmouse_highlight,
doc: );
Vmouse_highlight = Qt;
DEFVAR_LISP ("delete-frame-functions", &Vdelete_frame_functions,
doc: );
Vdelete_frame_functions = Qnil;
DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,
doc: );
staticpro (&Vframe_list);
defsubr (&Sactive_minibuffer_window);
defsubr (&Sframep);
defsubr (&Sframe_live_p);
defsubr (&Smake_terminal_frame);
defsubr (&Shandle_switch_frame);
defsubr (&Sselect_frame);
defsubr (&Sselected_frame);
defsubr (&Swindow_frame);
defsubr (&Sframe_root_window);
defsubr (&Sframe_first_window);
defsubr (&Sframe_selected_window);
defsubr (&Sset_frame_selected_window);
defsubr (&Sframe_list);
defsubr (&Snext_frame);
defsubr (&Sprevious_frame);
defsubr (&Sdelete_frame);
defsubr (&Smouse_position);
defsubr (&Smouse_pixel_position);
defsubr (&Sset_mouse_position);
defsubr (&Sset_mouse_pixel_position);
#if 0
defsubr (&Sframe_configuration);
defsubr (&Srestore_frame_configuration);
#endif
defsubr (&Smake_frame_visible);
defsubr (&Smake_frame_invisible);
defsubr (&Siconify_frame);
defsubr (&Sframe_visible_p);
defsubr (&Svisible_frame_list);
defsubr (&Sraise_frame);
defsubr (&Slower_frame);
defsubr (&Sredirect_frame_focus);
defsubr (&Sframe_focus);
defsubr (&Sframe_parameters);
defsubr (&Sframe_parameter);
defsubr (&Smodify_frame_parameters);
defsubr (&Sframe_char_height);
defsubr (&Sframe_char_width);
defsubr (&Sframe_pixel_height);
defsubr (&Sframe_pixel_width);
defsubr (&Sset_frame_height);
defsubr (&Sset_frame_width);
defsubr (&Sset_frame_size);
defsubr (&Sset_frame_position);
#ifdef HAVE_WINDOW_SYSTEM
defsubr (&Sx_get_resource);
defsubr (&Sx_parse_geometry);
#endif
}